Java ClassDescriptor.getObjectReferenceDescriptors方法代码示例

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
    *
    * @see org.kuali.rice.krad.service.PersistenceService#refreshAllNonUpdatingReferences(org.kuali.rice.krad.bo.BusinessObject)
    */
   @Override
public void refreshAllNonUpdatingReferences(PersistableBusinessObject bo) {

       // get the OJB class-descriptor for the bo class
       ClassDescriptor classDescriptor = getClassDescriptor(bo.getClass());

       // get a list of all reference-descriptors for that class
       Vector references = classDescriptor.getObjectReferenceDescriptors();

       // walk through all of the reference-descriptors
       for (Iterator iter = references.iterator(); iter.hasNext();) {
           ObjectReferenceDescriptor reference = (ObjectReferenceDescriptor) iter.next();

           // if its NOT an updateable reference, then lets refresh it
           if (reference.getCascadingStore() == ObjectReferenceDescriptor.CASCADE_NONE) {
               PersistentField persistentField = reference.getPersistentField();
               String referenceName = persistentField.getName();
               retrieveReferenceObject(bo, referenceName);
           }
       }
   }
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * @see org.kuali.rice.krad.service.PersistenceService#getReferencesForForeignKey(java.lang.Class,
 *      java.lang.String)
 */

@Override
public Map getReferencesForForeignKey(Class persistableObjectClass, String attributeName) {
	Map referenceClasses = new HashMap();
	if (PersistableBusinessObject.class.isAssignableFrom(persistableObjectClass)) {
		ClassDescriptor classDescriptor = getClassDescriptor(persistableObjectClass);
		Vector objectReferences = classDescriptor.getObjectReferenceDescriptors();
		for (Iterator iter = objectReferences.iterator(); iter.hasNext();) {
			ObjectReferenceDescriptor referenceDescriptor = (ObjectReferenceDescriptor) iter.next();

			/*
			 * iterate through the fk keys for the reference object and if
			 * matches the attributeName add the class as a reference
			 */
			FieldDescriptor[] refFkNames = referenceDescriptor.getForeignKeyFieldDescriptors(classDescriptor);
			for (int i = 0; i < refFkNames.length; i++) {
				FieldDescriptor fkField = refFkNames[i];
				if (fkField.getAttributeName().equals(attributeName)) {
					referenceClasses.put(referenceDescriptor.getAttributeName(), referenceDescriptor.getItemClass());
				}
			}
		}
	}
	return referenceClasses;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * @see org.kuali.rice.krad.service.PersistenceService#getNestedForeignKeyMap(java.lang.Class)
 */

@Override
public Map getNestedForeignKeyMap(Class persistableObjectClass) {
	Map fkMap = new HashMap();
	ClassDescriptor classDescriptor = getClassDescriptor(persistableObjectClass);
	Vector objectReferences = classDescriptor.getObjectReferenceDescriptors();
	for (Iterator iter = objectReferences.iterator(); iter.hasNext();) {
		ObjectReferenceDescriptor objectReferenceDescriptor = (ObjectReferenceDescriptor) iter.next();
		ClassDescriptor referenceDescriptor = this.getClassDescriptor(objectReferenceDescriptor.getItemClass());

		FieldDescriptor[] fkFields = objectReferenceDescriptor.getForeignKeyFieldDescriptors(classDescriptor);
		FieldDescriptor[] pkFields = referenceDescriptor.getPkFields();
		for (int i = 0; i < pkFields.length; i++) {
			FieldDescriptor pkField = pkFields[i];
			fkMap.put(objectReferenceDescriptor.getAttributeName() + "." + pkField.getAttributeName(), fkFields[i].getAttributeName());
		}
	}

	return fkMap;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * @see org.kuali.rice.krad.service.PersistenceStructureService#listReferenceObjectFieldNames(java.lang.Class)
 */

@Override
public Map<String, Class> listReferenceObjectFields(Class boClass) {
	// validate parameter
	if (boClass == null) {
		throw new IllegalArgumentException("Class specified in the parameter was null.");
	}

	Map<String, Class> references = new HashMap<String, Class>();
	ClassDescriptor classDescriptor = getClassDescriptor(boClass);
	Collection<ObjectReferenceDescriptor> referenceDescriptors = classDescriptor.getObjectReferenceDescriptors(true);

	for (ObjectReferenceDescriptor referenceDescriptor : referenceDescriptors) {
		/*
            * Below check is performed for OJB specific inheritance implementation. For more information see the OJB
            * documentation: http://db.apache.org/ojb/docu/guides/advanced-technique.html#table-per-subclass
            */
           String superReferenceDescriptor = referenceDescriptor.getAttributeName();
           if (!SuperReferenceDescriptor.SUPER_FIELD_INTERNAL_NAME.equals(superReferenceDescriptor)) {
               references.put(superReferenceDescriptor, referenceDescriptor.getItemClass());
           }
	}

	return references;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
private static void getMappedTree(String rootClass, Collection<DescriptorRepository> descriptorRepositories, Set<String> processed) {
    if (processed.contains(rootClass)) {
        return;
    }

    processed.add(rootClass);
    final ClassDescriptor cd = findClassDescriptor(rootClass, descriptorRepositories);
    if (cd != null) {
        final Collection<ObjectReferenceDescriptor> ords = cd.getObjectReferenceDescriptors();
        if (ords != null) {
            for (ObjectReferenceDescriptor ord : ords) {
                getMappedTree(ord.getItemClassName(), descriptorRepositories, processed);
            }
        }

        final Collection<CollectionDescriptor> clds = cd.getCollectionDescriptors();
        if (clds != null) {
            for (ObjectReferenceDescriptor cld : clds) {
                getMappedTree(cld.getItemClassName(), descriptorRepositories, processed);
            }
        }

    } else {
        LOG.warn("ClassDescriptor not found for " + rootClass);
    }
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * Walk through the object graph of the specified delete object. Was used for
 * recursive object graph walk.
 */
private void cascadeDeleteFor(ObjectEnvelope mod, List alreadyPrepared)
{
    // avoid endless recursion
    if(alreadyPrepared.contains(mod.getIdentity())) return;

    alreadyPrepared.add(mod.getIdentity());

    ClassDescriptor cld = getTransaction().getBroker().getClassDescriptor(mod.getObject().getClass());

    List refs = cld.getObjectReferenceDescriptors(true);
    cascadeDeleteSingleReferences(mod, refs, alreadyPrepared);

    List colls = cld.getCollectionDescriptors(true);
    cascadeDeleteCollectionReferences(mod, colls, alreadyPrepared);
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * Store all object references that <b>obj</b> points to.
 * All objects which we have a FK pointing to (Via ReferenceDescriptors) will be
 * stored if auto-update is true <b>AND</b> the member field containing the object
 * reference is NOT null.
 * With flag <em>ignoreReferences</em> the storing/linking
 * of references can be suppressed (independent of the used auto-update setting),
 * except {@link org.apache.ojb.broker.metadata.SuperReferenceDescriptor}
 * these kind of reference (descriptor) will always be performed.
 *
 * @param obj Object which we will store references for
 */
private void storeReferences(Object obj, ClassDescriptor cld, boolean insert, boolean ignoreReferences)
{
    // get all members of obj that are references and store them
    Collection listRds = cld.getObjectReferenceDescriptors();
    // return if nothing to do
    if(listRds == null || listRds.size() == 0)
    {
        return;
    }
    Iterator i = listRds.iterator();
    while (i.hasNext())
    {
        ObjectReferenceDescriptor rds = (ObjectReferenceDescriptor) i.next();
        /*
        arminw: the super-references (used for table per subclass inheritance) must
        be performed in any case. The "normal" 1:1 references can be ignored when
        flag "ignoreReferences" is set
        */
        if((!ignoreReferences && rds.getCascadingStore() != ObjectReferenceDescriptor.CASCADE_NONE)
                || rds.isSuperReferenceDescriptor())
        {
            storeAndLinkOneToOne(false, obj, cld, rds, insert);
        }
    }
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * @see org.kuali.rice.krad.service.PersistenceService#getRelationshipMetadata(java.lang.Class,
 *      java.lang.String)
 */

@Override
public Map<String, DataObjectRelationship> getRelationshipMetadata(Class persistableClass, String attributeName, String attributePrefix) {
	if (persistableClass == null) {
		throw new IllegalArgumentException("invalid (null) persistableClass");
	}
	if (StringUtils.isBlank(attributeName)) {
		throw new IllegalArgumentException("invalid (blank) attributeName");
	}

	Map<String, DataObjectRelationship> relationships = new HashMap<String, DataObjectRelationship>();
	ClassDescriptor classDescriptor = getClassDescriptor(persistableClass);
	Vector<ObjectReferenceDescriptor> references = classDescriptor.getObjectReferenceDescriptors();
	for (ObjectReferenceDescriptor objRef : references) {
		Vector fks = objRef.getForeignKeyFields();
		if (fks.contains(attributeName) || objRef.getAttributeName().equals(attributeName)) {
			Map<String, String> fkToPkRefs = getForeignKeysForReference(persistableClass, objRef.getAttributeName());
			DataObjectRelationship rel = new DataObjectRelationship(persistableClass, objRef.getAttributeName(), objRef.getItemClass());
			for (Map.Entry<String, String> ref : fkToPkRefs.entrySet()) {
				if (StringUtils.isBlank(attributePrefix)) {
					rel.getParentToChildReferences().put(ref.getKey(), ref.getValue());
				} else {
					rel.getParentToChildReferences().put(attributePrefix + "." + ref.getKey(), ref.getValue());
				}
			}
			relationships.put(objRef.getAttributeName(), rel);
		}
	}
	return relationships;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
private boolean isBidirectional(String thisClass, String itemClass) {
    final ClassDescriptor cd = OjbUtil.findClassDescriptor(itemClass, descriptorRepositories);
    if (cd != null) {
        Collection<ObjectReferenceDescriptor> ords = cd.getObjectReferenceDescriptors();
        if (ords != null) {
            for (ObjectReferenceDescriptor ord : ords) {
                if (ord.getItemClassName().equals(thisClass)) {
                    return true;
                }
            }
        }
    }
    return false;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
private String getMappedBy(String thisClass, String itemClass) {
    final ClassDescriptor cd = OjbUtil.findClassDescriptor(itemClass, descriptorRepositories);
    if (cd != null) {
        Collection<ObjectReferenceDescriptor> ords = cd.getObjectReferenceDescriptors();
        if (ords != null) {
            for (ObjectReferenceDescriptor ord : ords) {
                if (ord.getItemClassName().equals(thisClass)) {
                    return ord.getAttributeName();
                }
            }
        }
    }
    return null;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
private boolean isBidirectional(String thisClass, String itemClass) {
    final ClassDescriptor cd = OjbUtil.findClassDescriptor(itemClass, descriptorRepositories);
    Collection<ObjectReferenceDescriptor> ords = cd.getObjectReferenceDescriptors();
    if (ords != null) {
        for (ObjectReferenceDescriptor ord : ords) {
            if (ord.getItemClassName().equals(thisClass)) {
                return true;
            }
        }
    }
    return false;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
private String getMappedBy(String thisClass, String itemClass) {
    final ClassDescriptor cd = OjbUtil.findClassDescriptor(itemClass, descriptorRepositories);
    Collection<ObjectReferenceDescriptor> ords = cd.getObjectReferenceDescriptors();
    if (ords != null) {
        for (ObjectReferenceDescriptor ord : ords) {
            if (ord.getItemClassName().equals(thisClass)) {
                return ord.getAttributeName();
            }
        }
    }
    return null;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * Walk through the object graph of the specified insert object. Was used for
 * recursive object graph walk.
 */
private void cascadeInsertFor(ObjectEnvelope mod, List alreadyPrepared)
{
    // avoid endless recursion, so use List for registration
    if(alreadyPrepared.contains(mod.getIdentity())) return;
    alreadyPrepared.add(mod.getIdentity());

    ClassDescriptor cld = getTransaction().getBroker().getClassDescriptor(mod.getObject().getClass());

    List refs = cld.getObjectReferenceDescriptors(true);
    cascadeInsertSingleReferences(mod, refs, alreadyPrepared);

    List colls = cld.getCollectionDescriptors(true);
    cascadeInsertCollectionReferences(mod, colls, alreadyPrepared);
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
private void buildOneToOneConstraints(ClassDescriptor classDescriptor) {
    Vector referenceDescriptors = classDescriptor.getObjectReferenceDescriptors();
    for (int i = 0; i < referenceDescriptors.size(); i++) {
        ObjectReferenceDescriptor ord = (ObjectReferenceDescriptor) referenceDescriptors.get(i);

        Vector foreignKeyIndices = ord.getForeignKeyFields();
        ClassDescriptor foreignClassDescriptor = this.repository.getDescriptorFor(ord.getItemClass());
        buildForeignKey(foreignClassDescriptor, foreignKeyIndices, classDescriptor);
    }
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * Deletes references that <b>obj</b> points to.
 * All objects which we have a FK poiting to (Via ReferenceDescriptors)
 * will be deleted if auto-delete is true <b>AND</b>
 * the member field containing the object reference is NOT null.
 *
 * @param obj Object which we will delete references for
 * @param listRds list of ObjectRederenceDescriptors
 * @param ignoreReferences With this flag the automatic deletion/unlinking
 * of references can be suppressed (independent of the used auto-delete setting in metadata),
 * except {@link org.apache.ojb.broker.metadata.SuperReferenceDescriptor}
 * these kind of reference (descriptor) will always be performed.
 * @throws PersistenceBrokerException if some goes wrong - please see the error message for details
 */
private void deleteReferences(ClassDescriptor cld, Object obj, Identity oid, boolean ignoreReferences) throws PersistenceBrokerException
{
	List listRds = cld.getObjectReferenceDescriptors();
    // get all members of obj that are references and delete them
    Iterator i = listRds.iterator();
    while (i.hasNext())
    {
        ObjectReferenceDescriptor rds = (ObjectReferenceDescriptor) i.next();
        if ((!ignoreReferences && rds.getCascadingDelete() == ObjectReferenceDescriptor.CASCADE_OBJECT)
                || rds.isSuperReferenceDescriptor())
        {
            Object referencedObject = rds.getPersistentField().get(obj);
            if (referencedObject != null)
            {
            	if(rds.isSuperReferenceDescriptor())
            	{
            		ClassDescriptor base = cld.getSuperClassDescriptor();
            		/*
	                 arminw: If "table-per-subclass" inheritance is used we have to
	                 guarantee that all super-class table entries are deleted too.
	                 Thus we have to perform the recursive deletion of all super-class
	                 table entries.
            		 */
            		performDeletion(base, referencedObject, oid, ignoreReferences);
            	}
            	else
            	{
            		doDelete(referencedObject, ignoreReferences);
            	}
            }
        }
    }
}