Java Metamodel类代码示例

import javax.persistence.metamodel.Metamodel; //导入依赖的package包/类
protected static void addIdFieldConstraints(Metamodel metamodel, SolverManager solver, VirtualObjectDatabase vodb) {
		Map<String, Set<DatabaseObject>> reqData = vodb.getPreExecutionRequiredData();
		for(String entityName : reqData.keySet()) {
			String idName = EntityConstraintAnalyzer.getIdFieldName(entityName);
			Set<Expression> uniqueNumericObjects = new HashSet<>();
			for(DatabaseObject dbObj : reqData.get(entityName)) {
				Object o = dbObj.valueMap().get(idName);
				if(o != null && o instanceof NumericVariable) {
					uniqueNumericObjects.add((NumericVariable)o);
//					solver.addConstraint(GreaterOrEqual.newInstance((NumericVariable)o, NumericConstant.getInstance(0, Expression.INT)));
				}
				else if(o != null && o instanceof IObjectreference && ((IObjectreference)o).getObjectType().equals("java.lang.String")) {
					Object value = ((IObjectreference)o).valueMap().get("value");
					if(value instanceof ISymbolicArrayref) {
						solver.addConstraint(GreaterThan.newInstance(((ISymbolicArrayref)value).getSymbolicLength(), NumericConstant.getInstance(0, Expression.INT)));
					}
				}
			}
			if(uniqueNumericObjects.size() > 1) {
				solver.addConstraint(new AllDifferent(uniqueNumericObjects));
			}
		}
	}
 

import javax.persistence.metamodel.Metamodel; //导入依赖的package包/类
public static Set<String> getIdFieldNames(Metamodel metamodel, String entityName) {
	Set<String> ids = entityIdMap.get(entityName);
	if(ids == null) {
		ids = new HashSet<>();
		for(EntityType<?> et : metamodel.getEntities()) {
			if(et.getJavaType().getName().equals(entityName)) {
				if(et.hasSingleIdAttribute()) {
					ids.add(et.getId(et.getIdType().getJavaType()).getName());
				} else {
					for(SingularAttribute<?, ?> idAttribute : et.getIdClassAttributes()) {
						ids.add(idAttribute.getName());
					}
				}
			}
		}
	}
	if(ids.size() == 0) {
		ids.add("id");
	}
	return ids;
}
 

import javax.persistence.metamodel.Metamodel; //导入依赖的package包/类
@Override
public void startUp(ServletContext servletContext) {
    try {
        initializeJPA();
    } catch (PersistenceException e) {
        //fix for MCR-1236
        if (MCRConfiguration.instance().getBoolean("MCR.Persistence.Database.Enable", true)) {
            LogManager.getLogger()
                .error(() -> "Could not initialize JPA. Database access is disabled in this session.", e);
            MCRConfiguration.instance().set("MCR.Persistence.Database.Enable", 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());
}
 

import javax.persistence.metamodel.Metamodel; //导入依赖的package包/类
private void checkHibernateMappingConfig(Metamodel metamodel) {
    Set<String> mappedEntities = metamodel
        .getEntities()
        .stream()
        .map(EntityType::getJavaType)
        .map(Class::getName)
        .collect(Collectors.toSet());
    List<String> unMappedEntities = MCRConfiguration
        .instance()
        .getStrings("MCR.Hibernate.Mappings", Collections.emptyList())
        .stream()
        .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);
    }
}
 

import javax.persistence.metamodel.Metamodel; //导入依赖的package包/类
/**
 * Returns the table name for a given entity type in the
 * {@link EntityManager}.
 * 
 * @param entityClass
 * @return
 */
public <T> String getTableName(Class<T> entityClass) {
	/*
	 * Check if the specified class is present in the metamodel. Throws
	 * IllegalArgumentException if not.
	 */
	Metamodel meta = entityManager.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();
	logger.debug("Table name found: {}", tableName);
	return tableName;
}
 

import javax.persistence.metamodel.Metamodel; //导入依赖的package包/类
@Test
public void ruleWithSubselect() throws ParseException {
    String rule = " GRANT READ ACCESS TO ClientDetails cd "
                + " WHERE cd.clientRelations.client.id "
                + " IN (SELECT cs.client.id FROM ClientStaffing cs, ClientStatus cst, Employee e "
                + "     WHERE e.email=CURRENT_PRINCIPAL AND cs.employee=e "
                + "       AND cs.client= cd.clientRelation.client AND cs.endDate IS NULL "
                + "       AND (cst.name <> 'Closed' OR cst.name IS NULL ))";
    Metamodel metamodel = mock(Metamodel.class);
    EntityType clientTradeImportMonitorType = mock(EntityType.class);
    when(metamodel.getEntities()).thenReturn(Collections.<EntityType<?>>singleton(clientTradeImportMonitorType));
    when(clientTradeImportMonitorType.getName()).thenReturn(ClientDetails.class.getSimpleName());
    when(clientTradeImportMonitorType.getJavaType()).thenReturn(ClientDetails.class);
    JpqlParser parser = new JpqlParser();
    AccessRulesCompiler compiler = new AccessRulesCompiler(metamodel);

    JpqlAccessRule accessRule = parser.parseRule(rule);
    Collection<AccessRule> compiledRules = compiler.compile(accessRule);
    assertThat(compiledRules.size(), is(1));
    AccessRule compiledRule = compiledRules.iterator().next();
    assertThat(compiledRule.getSelectedPath(), is(new Path("cd")));
}
 

import javax.persistence.metamodel.Metamodel; //导入依赖的package包/类
@Before
public void initialize() throws Exception {
    metamodel = mock(Metamodel.class);
    EntityType contactType = mock(EntityType.class);
    SingularAttribute ownerAttribute = mock(SingularAttribute.class);
    accessManager = mock(DefaultAccessManager.class);
    when(accessManager.getContext()).thenReturn(new DefaultSecurityContext());
    when(contactType.getName()).thenReturn(Contact.class.getSimpleName());
    when(contactType.getJavaType()).thenReturn((Class)Contact.class);
    when(metamodel.getEntities())
        .thenReturn(new HashSet<EntityType<?>>(Arrays.<EntityType<?>>asList(contactType)));
    when(metamodel.entity(Contact.class)).thenReturn(contactType);
    when(metamodel.managedType(Contact.class)).thenReturn(contactType);
    when(contactType.getAttributes()).thenReturn(Collections.singleton(ownerAttribute));
    when(contactType.getAttribute("owner")).thenReturn(ownerAttribute);
    when(ownerAttribute.getName()).thenReturn("owner");
    when(ownerAttribute.getJavaMember()).thenReturn(Contact.class.getDeclaredField("owner"));

    DefaultAccessManager.Instance.register(accessManager);

    JpqlParser parser = new JpqlParser();
    JpqlAccessRule rule
        = parser.parseRule("GRANT READ ACCESS TO Contact contact WHERE contact.owner = CURRENT_PRINCIPAL");
    AccessRulesCompiler compiler = new AccessRulesCompiler(metamodel);
    accessRules = compiler.compile(rule);
}
 

import javax.persistence.metamodel.Metamodel; //导入依赖的package包/类
@Before
public void initialize() {
    metamodel = mock(Metamodel.class);
    EntityType testBeanType = mock(EntityType.class);
    when(metamodel.getEntities()).thenReturn(Collections.<EntityType<?>>singleton(testBeanType));
    when(testBeanType.getName()).thenReturn(TestBean.class.getSimpleName());
    when(testBeanType.getJavaType()).thenReturn(TestBean.class);
    securityContext = mock(SecurityContext.class);
    accessManager = mock(DefaultAccessManager.class);
    DefaultAccessManager.Instance.register(accessManager);

    parser = new JpqlParser();
    compiler = new AccessRulesCompiler(metamodel);
    entityManagerFactory = Persistence.createEntityManagerFactory("hibernate");
    criteriaVisitor = new CriteriaVisitor(metamodel, entityManagerFactory.getCriteriaBuilder());
    EntityManager entityManager = entityManagerFactory.createEntityManager();
    entityManager.getTransaction().begin();
    bean1 = new TestBean();
    bean2 = new TestBean();
    entityManager.persist(bean1);
    entityManager.persist(bean2);
    entityManager.getTransaction().commit();
    entityManager.close();
}
 

import javax.persistence.metamodel.Metamodel; //导入依赖的package包/类
@Test
public void makeSureEntityIDCanbeDetect() {
	Metamodel model = entityManager.getMetamodel();
	final Reflections reflections = new Reflections(EntityIDTest.class.getPackage().getName());
	Set<Class<?>> entities = reflections.getTypesAnnotatedWith(Entity.class);

	for (Class<?> entity : entities) {
		EntityType<?> entityType = model.entity(entity);
		Class<?> id = entityType.getIdType().getJavaType();
		System.out.println(entityType);
		if (entity.equals(InvalidEntity.class)) {
			Assert.assertEquals(id, Serializable.class);
		} else {
			Assert.assertNotEquals(id, Serializable.class);
		}
	}
}
 

import javax.persistence.metamodel.Metamodel; //导入依赖的package包/类
public void printPersistenceModel() {
    Metamodel metaModel = entityManager.getMetamodel();
    Set<EntityType<? extends Object>> types = metaModel.getEntities();
    for(EntityType<? extends Object> type : types) {
        logger.log(Level.INFO, "--> Type: {0}", type);
        Set attributes = type.getAttributes();
        for(Object obj : attributes) {
            logger.log(Level.INFO, "Name: {0}", ((Attribute)obj).getName());
            logger.log(Level.INFO, "isCollection: {0}", ((Attribute)obj).isCollection());
            logger.log(Level.INFO, "Name: {0}", ((Attribute)obj).isAssociation());
            logger.log(Level.INFO, "Name: {0}", ((Attribute)obj).getPersistentAttributeType());
        }
        
    }
    
    EntityType<Item> item = metaModel.entity(Item.class);
}
 

import javax.persistence.metamodel.Metamodel; //导入依赖的package包/类
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);
  EasyMock.expect(jpqlquery.setParameter(EasyMock.anyInt(), EasyMock.anyObject()))
  .andReturn(jpqlquery).anyTimes();
  EasyMock.replay(em,mm,jpqlquery);
  return em;

}
 

import javax.persistence.metamodel.Metamodel; //导入依赖的package包/类
@SuppressWarnings({"unchecked", "rawtypes"})
private String getIdProperty(Class<?> entityClass) {
	String idProperty = null;
	Metamodel metamodel = this.emf.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 SearchException( "id field not found for: " + entityClass );
	}
	return idProperty;
}
 

import javax.persistence.metamodel.Metamodel; //导入依赖的package包/类
public RequiredDatabaseStateTextGenerator(Metamodel metamodel, Solution solution, SymbolicObjectStore objectStore) {
	this.metamodel = metamodel;
	this.objectFieldNameMap = new HashMap<>();
	this.generatedEntityCounterMap = new HashMap<>();
	this.solution = solution;
	this.objectStore = objectStore;
	this.entityObjectIds = new HashSet<>();
}
 

import javax.persistence.metamodel.Metamodel; //导入依赖的package包/类
/**
 * Try to obtain JPA Entity mapping class from given path name using given ClassLoader
 * @param classLoader ClassLoader to use
 * @param name Path name (not null)
 * @param metamodel JPA Metamodel (not null)
 * @return Entity class, or <code>null</code> target was null
 */
public synchronized static Optional<Class<?>> resolveEntityClass(ClassLoader classLoader, String name,
		Metamodel metamodel) {

	ObjectUtils.argumentNotNull(name, "Name must be not null");
	ObjectUtils.argumentNotNull(metamodel, "Metamodel name must be not null");

	final ClassLoader cl = (classLoader != null) ? classLoader : ClassUtils.getDefaultClassLoader();

	// check cache
	Map<String, Class<?>> mappings = ENTITY_TARGETS.getOrDefault(cl, Collections.emptyMap());
	if (mappings.containsKey(name)) {
		return Optional.of(mappings.get(name));
	}

	// try to resolve by entity name
	Optional<Class<?>> entityClass = metamodel.getEntities().stream().filter(e -> e.getName().equals(name))
			.findFirst().map(e -> e.getJavaType());
	// try to resolve by entity type
	if (!entityClass.isPresent()) {
		entityClass = metamodel.getEntities().stream().filter(e -> e.getJavaType().getName().equals(name))
				.findFirst().map(e -> e.getJavaType());
	}

	// cache value
	entityClass.ifPresent(e -> ENTITY_TARGETS.computeIfAbsent(cl, c -> new HashMap<>()).put(name, e));

	return entityClass;

}
 

import javax.persistence.metamodel.Metamodel; //导入依赖的package包/类
public List<Produto> filtrados(ProdutoFilter filter) {

		Metamodel meta = manager.getMetamodel();
		EntityType<Produto> type = meta.entity(Produto.class);

		CriteriaBuilder criteriaBuilder = manager.getCriteriaBuilder();
		CriteriaQuery<Produto> criteriaQuery = criteriaBuilder.createQuery(Produto.class);
		Root<Produto> root = criteriaQuery.from(Produto.class);

		if (StringUtils.isNotBlank(filter.getSku())) {
			Predicate equalsPredicate = criteriaBuilder.equal(root.get("sku"), filter.getSku());
			criteriaQuery.where(equalsPredicate);
		}

		// vamos usar o atributo nome para filtragem e ordenação
		Path<String> nomeAttr = root.get(type.getDeclaredSingularAttribute("nome", String.class));

		if (StringUtils.isNotBlank(filter.getNome())) {
			Expression<String> expr = criteriaBuilder.lower(nomeAttr);

			// where nome like '%nome%'
			String match = String.format("%%%s%%", filter.getNome().toLowerCase());

			Predicate likePredicate = criteriaBuilder.like(expr, match);
			criteriaQuery.where(likePredicate);
		}

		Order ordernacao = criteriaBuilder.asc(nomeAttr);

		criteriaQuery.orderBy(ordernacao);

		return manager.createQuery(criteriaQuery).getResultList();
	}