Java ClassDescriptor.isInterface方法代码示例

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
private void buildManyToManyReferences(ClassDescriptor cd, CollectionDescriptor collectionDescriptor,
                                        Object keys[], Vector columns)
 {
     if(cd.isAbstract() || cd.isInterface())
     {
logger.debug( "Skip foreign key build for MtoM, found abstract base class or interface " + cd.getClassNameOfObject() );
         return;
     }
     StringBuffer buffer = new StringBuffer(256);
     buildForeignKeyHeader(cd.getFullTableName(), buffer);

     for (int i = 0; i < keys.length; i++) {
         String columnName = (String) keys[i];

         FieldDescriptor foreignColumn = cd.getPkFields()[i];
         String foreignColumnName = foreignColumn.getPersistentField().getName();
         buildReferenceForColumn(buffer, columnName, foreignColumnName);
         FieldDescriptor fieldDescriptor = (FieldDescriptor)foreignColumn.clone();
         fieldDescriptor.setColumnName(columnName);
         columns.add(fieldDescriptor);
     }
     buffer.append("        </foreign-key>\n");

     addReferenceToTable(collectionDescriptor.getIndirectionTable(), buffer.toString());
 }
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
private void linkOrUnlinkOneToOne(boolean doLink, Object obj, ObjectReferenceDescriptor ord, boolean insert)
{
    /*
    arminw: we need the class-descriptor where the reference is declared, thus we ask the
    reference-descriptor for this, instead of using the class-descriptor of the specified
    object. If the reference was declared within an interface (should never happen) we
    only can use the descriptor of the real class.
    */
    ClassDescriptor cld = ord.getClassDescriptor();
    if(cld.isInterface())
    {
        cld = m_broker.getDescriptorRepository().getDescriptorFor(ProxyHelper.getRealClass(obj));
    }

    if (doLink)
    {
        m_broker.linkOneToOne(obj, cld, ord, insert);
    }
    else
    {
        m_broker.unlinkFK(obj, cld, ord);
        // in 1:1 relation we have to set relation to null
        ord.getPersistentField().set(obj, null);
    }
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * try to find the first none null table name for the given class-descriptor.
 * If cld has extent classes, all of these cld's searched for the first none null
 * table name.
 */
private static String firstFoundTableName(PersistenceBroker brokerForClass, ClassDescriptor cld)
{
    String name = null;
    if (!cld.isInterface() && cld.getFullTableName() != null)
    {
        return cld.getFullTableName();
    }
    if (cld.isExtent())
    {
        Collection extentClasses = cld.getExtentClasses();
        for (Iterator iterator = extentClasses.iterator(); iterator.hasNext();)
        {
            name = firstFoundTableName(brokerForClass, brokerForClass.getClassDescriptor((Class) iterator.next()));
            // System.out.println("## " + cld.getClassNameOfObject()+" - name: "+name);
            if (name != null) break;
        }
    }
    return name;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
public void buildConstraintsMap() {
    Iterator classDescriptorIterators = this.repository.iterator();
    while (classDescriptorIterators.hasNext()) {
        ClassDescriptor cd = (ClassDescriptor) classDescriptorIterators.next();
        if(cd.isAbstract() || cd.isInterface())
        {
logger.debug( "Skip constraint build for abstract class/ interface " + cd.getClassNameOfObject() );
        }
        else
        {
            buildConstraints(cd);
            buildOneToOneConstraints(cd);
        }
    }
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
private void buildForeignKey(ClassDescriptor foreignClassDescriptor, Vector foreignKeyIndices, ClassDescriptor classDescriptor) {

        if(classDescriptor.isAbstract() || classDescriptor.isInterface())
        {
			logger.debug( "Skip foreign key build, found abstract base class or interface " + classDescriptor.getClassNameOfObject() );
            return;
        }
        StringBuffer buffer = new StringBuffer(256);
        buildForeignKeyHeader(foreignClassDescriptor.getFullTableName(), buffer);

        for (int i = 0; i < foreignKeyIndices.size(); i++) {
            String columnName = null;
            Object obj = foreignKeyIndices.get(i);

            if (obj instanceof Integer)
            {
                int foreignKeyIndex = ((Integer) obj).intValue();
                columnName = classDescriptor.getFieldDescriptorByIndex(foreignKeyIndex).getColumnName();
            }
            else
            {
                    FieldDescriptor fld = classDescriptor.getFieldDescriptorByName((String) obj);
                    if(fld == null)
                    {
						logger.debug( "FieldDescriptor for foreign key parameter \n" + obj + " was not found in ClassDescriptor \n" + classDescriptor );
                    }
                    else columnName = fld.getColumnName();
            }

            FieldDescriptor foreignColumn = foreignClassDescriptor.getPkFields()[i];
            String foreignColumnName = foreignColumn.getColumnName();
            buildReferenceForColumn(buffer, columnName, foreignColumnName);
        }
        buffer.append("        </foreign-key>\n");
        addReferenceToTable(classDescriptor.getFullTableName(), buffer.toString());
    }
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
public void buildStandardTables() {
    Iterator classDescriptorIterators = this.repository.iterator();
    while (classDescriptorIterators.hasNext()) {
        ClassDescriptor cd = (ClassDescriptor) classDescriptorIterators.next();
        if(cd.isAbstract() || cd.isInterface())
        {
            System.out.println("Skip table build for abstract base class / interface called "+cd.getClassNameOfObject());
        }
        else
        {
            buildStandardTable(cd);
        }
    }
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * Retrieve an plain object (without populated references) by it's identity
 * from the database
 *
 * @param cld the real {@link org.apache.ojb.broker.metadata.ClassDescriptor} of the object to refresh
 * @param oid the {@link org.apache.ojb.broker.Identity} of the object
 * @return A new plain object read from the database or <em>null</em> if not found
 * @throws ClassNotPersistenceCapableException
 */
private Object getPlainDBObject(ClassDescriptor cld, Identity oid) throws ClassNotPersistenceCapableException
{
    Object newObj = null;

    // Class is NOT an Interface: it has a directly mapped table and we lookup this table first:
    if (!cld.isInterface())
    {
        // 1. try to retrieve skalar fields from directly mapped table columns
        newObj = dbAccess.materializeObject(cld, oid);
    }

    // if we did not find the object yet AND if the cld represents an Extent,
    // we can lookup all tables of the extent classes:
    if (newObj == null && cld.isExtent())
    {
        Iterator extents = getDescriptorRepository().getAllConcreteSubclassDescriptors(cld).iterator();

        while (extents.hasNext())
        {
            ClassDescriptor extCld = (ClassDescriptor) extents.next();

            newObj = dbAccess.materializeObject(extCld, oid);
            if (newObj != null)
            {
                break;
            }
        }
    }
    return newObj;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * Search down all extent classes and return max of all found
 * PK values.
 */
public static long getMaxId(PersistenceBroker brokerForClass, Class topLevel, FieldDescriptor original) throws PersistenceBrokerException
{
    long max = 0;
    long tmp;
    ClassDescriptor cld = brokerForClass.getClassDescriptor(topLevel);

    // if class is not an interface / not abstract we have to search its directly mapped table
    if (!cld.isInterface() && !cld.isAbstract())
    {
        tmp = getMaxIdForClass(brokerForClass, cld, original);
        if (tmp > max)
        {
            max = tmp;
        }
    }
    // if class is an extent we have to search through its subclasses
    if (cld.isExtent())
    {
        Vector extentClasses = cld.getExtentClasses();
        for (int i = 0; i < extentClasses.size(); i++)
        {
            Class extentClass = (Class) extentClasses.get(i);
            if (cld.getClassOfObject().equals(extentClass))
            {
                throw new PersistenceBrokerException("Circular extent in " + extentClass +
                        ", please check the repository");
            }
            else
            {
                // fix by Mark Rowell
                // Call recursive
                tmp = getMaxId(brokerForClass, extentClass, original);
            }
            if (tmp > max)
            {
                max = tmp;
            }
        }
    }
    return max;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * Extent aware Delete by Query
 * @param query
 * @param cld
 * @throws PersistenceBrokerException
 */
private void deleteByQuery(Query query, ClassDescriptor cld) throws PersistenceBrokerException
{
    if (logger.isDebugEnabled())
    {
        logger.debug("deleteByQuery " + cld.getClassNameOfObject() + ", " + query);
    }

    if (query instanceof QueryBySQL)
    {
        String sql = ((QueryBySQL) query).getSql();
        this.dbAccess.executeUpdateSQL(sql, cld);
    }
    else
    {
        // if query is Identity based transform it to a criteria based query first
        if (query instanceof QueryByIdentity)
        {
            QueryByIdentity qbi = (QueryByIdentity) query;
            Object oid = qbi.getExampleObject();
            // make sure it's an Identity
            if (!(oid instanceof Identity))
            {
                oid = serviceIdentity().buildIdentity(oid);
            }
            query = referencesBroker.getPKQuery((Identity) oid);
        }

        if (!cld.isInterface())
        {
            this.dbAccess.executeDelete(query, cld);
        }

        // if class is an extent, we have to delete all extent classes too
        String lastUsedTable = cld.getFullTableName();
        if (cld.isExtent())
        {
            Iterator extents = getDescriptorRepository().getAllConcreteSubclassDescriptors(cld).iterator();

            while (extents.hasNext())
            {
                ClassDescriptor extCld = (ClassDescriptor) extents.next();

                // read same table only once
                if (!extCld.getFullTableName().equals(lastUsedTable))
                {
                    lastUsedTable = extCld.getFullTableName();
                    this.dbAccess.executeDelete(query, extCld);
                }
            }
        }

    }
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * Get an extent aware RsIterator based on the Query
 *
 * @param query
 * @param cld
 * @param factory the Factory for the RsIterator
 * @return OJBIterator
 */
private OJBIterator getRsIteratorFromQuery(Query query, ClassDescriptor cld, RsIteratorFactory factory)
    throws PersistenceBrokerException
{
    query.setFetchSize(1);
    if (query instanceof QueryBySQL)
    {
        if(logger.isDebugEnabled()) logger.debug("Creating SQL-RsIterator for class ["+cld.getClassNameOfObject()+"]");
        return factory.createRsIterator((QueryBySQL) query, cld, this);
    }

    if (!cld.isExtent() || !query.getWithExtents())
    {
        // no extents just use the plain vanilla RsIterator
        if(logger.isDebugEnabled()) logger.debug("Creating RsIterator for class ["+cld.getClassNameOfObject()+"]");

        return factory.createRsIterator(query, cld, this);
    }

    if(logger.isDebugEnabled()) logger.debug("Creating ChainingIterator for class ["+cld.getClassNameOfObject()+"]");

    ChainingIterator chainingIter = new ChainingIterator();

    // BRJ: add base class iterator
    if (!cld.isInterface())
    {
        if(logger.isDebugEnabled()) logger.debug("Adding RsIterator for class ["+cld.getClassNameOfObject()+"] to ChainingIterator");

        chainingIter.addIterator(factory.createRsIterator(query, cld, this));
    }

    Iterator extents = getDescriptorRepository().getAllConcreteSubclassDescriptors(cld).iterator();
    while (extents.hasNext())
    {
        ClassDescriptor extCld = (ClassDescriptor) extents.next();

        // read same table only once
        if (chainingIter.containsIteratorForTable(extCld.getFullTableName()))
        {
            if(logger.isDebugEnabled()) logger.debug("Skipping class ["+extCld.getClassNameOfObject()+"]");
        }
        else
        {
            if(logger.isDebugEnabled()) logger.debug("Adding RsIterator of class ["+extCld.getClassNameOfObject()+"] to ChainingIterator");

            // add the iterator to the chaining iterator.
            chainingIter.addIterator(factory.createRsIterator(query, extCld, this));
        }
    }

    return chainingIter;
}