private Object getEntityId(Object obj, HibernateTemplate ht) throws IllegalAccessException, InvocationTargetException { ClassMetadata cm = ht.getSessionFactory().getClassMetadata(superClass); String idCol = cm.getIdentifierPropertyName(); PropertyDescriptor idPropDescr = BeanUtils.getPropertyDescriptor(superClass, idCol); return idPropDescr.getReadMethod().invoke(obj); }
/** * Returns <code>true</code> if the entity name needs to be filtered. * * <p>Implementation filteres out inherited hibernate mappings, since the select query for the * base class will cover any inherited classes as well. * * <p>Note, that this method is called after it has been verified that the class has Compass * mappings (either directly, or indirectly by an interface or a super class). * * @param entityname The name of the entity * @param classMetadata The Hibernate class meta data. * @param device The Jpa Gps device * @return <code>true</code> if the entity should be filtered out, <code>false</code> if not. */ protected boolean shouldFilter( String entityname, ClassMetadata classMetadata, Map allClassMetaData, JpaGpsDevice device) { Class<?> clazz = classMetadata.getMappedClass(); // if it is inherited, do not add it to the classes to index, since the "from [entity]" // query for the base class will return results for this class as well if (classMetadata.isInherited()) { String superClassEntityName = ((AbstractEntityPersister) classMetadata).getMappedSuperclass(); ClassMetadata superClassMetadata = (ClassMetadata) allClassMetaData.get(superClassEntityName); Class superClass = superClassMetadata.getMappedClass(); // only filter out classes that their super class has compass mappings if (superClass != null && ((CompassGpsInterfaceDevice) device.getGps()) .hasMappingForEntityForIndex(superClass)) { if (log.isDebugEnabled()) { log.debug( "Entity [" + entityname + "] is inherited and super class [" + superClass + "] has compass mapping, filtering it out"); } return true; } } return false; }
/** * Takes a class name as a string and find that class and all of its subclasses (transitively) * returns them as a list. */ private static List<Class<?>> hierarchy(Map<String, ClassMetadata> m, String key) { final List<Class<?>> h = new ArrayList<Class<?>>(); ClassMetadata cm = m.get(key); Class<?> c = cm.getMappedClass(EntityMode.POJO); h.add(c); int index = 0; while (index < h.size()) { for (String key2 : m.keySet()) { if (key.equals(key2)) { continue; } else { cm = m.get(key2); c = cm.getMappedClass(EntityMode.POJO); if (c.getSuperclass().equals(h.get(index))) { h.add(c); } } } index++; } return h; }
/** * Parse the {@link DataAccessException} to see if special problems were encountered while * performing the query. See issue NMS-5029 for examples of stack traces that can be thrown from * these calls. {@see http://issues.opennms.org/browse/NMS-5029} */ private void logExtraSaveOrUpdateExceptionInformation( final T entity, final DataAccessException e) { Throwable cause = e; while (cause.getCause() != null) { // if (cause.getCause().getClass().getName().equals(PSQLException.class.getName())) { if (cause.getMessage().contains("duplicate key value violates unique constraint")) { final ClassMetadata meta = getSessionFactory().getClassMetadata(m_entityClass); LogUtils.warnf( this, "Duplicate key constraint violation, class: %s, key value: %s", m_entityClass.getName(), meta.getPropertyValue(entity, meta.getIdentifierPropertyName(), EntityMode.POJO)); break; } else if (cause.getMessage().contains("given object has a null identifier")) { LogUtils.warnf( this, "Null identifier on object, class: %s: %s", m_entityClass.getName(), entity.toString()); break; } // } cause = cause.getCause(); } }
/** 取得对象的主键名,辅助函数. */ public String getIdName(Class<T> clazz) { Assert.notNull(clazz); ClassMetadata meta = getSessionFactory().getClassMetadata(clazz); Assert.notNull(meta, "Class " + clazz + " not define in hibernate session factory."); String idName = meta.getIdentifierPropertyName(); Assert.hasText(idName, clazz.getSimpleName() + " has no identifier property define."); return idName; }
/** * @param writer * @param includeHistory * @param session * @throws DataAccessException * @throws HibernateException */ private void writeObjects( final Writer writer, final boolean includeHistory, final Session session, final boolean preserveIds) throws DataAccessException, HibernateException { // Container für die Objekte final List<Object> all = new ArrayList<Object>(); final XStream stream = initXStream(session, true); final XStream defaultXStream = initXStream(session, false); session.flush(); // Alles laden List<?> list = session.createQuery("select o from java.lang.Object o").setReadOnly(true).list(); list = (List<?>) CollectionUtils.select(list, PredicateUtils.uniquePredicate()); final int size = list.size(); log.info("Writing " + size + " objects"); for (final Iterator<?> it = list.iterator(); it.hasNext(); ) { final Object obj = it.next(); if (log.isDebugEnabled()) { log.debug("loaded object " + obj); } if ((obj instanceof HistoryEntry || obj instanceof PropertyDelta) && includeHistory == false) { continue; } Hibernate.initialize(obj); final Class<?> targetClass = HibernateProxyHelper.getClassWithoutInitializingProxy(obj); final ClassMetadata classMetadata = session.getSessionFactory().getClassMetadata(targetClass); if (classMetadata == null) { log.fatal("Can't init " + obj + " of type " + targetClass); continue; } // initalisierung des Objekts... defaultXStream.marshal(obj, new CompactWriter(new NullWriter())); if (preserveIds == false) { // Nun kann die ID gelöscht werden classMetadata.setIdentifier(obj, null, EntityMode.POJO); } if (log.isDebugEnabled()) { log.debug("loading evicted object " + obj); } if (this.ignoreFromTopLevelListing.contains(targetClass) == false) { all.add(obj); } } // und schreiben try { writer.write("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n"); } catch (final IOException ex) { // ignore, will fail on stream.marshal() } log.info("Wrote " + all.size() + " objects"); final MarshallingStrategy marshallingStrategy = new ProxyIdRefMarshallingStrategy(); stream.setMarshallingStrategy(marshallingStrategy); stream.marshal(all, new PrettyPrintWriter(writer)); }
public Object getIdentifier(Object entity) { final Class entityClass = Hibernate.getClass(entity); final ClassMetadata classMetadata = emf.getSessionFactory().getClassMetadata(entityClass); if (classMetadata == null) { throw new IllegalArgumentException(entityClass + " is not an entity"); } // TODO does that work for @IdClass? return classMetadata.getIdentifier(entity, EntityMode.POJO); }
public void initializeCollection(T instance, String collectionName) { ClassMetadata classMetadata = sessionFactory.getClassMetadata(instance.getClass()); Object collection = classMetadata.getPropertyValue(instance, collectionName); if (!Hibernate.isInitialized(collection)) { attachClean(instance); Hibernate.initialize(collection); } }
/** * 取得对象的主键名,辅助函数. * * @param entityClass 实体类型 * @return 主键名称 */ public String getIdName(Class entityClass) { Assert.notNull(entityClass); entityClass = ReflectUtils.getOriginalClass(entityClass); ClassMetadata meta = this.getSessionFactory().getClassMetadata(entityClass); Assert.notNull(meta, "Class " + entityClass + " not define in hibernate session factory."); String idName = meta.getIdentifierPropertyName(); Assert.hasText(idName, entityClass.getSimpleName() + " has no identifier property define."); return idName; }
public Pager findPager(Pager pager, Criteria criteria) { Assert.notNull(pager, "pager is required"); Assert.notNull(criteria, "criteria is required"); Integer pageNumber = pager.getPageNumber(); Integer pageSize = pager.getPageSize(); String searchBy = pager.getSearchBy(); String keyword = pager.getKeyword(); String orderBy = pager.getOrderBy(); Pager.Order order = pager.getOrder(); if (StringUtils.isNotEmpty(searchBy) && StringUtils.isNotEmpty(keyword)) { if (searchBy.contains(".")) { String alias = StringUtils.substringBefore(searchBy, "."); criteria.createAlias(alias, alias); } criteria.add(Restrictions.like(searchBy, "%" + keyword + "%")); } pager.setTotalCount(criteriaResultTotalCount(criteria)); if (StringUtils.isNotEmpty(orderBy) && order != null) { if (order == Pager.Order.asc) { criteria.addOrder(Order.asc(orderBy)); } else { criteria.addOrder(Order.desc(orderBy)); } } ClassMetadata classMetadata = sessionFactory.getClassMetadata(entityClass); if (!StringUtils.equals(orderBy, ORDER_LIST_PROPERTY_NAME) && ArrayUtils.contains(classMetadata.getPropertyNames(), ORDER_LIST_PROPERTY_NAME)) { criteria.addOrder(Order.asc(ORDER_LIST_PROPERTY_NAME)); criteria.addOrder(Order.desc(CREATE_DATE_PROPERTY_NAME)); if (StringUtils.isEmpty(orderBy) || order == null) { pager.setOrderBy(ORDER_LIST_PROPERTY_NAME); pager.setOrder(Pager.Order.asc); } } else if (!StringUtils.equals(orderBy, CREATE_DATE_PROPERTY_NAME) && ArrayUtils.contains(classMetadata.getPropertyNames(), CREATE_DATE_PROPERTY_NAME)) { criteria.addOrder(Order.desc(CREATE_DATE_PROPERTY_NAME)); if (StringUtils.isEmpty(orderBy) || order == null) { pager.setOrderBy(CREATE_DATE_PROPERTY_NAME); pager.setOrder(Pager.Order.desc); } } criteria.setFirstResult((pageNumber - 1) * pageSize); criteria.setMaxResults(pageSize); pager.setResult(criteria.list()); return pager; }
private boolean copyState(Object entity, Type[] types, Object[] state, SessionFactory sf) { // copy the entity state into the state array and return true if the state has changed ClassMetadata metadata = sf.getClassMetadata(entity.getClass()); Object[] newState = metadata.getPropertyValues(entity, EntityMode.POJO); int size = newState.length; boolean isDirty = false; for (int index = 0; index < size; index++) { if (!types[index].isEqual(state[index], newState[index], EntityMode.POJO)) { isDirty = true; state[index] = newState[index]; } } return isDirty; }
protected void setRelatedClassType( GrailsHibernateDomainClassProperty prop, AssociationType assType, Type hibernateType) { try { String associatedEntity = assType.getAssociatedEntityName((SessionFactoryImplementor) getSessionFactory()); ClassMetadata associatedMetaData = getSessionFactory().getClassMetadata(associatedEntity); prop.setRelatedClassType(associatedMetaData.getMappedClass(EntityMode.POJO)); } catch (MappingException me) { // other side must be a value object if (hibernateType.isCollectionType()) { prop.setRelatedClassType(Collection.class); } } }
public IObject[] getLockCandidates(IObject o) { int idx = 0; IObject[] toCheck = new IObject[total()]; Object[] values = cm.getPropertyValues(o, EntityMode.POJO); for (int i = 0; i < size(); i++) { if (!include(i)) { continue; } // this relation has subtypes and therefore is an embedded // component. This means that the value in values[] is the // instance itself. we will now have to acquire the actual // component values. if (hasSubtypes(i)) { for (int j = 0; j < numberOfSubtypes(i); j++) { Object value = getSubtypeValue(i, j, o); if (value != null) { toCheck[idx++] = (IObject) value; } } } // this is a regular relation. if the value is non null, // add it to the list of candidates. else if (values[i] != null) { toCheck[idx++] = (IObject) values[i]; } } IObject[] retVal; retVal = new IObject[idx]; System.arraycopy(toCheck, 0, retVal, 0, idx); return retVal; }
@SuppressWarnings("unchecked") public List<T> getAllList() { ClassMetadata classMetadata = sessionFactory.getClassMetadata(entityClass); String hql; if (ArrayUtils.contains(classMetadata.getPropertyNames(), ORDER_LIST_PROPERTY_NAME)) { hql = "from " + entityClass.getName() + " as entity order by entity." + ORDER_LIST_PROPERTY_NAME + " desc"; } else { hql = "from " + entityClass.getName(); } return getSession().createQuery(hql).list(); }
public static void main(final String[] args) throws Exception { final Session session = getSession(); try { System.out.println("querying all the managed entities..."); final Map metadataMap = session.getSessionFactory().getAllClassMetadata(); for (Object key : metadataMap.keySet()) { final ClassMetadata classMetadata = (ClassMetadata) metadataMap.get(key); final String entityName = classMetadata.getEntityName(); final Query query = session.createQuery("from " + entityName); System.out.println("executing: " + query.getQueryString()); for (Object o : query.list()) { System.out.println(" " + o); } } } finally { session.close(); } }
/** * examines all {@link Type types} for this class and stores pointers to those fields which * represent {@link IObject} instances. These fields may need to be locked when an object of * this type is created or updated. */ Locks(ClassMetadata classMetadata) { this.cm = classMetadata; String[] name = cm.getPropertyNames(); Type[] type = cm.getPropertyTypes(); List<String[]> checks = new ArrayList<String[]>(); List<String[]> groupChecks = new ArrayList<String[]>(); this.size = type.length; this.include = new boolean[size]; this.subnames = new String[size][]; this.subtypes = new Type[size][]; for (int i = 0; i < type.length; i++) { if (type[i].isComponentType() && ((ComponentType) type[i]).isEmbedded()) { EmbeddedComponentType embedded = (EmbeddedComponentType) type[i]; String[] sub_name = embedded.getPropertyNames(); Type[] sub_type = embedded.getSubtypes(); List<String> name_list = new ArrayList<String>(); List<Type> type_list = new ArrayList<Type>(); for (int j = 0; j < sub_type.length; j++) { if (IObject.class.isAssignableFrom(sub_type[j].getReturnedClass())) { String path = name[i] + "." + sub_name[j]; name_list.add(path); type_list.add(sub_type[j]); addCheck(checks, groupChecks, sub_type[j].getReturnedClass(), path); } } add( i, name_list.toArray(new String[name_list.size()]), type_list.toArray(new Type[type_list.size()])); } else if (IObject.class.isAssignableFrom(type[i].getReturnedClass())) { add(i); addCheck(checks, groupChecks, type[i].getReturnedClass(), name[i]); // Create checks for } } this.checks = checks.toArray(new String[checks.size()][]); this.groupChecks = groupChecks.toArray(new String[groupChecks.size()][]); }
@Override public void delete(long id) { String entityName = entityClassMetadata.getEntityName(); String idPropertyName = entityClassMetadata.getIdentifierPropertyName(); String hqlDeleteQuery = new StringBuffer() .append("delete ") .append(entityName) .append(" where ") .append(idPropertyName) .append(" = :id") .toString(); Query deleteQuery = getCurrentSession().createQuery(hqlDeleteQuery); deleteQuery.setParameter("id", id); deleteQuery.executeUpdate(); }
private List<String> getCollectionRoles( final SessionFactory sessionFactory, final Class<?> entityClass) { List<String> collectionRoles = entityCollectionRoles.get(entityClass); if (collectionRoles != null) { return collectionRoles; } final com.google.common.collect.ImmutableList.Builder<String> collectionRolesBuilder = ImmutableList.builder(); final ClassMetadata classMetadata = sessionFactory.getClassMetadata(entityClass); for (final Type type : classMetadata.getPropertyTypes()) { if (type.isCollectionType()) { collectionRolesBuilder.add(((CollectionType) type).getRole()); } } collectionRoles = collectionRolesBuilder.build(); entityCollectionRoles.put(entityClass, collectionRoles); return collectionRoles; }
public EntityInformation[] locate(EntityManagerFactory entityManagerFactory, JpaGpsDevice device) throws JpaGpsDeviceException { CompassGpsInterfaceDevice gps = (CompassGpsInterfaceDevice) device.getGps(); HibernateEntityManagerFactory hibernateEntityManagerFactory = (HibernateEntityManagerFactory) entityManagerFactory; SessionFactory sessionFactory = hibernateEntityManagerFactory.getSessionFactory(); ArrayList<EntityInformation> entitiesList = new ArrayList<EntityInformation>(); Map allClassMetaData = sessionFactory.getAllClassMetadata(); for (Object o : allClassMetaData.keySet()) { String entityname = (String) o; if (!gps.hasMappingForEntityForIndex((entityname))) { if (log.isDebugEnabled()) { log.debug("Entity [" + entityname + "] does not have compass mapping, filtering it out"); } continue; } ClassMetadata classMetadata = (ClassMetadata) allClassMetaData.get(entityname); if (shouldFilter(entityname, classMetadata, allClassMetaData, device)) { continue; } Class<?> clazz = classMetadata.getMappedClass(); ResourceMapping resourceMapping = gps.getMappingForEntityForIndex(entityname); EntityInformation entityInformation = new EntityInformation( clazz, entityname, new HibernateJpaQueryProvider(clazz, entityname), resourceMapping.getSubIndexHash().getSubIndexes()); entitiesList.add(entityInformation); if (log.isDebugEnabled()) { log.debug("Entity [" + entityname + "] will be indexed"); } } return entitiesList.toArray(new EntityInformation[entitiesList.size()]); }
/** * For each of the fields contained in this {@link Locks} object, parse out the type and the * field name and store those as the key and value in the "value" argument. */ public void fillRelationships(SessionFactoryImplementor sfi, Map<String, Relationship> value) { final Type[] types = cm.getPropertyTypes(); for (int t = 0; t < types.length; t++) { final Type type = types[t]; final String name = type.getName(); String to = null; Relationship field = null; if (type instanceof EntityType) { final EntityType entType = (EntityType) type; to = entType.getAssociatedEntityName(); field = new Relationship(cm.getPropertyNames()[t], false); } else if (types[t] instanceof CollectionType) { final CollectionType colType = (CollectionType) types[t]; final Type elemType = colType.getElementType(sfi); if (!elemType.isEntityType()) { continue; // The case for count maps and other primitives. } to = elemType.getName(); int open = name.indexOf("("); int close = name.lastIndexOf(")"); String role = name.substring(open + 1, close); int dot = role.lastIndexOf("."); field = new Relationship(role.substring(dot + 1), true); } if (to != null && field != null) { Map<String, ClassMetadata> m = sfi.getAllClassMetadata(); for (Class<?> c : Impl.hierarchy(m, to)) { value.put(c.getName(), field); } } } }
public void /*test*/ AddNewProperty() { System.out.println("******************* testAddNewProperty ********************"); PersistentClass userMapping = HibernateUtil.getClassMapping(User.class); Column column = new Column(); column.setName("MOTTO"); column.setNullable(false); column.setUnique(true); column.setSqlType("VARCHAR"); userMapping.getTable().addColumn(column); SimpleValue value = new SimpleValue(); value.setTable(userMapping.getTable()); value.addColumn(column); value.setTypeName("string"); Property prop = new Property(); prop.setValue(value); prop.setName("motto"); prop.setPropertyAccessorName("field"); prop.setNodeName(prop.getName()); userMapping.addProperty(prop); HibernateUtil.rebuildSessionFactory(); ClassMetadata metadata = HibernateUtil.getClassMetadata(User.class); String[] propNames = metadata.getPropertyNames(); boolean mottoFound = false; for (int i = 0; i < propNames.length; i++) { String propName = propNames[i]; if (propName.equalsIgnoreCase("motto")) { mottoFound = true; break; } } assertTrue(mottoFound); }
/** * examines all model objects to see which fields contain a {@link Type} which points to this * class. Uses {@link #locksFields(Type[])} since this is the inverse process. */ private String[][] lockedByFields(String klass, Map<String, ClassMetadata> m) { if (m == null) { throw new InternalException("ClassMetadata map cannot be null."); } List<String[]> fields = new ArrayList<String[]>(); for (String k : m.keySet()) { ClassMetadata cm = m.get(k); Type[] type = cm.getPropertyTypes(); String[] names = cm.getPropertyNames(); Locks inverse = locksHolder.get(k); for (int i = 0; i < inverse.size(); i++) { if (!inverse.include(i)) { continue; } // this is an embedded component and must be treated // specially. specifically, that we cannot compare against // the top-level returnedClass name but rather against // each of the individual subtype returnedClass names. if (inverse.hasSubtypes(i)) { for (int j = 0; j < inverse.numberOfSubtypes(i); j++) { if (inverse.subtypeEquals(i, j, klass)) { fields.add(new String[] {k, inverse.subtypeName(i, j)}); } } } // no subtypes so can compare directly else if (klass.equals(type[i].getReturnedClass().getName())) { fields.add(new String[] {k, names[i]}); } } } return fields.toArray(new String[fields.size()][2]); }
public boolean matches(String name, Object value) { boolean matches = false; EnvironmentImpl environment = EnvironmentImpl.getCurrent(); if (environment != null) { SessionFactory sessionFactory = null; if (hibernateSessionFactoryName != null) { sessionFactory = (SessionFactory) environment.get(hibernateSessionFactoryName); } else { sessionFactory = environment.get(SessionFactory.class); } if (sessionFactory != null) { ClassMetadata classMetadata = sessionFactory.getClassMetadata(value.getClass()); matches = ((classMetadata != null) && (classMetadata.getIdentifierType().getClass() == getIdType())); } } else { log.trace( "no current environment so valueClass cannot be stored as an id-ref to a hibernate object"); matches = false; } return matches; }
@Test public void entityMappingTest() { try { log.info("querying all the managed entities..."); final Map<String, ClassMetadata> metadataMap = session.getSessionFactory().getAllClassMetadata(); for (Object key : metadataMap.keySet()) { final ClassMetadata classMetadata = metadataMap.get(key); final String entityName = classMetadata.getEntityName(); final Query query = session.createQuery("from " + entityName); query.setCacheable(true); log.info("executing hql= " + query.getQueryString()); for (Object o : query.list()) { log.info("IEntity= " + o); } } } finally { session.flush(); } log.info("성공했습니다."); }
private void addChildExampleCriteria(Object exampleInstance, Criteria criteria, Session sesion) { ClassMetadata metadata = sesion.getSessionFactory().getClassMetadata(exampleInstance.getClass()); String[] propertyNames = metadata.getPropertyNames(); Type[] propertyTypes = metadata.getPropertyTypes(); // see if this example instance has any properties that are entities for (int i = 0; i < propertyNames.length; i++) { String propertyName = propertyNames[i]; Type propertyType = propertyTypes[i]; if (propertyType instanceof EntityType) { // this property is an association - Hibernate's Example ignores // these Object value = metadata.getPropertyValue(exampleInstance, propertyName, EntityMode.POJO); if (value != null) { ClassMetadata childMetadata = sesion.getSessionFactory().getClassMetadata(value.getClass()); Criteria childCriteria = criteria.createCriteria(propertyName); if (childMetadata.hasIdentifierProperty()) { Object id = childMetadata.getIdentifier(value, EntityMode.POJO); if (id != null) { // add the identifier to the child criteria childCriteria.add(Restrictions.eq(childMetadata.getIdentifierPropertyName(), id)); } } // add the entity's fields as Example fields childCriteria.add(Example.create(value)); // add this entity's associations addChildExampleCriteria(value, childCriteria, sesion); } } } // ~for }
Immutables(ClassMetadata metadata) { if (metadata instanceof EntityPersister) { this.ep = (EntityPersister) metadata; } else { throw new IllegalArgumentException( "Metadata passed to Immutables" + " must be an instanceof EntityPersister, not " + (metadata == null ? null : metadata.getClass())); } List<String> retVal = new ArrayList<String>(); Type[] type = this.ep.getPropertyTypes(); String[] name = this.ep.getPropertyNames(); boolean[] up = this.ep.getPropertyUpdateability(); for (int i = 0; i < type.length; i++) { // not updateable, so our work (for this type) is done. if (!up[i]) { retVal.add(name[i]); } // updateable, but maybe a component subtype is NOT. else if (type[i].isComponentType() && ((ComponentType) type[i]).isEmbedded()) { EmbeddedComponentType embedded = (EmbeddedComponentType) type[i]; String[] sub_name = embedded.getPropertyNames(); Type[] sub_type = embedded.getSubtypes(); List<String> name_list = new ArrayList<String>(); List<Type> type_list = new ArrayList<Type>(); for (int j = 0; j < sub_type.length; j++) { // INCOMPLETE !!! } } } immutableFields = retVal.toArray(new String[retVal.size()]); }
/** uses the {@link ClassMetadata} for this {@link Locks} tp retrieve the component value. */ public Object getSubtypeValue(int i, int j, Object o) { return cm.getPropertyValue(o, subnames[i][j], EntityMode.POJO); }
/** 取得对象的主键名. */ public String getIdName() { ClassMetadata meta = getSessionFactory().getClassMetadata(entityClass); return meta.getIdentifierPropertyName(); }
/** * Initializes the metadata needed by this instance. * * @param sessionFactory * @see SessionFactory#getAllClassMetadata() */ public void setSessionFactory(SessionFactory sessionFactory) { if (initialized) { return; // EARLY EXIT !! } log.info("Calculating ExtendedMetadata..."); SessionFactoryImplementor sfi = (SessionFactoryImplementor) sessionFactory; Map<String, ClassMetadata> m = sessionFactory.getAllClassMetadata(); // do Locks() first because they are used during the // calculation of LockedBy() for (String key : m.keySet()) { ClassMetadata cm = m.get(key); locksHolder.put(key, new Locks(cm)); } // now that all Locks() are available, determine LockedBy() for (String key : m.keySet()) { lockedByHolder.put(key, lockedByFields(key, m)); } for (String key : m.keySet()) { ClassMetadata cm = m.get(key); immutablesHolder.put(key, new Immutables(cm)); } for (Map.Entry<String, ClassMetadata> entry : m.entrySet()) { String key = entry.getKey(); ClassMetadata cm = entry.getValue(); key = key.substring(key.lastIndexOf(".") + 1).toLowerCase(); if (hibernateClasses.containsKey(key)) { throw new RuntimeException("Duplicate keys!: " + key); } hibernateClasses.put(key, cm.getMappedClass(EntityMode.POJO)); } for (String key : m.keySet()) { Map<String, Relationship> value = new HashMap<String, Relationship>(); ClassMetadata cm = m.get(key); for (Class<?> c : hierarchy(m, key)) { Locks locks = locksHolder.get(c.getName()); locks.fillRelationships(sfi, value); } // FIXME: using simple name rather than FQN Map<String, Relationship> value2 = new HashMap<String, Relationship>(); for (Map.Entry<String, Relationship> i : value.entrySet()) { String k = i.getKey(); k = k.substring(k.lastIndexOf(".") + 1); value2.put(k, i.getValue()); } relationships.put(key.substring(key.lastIndexOf(".") + 1), value2); } Set<Class<IAnnotated>> anns = new HashSet<Class<IAnnotated>>(); Set<Class<Annotation>> anns2 = new HashSet<Class<Annotation>>(); for (String key : m.keySet()) { ClassMetadata cm = m.get(key); Map<String, String> queries = countQueriesAndEditTargets(key, lockedByHolder.get(key)); collectionCountHolder.putAll(queries); // Checking classes, specifically for ITypes Class c = cm.getMappedClass(EntityMode.POJO); if (IAnnotated.class.isAssignableFrom(c)) { anns.add(c); } if (Annotation.class.isAssignableFrom(c)) { anns2.add(c); } } annotatableTypes.addAll(anns); annotationTypes.addAll(anns2); initialized = true; }
/** 取得对象的主键名. */ public String getIdName() { ClassMetadata meta = getSessionFactory().getClassMetadata(entityClass); Assert.notNull( meta, "Class " + entityClass.getSimpleName() + " not define in HibernateSessionFactory."); return meta.getIdentifierPropertyName(); }