How to use

getIdentifierPropertyName

method

in

org.hibernate.metadata.ClassMetadata

  @Override
  public Field getIdField(Class<?> clazz, Session session) {
    clazz = getNonProxyImplementationClassIfNecessary(clazz);
    ClassMetadata metadata = session.getSessionFactory().getClassMetadata(clazz);
    Field idField = ReflectionUtils.findField(clazz, metadata.getIdentifierPropertyName());
    idField.setAccessible(true);
    return idField;
  }
}

@Override
public Field getIdField(Class<?> clazz, EntityManager em) {
  clazz = getNonProxyImplementationClassIfNecessary(clazz);
  ClassMetadata metadata = em.unwrap(Session.class).getSessionFactory().getClassMetadata(clazz);
  Field idField = ReflectionUtils.findField(clazz, metadata.getIdentifierPropertyName());
  idField.setAccessible(true);
  return idField;
}

@Override
public Map<String, Object> getIdMetadata(Class<?> entityClass, HibernateEntityManager entityManager) {
  entityClass = getNonProxyImplementationClassIfNecessary(entityClass);
  Map<String, Object> response = new HashMap<>();
  SessionFactory sessionFactory = entityManager.getSession().getSessionFactory();
  
  ClassMetadata metadata = sessionFactory.getClassMetadata(entityClass);
  if (metadata == null) {
    return null;
  }
  
  String idProperty = metadata.getIdentifierPropertyName();
  response.put("name", idProperty);
  Type idType = metadata.getIdentifierType();
  response.put("type", idType);
  return response;
}

for (Object item : sessionFactory.getAllClassMetadata().values()) {
  ClassMetadata metadata = (ClassMetadata) item;
  String idProperty = metadata.getIdentifierPropertyName();
  Class<?> mappedClass = metadata.getMappedClass();
  Field idField;

    setForeignKeyProperty(foreignMetadata.getIdentifierPropertyName());
((BasicFieldMetadata) metadata.get(addMetadataFromFieldTypeRequest.getRequestedPropertyName()))
    .setForeignKeyClass(foreignKeyClass);
    setForeignKeyProperty(foreignMetadata.getIdentifierPropertyName());
((BasicFieldMetadata) metadata.get(addMetadataFromFieldTypeRequest.getRequestedPropertyName())).
    setForeignKeyClass(foreignKeyClass);

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

String idPropertyName = getSession().getSessionFactory().getClassMetadata(getType()).getIdentifierPropertyName();

String[] propNames = metadata.getPropertyNames();
Object identifierType = metadata.getIdentifierType();
String identifierName = metadata.getIdentifierPropertyName();
if (identifierType instanceof StringType || identifierType instanceof TextType) {
  int maxLength = getMaximumPropertyLength(entityClass, identifierName);

 Class<?> entityType = MyClass.class;
ClassMetadata md = sessionFactory.getClassMetadata( entityType );
ScrollableResults scrollableResults = session
    .createCriteria( entityType )
    .setCacheable( false )
    .setFetchSize( 1 )
    .add( Restrictions.gt( md.getIdentifierPropertyName(), checkpointId ))
    .setMaxResults( maxResults )
    .scroll( ScrollMode.FORWARD_ONLY );

/**
 * 取得对象的主键名.
 * 
 * @return String
 */
public String getIdName() {
  ClassMetadata meta = sessionFactory.getClassMetadata(entityClass);
  return meta.getIdentifierPropertyName();
}
 

public Method getIdGetter() {
  String prop = this.metadata.getIdentifierPropertyName();
  return getGetterFor(prop);
}

/**
 * 获取模型主键名称
 *
 * @param sessionFactory 会话工厂
 * @param model          模型对象
 * @return 主键名称
 */
public static String getPrimary(SessionFactory sessionFactory, Class<?> model) {
  return getClassMetadata(sessionFactory, model).getIdentifierPropertyName();
}

public String[] getProperties() {
  String[] pn = metadata.getPropertyNames();
  String[] result = new String[pn.length + 1];
  result[0] = metadata.getIdentifierPropertyName();
  for (int i = 0; i < pn.length; i++) {
    result[i+1] = pn[i];
  }
  return result;
}

public HibernateMetamodelEntityInformation(Class<T> domainClass, ClassMetadata metadata) {
  super(domainClass);
  Assert.notNull(metadata);
  
  Type idType = metadata.getIdentifierType();
  if (idType == null) {
    throw new IllegalArgumentException("The given domain class does not contain an id attribute!");
  }
  
  String idProperty = metadata.getIdentifierPropertyName();
  this.idType = idType;
  this.idProperty = idProperty;
}

@Override
public Object getAttribute(String name) throws LayerException {
  if (metadata.getIdentifierPropertyName().equals(name)) {
    return getId(name);
  }
  return object == null ? null : metadata.getPropertyValue(object, name, EntityMode.POJO);
}

 class IntrospectClassMetadata extends BasicTransformerAdapter {
 PassThroughResultTransformer rt = PassThroughResultTransformer.INSTANCE;
 public Object transformTuple(Object[] tuple, String[] aliases) {
  final Object o = rt.transformTuple(tuple, aliases);
  ClassMetadata cm = sf.getClassMetadata(o.getClass());
  List<String> pns = new ArrayList<String>(Arrays.asList(cm.getPropertyNames()));
  Map<String, Object> m = new HashMap<String, Object>();
  for(String pn : pns) {
   m.put(pn, cm.getPropertyValue(o, pn));
  }
  m.put(cm.getIdentifierPropertyName(), cm.getIdentifier(o));
  return m;
 }
}

public String getIdProperty(Class<?> entityClass) {
 ClassMetadata classmeta = getSessionFactory().getClassMetadata(entityClass);
 if (classmeta == null) return null;
 return classmeta.getIdentifierPropertyName();
}

/** {@inheritDoc} */
@Override
public Object visit(Id filter, Object userData) {
  String idName;
  try {
    idName = featureModel.getEntityMetadata().getIdentifierPropertyName();
  } catch (LayerException e) {
    log.warn("Cannot read idName, defaulting to 'id'", e);
    idName = HIBERNATE_ID;
  }
  Collection<?> c = (Collection<?>) castLiteral(filter.getIdentifiers(), idName);
  return Restrictions.in(idName, c);
}

 @Override
public OpenmrsObject getItemById(Class<? extends OpenmrsObject> type, Integer id) {
   try {
     String idProperty = sessionFactory.getHibernateSessionFactory().getClassMetadata(type).getIdentifierPropertyName();
     Criteria criteria = sessionFactory.getCurrentSession().createCriteria(type);
     criteria.add(Expression.eq(idProperty, id));
     OpenmrsObject result = (OpenmrsObject) criteria.uniqueResult();
     return result;
   }
   catch(Exception e) {
     log.error("Error fetching item by id:" + e);
     return null;
   }
 }

  public static boolean areDocIdAndEntityIdIdentical(EntityInfo entityInfo, SessionImplementor session) {
    SessionFactoryImplementor sessionFactoryImplementor = session.getSessionFactory();
    ClassMetadata cm = sessionFactoryImplementor.getMetamodel().entityPersister( entityInfo.getType().getName() ).getClassMetadata();
    String hibernateIdentifierProperty = cm.getIdentifierPropertyName();
    return entityInfo.getIdName().equals( hibernateIdentifierProperty );
  }
}