Java ClassDescriptor类代码示例

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包/类
private Object getReferenceFKValue(Object persistableObject, ObjectReferenceDescriptor chkRefCld, String fkName) {
    ClassDescriptor classDescriptor = getClassDescriptor(persistableObject.getClass());
    Object referenceObject = ObjectUtils.getPropertyValue(persistableObject, chkRefCld.getAttributeName());

    if (referenceObject == null) {
        return null;
    }

    FieldDescriptor[] refFkNames = chkRefCld.getForeignKeyFieldDescriptors(classDescriptor);
    ClassDescriptor refCld = getClassDescriptor(chkRefCld.getItemClass());
    FieldDescriptor[] refPkNames = refCld.getPkFields();


    Object fkValue = null;
    for (int i = 0; i < refFkNames.length; i++) {
        FieldDescriptor fkField = refFkNames[i];

        if (fkField.getAttributeName().equals(fkName)) {
            fkValue = ObjectUtils.getPropertyValue(referenceObject, refPkNames[i].getAttributeName());
            break;
        }
    }

    return fkValue;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入依赖的package包/类
/**
 * @param persistableClass
 * @return ClassDescriptor for the given Class
 * @throws IllegalArgumentException
 *             if the given Class is null
 * @throws ClassNotPersistableException
 *             if the given Class is unknown to OJB
 */
// Legacy OJB - no need for JPA equivalent
protected ClassDescriptor getClassDescriptor(Class persistableClass) {
	if (persistableClass == null) {
		throw new IllegalArgumentException("invalid (null) object");
	}

	ClassDescriptor classDescriptor = null;
	DescriptorRepository globalRepository = getDescriptorRepository();
	try {
		classDescriptor = globalRepository.getDescriptorFor(persistableClass);
	} catch (ClassNotPersistenceCapableException e) {
		throw new ClassNotPersistableException("class '" + persistableClass.getName() + "' is not persistable", e);
	}

	return classDescriptor;
}
 

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

// Unit tests only
@Override
public List listPersistableSubclasses(Class superclazz) {
	if (superclazz == null) {
		throw new IllegalArgumentException("invalid (null) uberclass");
	}

	Map allDescriptors = getDescriptorRepository().getDescriptorTable();
	List persistableSubclasses = new ArrayList();
	for (Iterator i = allDescriptors.entrySet().iterator(); i.hasNext();) {
		Map.Entry e = (Map.Entry) i.next();

		Class persistableClass = ((ClassDescriptor) e.getValue()).getClassOfObject();
		if (!superclazz.equals(persistableClass) && superclazz.isAssignableFrom(persistableClass)) {
			persistableSubclasses.add(persistableClass);
		}
	}
	return persistableSubclasses;
}
 

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

@Override
public String getForeignKeyFieldName(Class persistableObjectClass, String attributeName, String pkName) {
	String fkName = "";
	ClassDescriptor classDescriptor = getClassDescriptor(persistableObjectClass);
	ObjectReferenceDescriptor objectReferenceDescriptor = classDescriptor.getObjectReferenceDescriptorByName(attributeName);
	if (objectReferenceDescriptor == null) {
		throw new RuntimeException("Attribute name " + attributeName + " is not a valid reference to class " + persistableObjectClass.getName());
	}
	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];
		if (pkField.getAttributeName().equals(pkName)) {
			fkName = fkFields[i].getAttributeName();
		}
	}
	return fkName;
}
 

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包/类
@Override
public Map<String, Class> listCollectionObjectTypes(Class boClass) {
	if (boClass == null) {
		throw new IllegalArgumentException("Class specified in the parameter was null.");
	}

	Map<String, Class> references = new HashMap<String, Class>();
	ClassDescriptor classDescriptor = null;
	try {
		classDescriptor = getClassDescriptor(boClass);
	} catch (ClassNotPersistableException cnpe) {
		return references;
	}

	Collection<CollectionDescriptor> collectionDescriptors = classDescriptor.getCollectionDescriptors(true);
	for (CollectionDescriptor collectionDescriptor : collectionDescriptors) {
		references.put(collectionDescriptor.getAttributeName(), collectionDescriptor.getItemClass());
	}

	return references;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入依赖的package包/类
private Collection<FieldDescriptor> getPrimaryKeyDescriptors(String clazz) {
    final Collection<FieldDescriptor> pks = new ArrayList<FieldDescriptor>();

    final ClassDescriptor cd = OjbUtil.findClassDescriptor(clazz, descriptorRepositories);
    if (cd != null) {
        //This causes a stackoverflow and appears to not work correctly
        //return cd.getPkFields().length > 1;
        int i = 0;
        FieldDescriptor[] fds = cd.getFieldDescriptions();
        if (fds != null) {
            for (FieldDescriptor fd : fds) {
                if (fd.isPrimaryKey()) {
                    pks.add(fd);
                }
            }
        }
    }
    return pks;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入依赖的package包/类
@Override
public NodeData resolve(Node node, String mappedClass) {
    if (!(node instanceof ClassOrInterfaceDeclaration)) {
        throw new IllegalArgumentException("this annotation belongs only on ClassOrInterfaceDeclaration");
    }

    final TypeDeclaration dclr = (TypeDeclaration) node;
    if (!(dclr.getParentNode() instanceof CompilationUnit)) {
        //handling nested classes
        return null;
    }

    final String name = dclr.getName();
    final String pckg = ((CompilationUnit) dclr.getParentNode()).getPackage().getName().toString();
    final String enclosingClass = pckg + "." + name;

    final ClassDescriptor cd = OjbUtil.findClassDescriptor(enclosingClass, descriptorRepositories);
    if (cd != null) {
        return new NodeData(new MarkerAnnotationExpr(new NameExpr(SIMPLE_NAME)),
                new ImportDeclaration(new QualifiedNameExpr(new NameExpr(PACKAGE), SIMPLE_NAME), false, false));
    }

    return null;
}
 

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包/类
public SqlStatement getPreparedExistsStatement(ClassDescriptor cld)
{
    SqlStatement sql;
    SqlForClass sfc = getSqlForClass(cld);
    sql = sfc.getSelectExists();
    if(sql == null)
    {
        // TODO: Should we support a procedure call for this too??
        sql = new SqlExistStatement(cld, logger);
        // set the sql string
        sfc.setSelectExists(sql);
        if(logger.isDebugEnabled())
        {
            logger.debug("SQL:" + sql.getStatement());
        }
    }
    return sql;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入依赖的package包/类
/**
 * Answer the SQL-Clause for a SelectionCriteria
 *
 * @param c SelectionCriteria
 * @param cld ClassDescriptor
 */
protected String asSQLClause(SelectionCriteria c, ClassDescriptor cld)
{
    if (c instanceof FieldCriteria)
        return toSQLClause((FieldCriteria) c, cld);

    if (c instanceof NullCriteria)
        return toSQLClause((NullCriteria) c);

    if (c instanceof BetweenCriteria)
        return toSQLClause((BetweenCriteria) c, cld);

    if (c instanceof InCriteria)
        return toSQLClause((InCriteria) c);

    if (c instanceof SqlCriteria)
        return toSQLClause((SqlCriteria) c);

    if (c instanceof ExistsCriteria)
        return toSQLClause((ExistsCriteria) c, cld);

    return toSQLClause(c, cld);
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入依赖的package包/类
/**
 * Calls the stored procedure stored procedure throws an
 * error if it doesn't exist.
 * @param broker
 * @param cld
 * @param sequenceName
 * @return
 * @throws LookupException
 * @throws SQLException
 */
protected long buildNextSequence(PersistenceBroker broker, ClassDescriptor cld, String sequenceName)
        throws LookupException, SQLException, PlatformException
{
    CallableStatement cs = null;
    try
    {
        Connection con = broker.serviceConnectionManager().getConnection();
        cs = getPlatform().prepareNextValProcedureStatement(con, PROCEDURE_NAME, sequenceName);
        cs.executeUpdate();
        return cs.getLong(1);
    }
    finally
    {
        try
        {
            if (cs != null)
                cs.close();
        }
        catch (SQLException ignore)
        {
            // ignore it
        }
    }
}