How to use

getPropertyTypes

method

in

org.hibernate.metadata.ClassMetadata

@Override
public List<Type> getPropertyTypes(Class<?> entityClass, HibernateEntityManager entityManager) {
  entityClass = getNonProxyImplementationClassIfNecessary(entityClass);
  ClassMetadata metadata = getSessionFactory(entityManager).getClassMetadata(entityClass);
  List<Type> propertyTypes = new ArrayList<>();
  Collections.addAll(propertyTypes, metadata.getPropertyTypes());
  return propertyTypes;
}

/**
 * Add parent and child entity names so that we know how to rearrange dependencies
 *
 * @param action The action being sorted
 * @param batchIdentifier The batch identifier of the entity affected by the action
 */
private void addParentChildEntityNames(AbstractEntityInsertAction action, BatchIdentifier batchIdentifier) {
  Object[] propertyValues = action.getState();
  ClassMetadata classMetadata = action.getPersister().getClassMetadata();
  if ( classMetadata != null ) {
    Type[] propertyTypes = classMetadata.getPropertyTypes();
    Type identifierType = classMetadata.getIdentifierType();
    for ( int i = 0; i < propertyValues.length; i++ ) {
      Object value = propertyValues[i];
      Type type = propertyTypes[i];
      addParentChildEntityNameByPropertyAndValue( action, batchIdentifier, type, value );
    }
    if ( identifierType.isComponentType() ) {
      CompositeType compositeType = (CompositeType) identifierType;
      Type[] compositeIdentifierTypes = compositeType.getSubtypes();
      for ( Type type : compositeIdentifierTypes ) {
        addParentChildEntityNameByPropertyAndValue( action, batchIdentifier, type, null );
      }
    }
  }
}

private void scanClassMetadata(ClassMetadata meta)
{
 Class<?> entityClass = meta.getMappedClass();
 String[] names = meta.getPropertyNames();
 Type[] types = meta.getPropertyTypes();
 for (int n = 0; n < names.length; n++)
 {
   String fieldName = names[n];
   Type type = types[n];
   registerEntityField(entityClass, fieldName, type);
 }
 if (meta.getIdentifierPropertyName() != null)
   registerEntityField(entityClass, meta.getIdentifierPropertyName(), meta.getIdentifierType());
 
 //System.out.println(names + " " + types);
}

@Override
public Type[] getPropertyTypes() {
  return TypeV2Adapter.adapt(metadata.getPropertyTypes());
}

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;
}

/**
 * Construct a entity collection.
 *
 * @param parentMetadata parent meta data
 * @param childMetadata child meta data
 * @param parent parent object
 * @param objects child objects
 */
public HibernateEntityCollection(ClassMetadata parentMetadata, ClassMetadata childMetadata, Object parent,
    Collection<?> objects) {
  this.objects = objects;
  int i = 0;
  for (Type type : childMetadata.getPropertyTypes()) {
    if (type instanceof ManyToOneType) {
      ManyToOneType mto = (ManyToOneType) type;
      if (mto.getAssociatedEntityName().equals(parentMetadata.getEntityName())) {
        parentName = childMetadata.getPropertyNames()[i];
      }
    }
    i++;
  }
  this.metadata = childMetadata;
  this.parent = parent;
}

.getPropertyTypes();

.getPropertyTypes();

public static void checkVersion(Object value, Session session, Object oldVersion, Object version)
{
 ClassMetadata classMetadata = getClassMetadata(value, session);
 VersionType versionType = (VersionType) classMetadata.getPropertyTypes()[ classMetadata.getVersionProperty() ];
 if ( !versionType.isEqual(oldVersion, version) )
 {
   throw new StaleStateException("current database version number does not match passivated version number");
 }
}

final Type[] propertyTypes = cm.getPropertyTypes();
for (int i = 0; i < propertyNames.length; i++) {
  if (propertyTypes[i] instanceof CollectionType && Map.class == propertyTypes[i].getReturnedClass()) {

/**
 * @param entity an actual entity object, not a proxy!
 */
public String toString(Object entity, EntityMode entityMode) throws HibernateException {
  // todo : this call will not work for anything other than pojos!
  ClassMetadata cm = factory.getClassMetadata( entity.getClass() );
  if ( cm==null ) return entity.getClass().getName();
  Map result = new HashMap();
  if ( cm.hasIdentifierProperty() ) {
    result.put(
      cm.getIdentifierPropertyName(),
      cm.getIdentifierType().toLoggableString( cm.getIdentifier( entity, entityMode ), factory )
    );
  }
  Type[] types = cm.getPropertyTypes();
  String[] names = cm.getPropertyNames();
  Object[] values = cm.getPropertyValues( entity, entityMode );
  for ( int i=0; i<types.length; i++ ) {
    if ( !names[i].startsWith("_") ) {
      String strValue = values[i]==LazyPropertyInitializer.UNFETCHED_PROPERTY ?
        values[i].toString() :
        types[i].toLoggableString( values[i], factory );
      result.put( names[i], strValue );
    }
  }
  return cm.getEntityName() + result.toString();
}

/**
 * @param entity an actual entity object, not a proxy!
 */
public String toString(Object entity, EntityMode entityMode) throws HibernateException {
  // todo : this call will not work for anything other than pojos!
  ClassMetadata cm = factory.getClassMetadata( entity.getClass() );
  if ( cm==null ) return entity.getClass().getName();
  Map result = new HashMap();
  if ( cm.hasIdentifierProperty() ) {
    result.put(
      cm.getIdentifierPropertyName(),
      cm.getIdentifierType().toLoggableString( cm.getIdentifier( entity, entityMode ), factory )
    );
  }
  Type[] types = cm.getPropertyTypes();
  String[] names = cm.getPropertyNames();
  Object[] values = cm.getPropertyValues( entity, entityMode );
  for ( int i=0; i<types.length; i++ ) {
    if ( !names[i].startsWith("_") ) {
      String strValue = values[i]==LazyPropertyInitializer.UNFETCHED_PROPERTY ?
        values[i].toString() :
        types[i].toLoggableString( values[i], factory );
      result.put( names[i], strValue );
    }
  }
  return cm.getEntityName() + result.toString();
}

private boolean hasInverseCollection(ClassMetadata meta, Class<?> elementType) {
  SessionFactoryImplementor impl = (SessionFactoryImplementor) sessionFactory;
  for (Type type : meta.getPropertyTypes()) {
    if (type.isCollectionType()) {
      String role = ((CollectionType) type).getRole();
      CollectionPersister persister = impl.getCollectionPersister(role);
      return persister.isInverse() && persister.getElementType()
          .getReturnedClass().equals(elementType);
    }
  }
  return false;
}

Type[] type = cm.getPropertyTypes();
String[] names = cm.getPropertyNames();
Locks inverse = locksHolder.get(k);

Map<String, ClassMetadata> classClassMetadatas = sessionFactoryImpl.getAllClassMetadata();
for (ClassMetadata classMetadata : classClassMetadatas.values()) {
  Type[] propertyTypes = classMetadata.getPropertyTypes(); 
  for (int i = propertyTypes.length - 1; i >= 0; i--) {
    Type propertyType = propertyTypes[i];

Type[] type = cm.getPropertyTypes();
List<String[]> checks = new ArrayList<String[]>();
List<String[]> groupChecks = new ArrayList<String[]>();

/**
 * 
 * {@inheritDoc}
 */
@Override
protected Set<Class<?>> findTypesToRegister() {
  Set<Class<?>> typesToRegister = new HashSet<Class<?>>();
  if (hibernateConfigured) {
    for(ClassMetadata classMetadata : this.classMetadata) {
      if (!classMetadata.getMappedClass().isInterface()) {
        typesToRegister.add(classMetadata.getMappedClass());
        findComponentProperties(classMetadata.getPropertyTypes(), typesToRegister);
      }
    }
    for (CollectionMetadata collectionMetadata : this.collectionMetadata) {
      Type elementType = collectionMetadata.getElementType();
      if (elementType instanceof ComponentType) {
        if (!elementType.getReturnedClass().isInterface()) {
          typesToRegister.add(elementType.getReturnedClass());
          findComponentProperties(((ComponentType)elementType).getSubtypes(), typesToRegister);
        }
      }
    }
  }
  return typesToRegister;
}

/**
 * 
 * {@inheritDoc}
 */
@Override
protected Set<Class<?>> findTypesToRegister() {
  Set<Class<?>> typesToRegister = new HashSet<Class<?>>();
  if (hibernateConfigured) {
    for(ClassMetadata classMetadata : this.classMetadata) {
      if (!classMetadata.getMappedClass(EntityMode.POJO).isInterface()) {
        typesToRegister.add(classMetadata.getMappedClass(EntityMode.POJO));
        findComponentProperties(classMetadata.getPropertyTypes(), typesToRegister);
      }
    }
    for (CollectionMetadata collectionMetadata : this.collectionMetadata) {
      Type elementType = collectionMetadata.getElementType();
      if (elementType instanceof ComponentType) {
        if (!elementType.getReturnedClass().isInterface()) {
          typesToRegister.add(elementType.getReturnedClass());
          findComponentProperties(((ComponentType)elementType).getSubtypes(), typesToRegister);
        }
      }
    }
  }
  return typesToRegister;
}

final Type[] propertyTypes = metadata.getPropertyTypes();
final boolean[] propertyNullabilities = metadata.getPropertyNullability();
for (int i = 0; i < propertyNames.length; i++) {

  Map<String, Relationship> value) {
final Type[] types = cm.getPropertyTypes();
for (int t = 0; t < types.length; t++) {