javax.persistence.Cache#javax.persistence.metamodel.Metamodel源码实例Demo

public EntityType getTargetEntity(RegistryConfiguration registryConf, EntityManager entityManager) {

		EntityType targetEntity;

		String targetEntityName = getTargetEntityName(registryConf);

		Metamodel classMetadata = entityManager.getMetamodel();
		Iterator it = classMetadata.getEntities().iterator();

		targetEntity = null;
		while (it.hasNext()) {
			EntityType entity = (EntityType) it.next();
			String jpaEntityName = entity.getName();

			if (entity != null && jpaEntityName.equals(targetEntityName)) {
				targetEntity = entity;
				break;
			}
		}

		return targetEntity;
	}
 

private void addRootEntities(ModelStructure modelStructure) {
	Metamodel jpaMetamodel;
	Set<EntityType<?>> jpaEntities;

	String modelName = getDataSource().getConfiguration().getModelName();

	jpaMetamodel = getEntityManager().getMetamodel();
	jpaEntities = jpaMetamodel.getEntities();
	logger.debug("Jpa metamodel contains [" + jpaEntities.size() + "] entity types");

	for (EntityType<?> entityType : jpaEntities) {
		logger.debug("Adding entity type [" + entityType + "] to model structure");
		String entityTypeName = entityType.getJavaType().getName();
		addEntity(modelStructure, modelName, entityTypeName);
		logger.info("Entity type [" + entityType + "] succesfully added to model structure");
	}
}
 

@Override
public void startUp(ServletContext servletContext) {
    try {
        initializeJPA();
    } catch (PersistenceException e) {
        //fix for MCR-1236
        if (MCRConfiguration2.getBoolean("MCR.Persistence.Database.Enable").orElse(true)) {
            LogManager.getLogger()
                .error(() -> "Could not initialize JPA. Database access is disabled in this session.", e);
            MCRConfiguration2.set("MCR.Persistence.Database.Enable", String.valueOf(false));
        }
        MCREntityManagerProvider.init(e);
        return;
    }
    Metamodel metamodel = MCREntityManagerProvider.getEntityManagerFactory().getMetamodel();
    checkHibernateMappingConfig(metamodel);
    LogManager.getLogger()
        .info("Mapping these entities: {}", metamodel.getEntities()
            .stream()
            .map(EntityType::getJavaType)
            .map(Class::getName)
            .collect(Collectors.toList()));
    MCRShutdownHandler.getInstance().addCloseable(new MCRJPAShutdownProcessor());
}
 

private void checkHibernateMappingConfig(Metamodel metamodel) {
    Set<String> mappedEntities = metamodel
        .getEntities()
        .stream()
        .map(EntityType::getJavaType)
        .map(Class::getName)
        .collect(Collectors.toSet());
    List<String> unMappedEntities = MCRConfiguration2.getString("MCR.Hibernate.Mappings")
        .map(MCRConfiguration2::splitValue)
        .orElseGet(Stream::empty)
        .filter(cName -> !mappedEntities.contains(cName))
        .collect(Collectors.toList());
    if (!unMappedEntities.isEmpty()) {
        throw new MCRException(
            "JPA Mapping is inclomplete. Could not find a mapping for these classes: " + unMappedEntities);
    }
}
 

private static EntityManager mockEntityManager() {
  EntityManager em = EasyMock.createMock(EntityManager.class);
  Metamodel mm = EasyMock.createMock(Metamodel.class);
  EasyMock.expect(em.getMetamodel()).andReturn(mm).anyTimes();
  Set<EntityType<?>> et = new HashSet<EntityType<?>>();
  EasyMock.expect(mm.getEntities()).andReturn(et).anyTimes();
  EasyMock.expect(em.isOpen()).andReturn(true).anyTimes();
  Query jpqlquery = EasyMock.createMock(Query.class);
  Capture<String> capturedArgument = new Capture<String>();
  EasyMock.expect(em.createQuery(EasyMock.capture(capturedArgument))).andReturn(jpqlquery).anyTimes();
  EasyMock.expect(jpqlquery.setParameter(EasyMock.anyInt(), EasyMock.anyObject()))
      .andReturn(jpqlquery).anyTimes();
  EasyMock.expect(jpqlquery.setParameter(EasyMock.anyInt(), (Calendar) EasyMock.anyObject(), 
      EasyMock.anyObject(TemporalType.TIMESTAMP.getClass()))).andReturn(jpqlquery).anyTimes();
  EasyMock.expect(jpqlquery.setParameter(EasyMock.anyInt(), (Time) EasyMock.anyObject(), 
      EasyMock.anyObject(TemporalType.TIME.getClass()))).andReturn(jpqlquery).anyTimes();
  List<Object> result = new ArrayList<Object>();
  result.add(5);
  EasyMock.expect(jpqlquery.getResultList()).andReturn(result).anyTimes();
  EasyMock.replay(em, mm, jpqlquery);
  return em;

}
 

private List<Class<?>> getAllManagedEntityTypes(EntityManagerFactory entityManagerFactory) {
	List<Class<?>> entityClasses = new ArrayList<>();
	Metamodel metamodel = entityManagerFactory.getMetamodel();

	for (ManagedType<?> managedType : metamodel.getManagedTypes())
		if (managedType.getJavaType().isAnnotationPresent(Entity.class))
			entityClasses.add(managedType.getJavaType());

	return entityClasses;
}
 

private void analyze(T aObject)
{
    if (aObject != null) {
        entityClass = HibernateProxyHelper.getClassWithoutInitializingProxy(aObject);

        String idProperty = null;
        Metamodel metamodel = getEntityManager().getMetamodel();
        EntityType entity = metamodel.entity(entityClass);
        Set<SingularAttribute> singularAttributes = entity.getSingularAttributes();
        for (SingularAttribute singularAttribute : singularAttributes) {
            if (singularAttribute.isId()) {
                idProperty = singularAttribute.getName();
                break;
            }
        }
        if (idProperty == null) {
            throw new RuntimeException("id field not found");
        }

        DirectFieldAccessor accessor = new DirectFieldAccessor(aObject);
        id = (Number) accessor.getPropertyValue(idProperty);
    }
    else {
        entityClass = null;
        id = null;
    }
}
 

public Metamodel getMetamodel() {
    final EntityManager entityManager = getEntityManager();
    try {
        final Timer timer = Op.getMetamodel.start(this.timer, this);
        try {
            return entityManager.getMetamodel();
        } finally {
            timer.stop();
        }
    } finally {
        closeIfNoTx(entityManager);
    }
}
 

private <T> String getTableName(EntityManager em, Class<T> entityClass){
	/*
	 * Check if the specified class is present in the metamodel.
	 * Throws IllegalArgumentException if not.
	 */
	Metamodel meta = em.getMetamodel();
	EntityType<T> entityType = meta.entity(entityClass);
	
	//Check whether @Table annotation is present on the class.
	Table t = entityClass.getAnnotation(Table.class);
	
	String tableName = (t == null) ? entityType.getName().toUpperCase() : t.name();
	return tableName;
}
 

@Override
public Metamodel getMetamodel() {
	return delegate.getMetamodel();
}
 

@Override
public Metamodel getMetamodel() {
	return delegate.getMetamodel();
}
 

@Override
public Metamodel getMetamodel() {
    try (EntityManagerResult emr = getEntityManager()) {
        return emr.em.getMetamodel();
    }
}
 

@Override
public Metamodel getMetamodel() {
    return delegate().getMetamodel();
}
 

@Override
public Metamodel getMetamodel() {
    return em.getMetamodel();
}
 

@Override
public Metamodel getMetamodel() {
    return em.getMetamodel();
}
 

@Override
public Metamodel getMetamodel() {
    return em.getMetamodel();
}
 

@Override
public Metamodel getMetamodel() {
	return delegate.getMetamodel();
}
 

public Attribute getIdAttribute(EntityManager em, Class<T> clazz) {
    Metamodel m = em.getMetamodel();
    IdentifiableType<T> of = (IdentifiableType<T>) m.managedType(clazz);
    return of.getId(of.getIdType().getJavaType());
}
 

/**
 * This method adds the normal fields to the model entry structure
 *
 * @param modelEntity: the model entity to complete adding normal fields
 *
 * @return a list of entities in ONE_TO_MANY relationship with the entity passed in as parameter (i.e. entities whose input entity is related to by means of
 *         e foreign key - MANY_TO_ONE relatioship)
 */
public List<IModelEntity> addNormalFields(IModelEntity modelEntity) {

	logger.debug("Adding the field " + modelEntity.getName());
	List<IModelEntity> subEntities = new ArrayList<IModelEntity>();
	EntityType thisEntityType = null;

	Metamodel classMetadata = getEntityManager().getMetamodel();

	for (Iterator it = classMetadata.getEntities().iterator(); it.hasNext();) {
		EntityType et = (EntityType) it.next();
		if (et.getJavaType().getName().equals(modelEntity.getType())) {
			thisEntityType = et;
			break;
		}
	}

	if (thisEntityType == null) {
		return new ArrayList();
	}

	Set<Attribute> attributes = thisEntityType.getAttributes();
	Iterator<Attribute> attributesIt = attributes.iterator();

	while (attributesIt.hasNext()) {
		Attribute a = attributesIt.next();
		// normal attribute
		if (a.getPersistentAttributeType().equals(PersistentAttributeType.BASIC)) {
			addField(a, modelEntity, "");
		} else if (a.getPersistentAttributeType().equals(PersistentAttributeType.MANY_TO_ONE)) { // relation
			Class c = a.getJavaType();
			javax.persistence.JoinColumn joinColumn = null;
			String entityType = c.getName();
			String columnName = a.getName();
			String joinColumnnName = a.getName();
			String entityName = a.getName(); // getEntityNameFromEntityType(entityType);

			try {
				joinColumn = (((java.lang.reflect.Field) a.getJavaMember()).getAnnotation(javax.persistence.JoinColumn.class));
			} catch (Exception e) {
				logger.error("Error loading the join column annotation for entity " + entityName, e);
			}

			if (joinColumn != null) {
				joinColumnnName = joinColumn.name();
				// add in the entity a property that maps the column name with the join column
				modelEntity.getProperties().put(columnName, joinColumnnName);
			}

			IModelEntity subentity = new ModelEntity(entityName, null, columnName, entityType, modelEntity.getStructure());
			subEntities.add(subentity);
		} else if (a.getPersistentAttributeType().equals(PersistentAttributeType.EMBEDDED)) { // key
			Set<Attribute> keyAttre = ((EmbeddableType) ((SingularAttribute) a).getType()).getAttributes();
			Iterator<Attribute> keyIter = keyAttre.iterator();
			while (keyIter.hasNext()) {
				addField(keyIter.next(), modelEntity, a.getName() + ".");
			}
		}
	}

	logger.debug("Field " + modelEntity.getName() + " added");
	return subEntities;
}
 

/** エンティティのメタ情報を返します。 */
public Metamodel metamodel() {
    return metamodel;
}
 

private EntityType<T> getEntityMetaModel() {
  Metamodel metamodel = getEntityManager().getMetamodel();
  EntityType<T> entity = metamodel.entity(domainClass);
  return entity;
}
 

/** エンティティのメタ情報を返します。 */
public Metamodel metamodel() {
    return metamodel;
}
 

public Metamodel getMetamodel() {
    throw new UnsupportedOperationException("Not supported.");
}
 

public Metamodel getMetamodel() {
    throw new UnsupportedOperationException("Not supported.");
}
 

@Override
public Metamodel getMetamodel() {

    return getEntityManager().getMetamodel();
}
 

@Override
public Metamodel getMetamodel() {
    return em.getMetamodel();
}
 

public JPAEdmModel(final Metamodel metaModel, final String pUnitName) {
  super(metaModel, pUnitName);
}
 

public JPAEdmBaseViewImpl(final Metamodel metaModel, final String pUnitName) {
  this.metaModel = metaModel;
  this.pUnitName = pUnitName;
}
 

@Override
public Metamodel getJPAMetaModel() {
  return metaModel;
}
 

private Metamodel mockMetaModel() {
  Metamodel metaModel = EasyMock.createMock(Metamodel.class);
  EasyMock.expect(metaModel.getEntities()).andStubReturn(getLocalEntities());
  EasyMock.replay(metaModel);
  return metaModel;
}