项目：tap17-muggl-javaee
文件：StaticEntityConstraintManager.java
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(),Expression.INT)));
}
}
}
if(uniqueNumericObjects.size() > 1) {
solver.addConstraint(new AllDifferent(uniqueNumericObjects));
}
}
}
项目：tap17-muggl-javaee
文件：EntityConstraintAnalyzer.java
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;
}
项目：mycore
文件：MCRJPABootstrapper.java
@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());
}
项目：mycore
文件：MCRJPABootstrapper.java
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);
}
}
项目：lider
文件：PluginDbServiceImpl.java
/**
* 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;
}
@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")));
}
@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);
}
@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();
}
@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);
}
}
}
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,((Attribute)obj).isAssociation());
logger.log(Level.INFO,((Attribute)obj).getPersistentAttributeType());
}
}
EntityType<Item> item = metamodel.entity(Item.class);
}
项目：olingo-odata2
文件：ODataJPAContextMock.java
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;
}
项目：Hibernate-Search-GenericJPA
文件：MassIndexerImpl.java
@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;
}
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<>();
}
项目：holon-datastore-jpa
文件：EntityTargetCache.java
/**
* 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;
}
项目：webpedidos
文件：Produtos.java
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();
}
项目：YCBugsManager
文件：JpaMappingTest.java
@Test
public void allClassMapping() throws Exception {
metamodel model = em.getEntityManagerFactory().getmetamodel();
assertthat(model.getEntities()).as("No entity mapping found").isNotEmpty();
for (EntityType entityType : model.getEntities()) {
String entityName = entityType.getName();
em.createquery("select o from " + entityName + " o").getResultList();
logger.info("ok: " + entityName);
}
}
项目：cibet
文件：AnnotationUtil.java
/**
* returns the name of the primary key field
*
* @param clazz
* @return
*/
public static <T> String primaryKeyName(Class<T> clazz) {
metamodel metamodel = Context.internalRequestScope().getApplicationEntityManager().getmetamodel();
EntityType<T> entityType = metamodel.entity(clazz);
if (!entityType.hasSingleIdAttribute()) {
String msg = "Composite persistence ID classes are not supported";
throw new RuntimeException(msg);
}
Class<?> idClass = entityType.getIdType().getJavaType();
log.debug("idClass: " + idClass.getName());
String idName = entityType.getId(idClass).getName();
log.debug("found id for class " + clazz.getName() + ": " + idName);
return idName;
}
public EntityFilter(metamodel metamodel,SecurePersistenceUnitUtil util,Collection<AccessRule> accessRules,SubselectEvaluator... evaluators) {
this.metamodel = notNull(metamodel.class,metamodel);
this.persistenceUnitUtil = notNull(SecurePersistenceUnitUtil.class,util);
this.parser = new JpqlParser();
this.compiler = new JpqlCompiler(metamodel);
this.queryEvaluator = new QueryEvaluator(compiler,util,evaluators);
this.accessRules = accessRules;
}
public AccessRulesParser(String persistenceUnitName,metamodel metamodel,SecurityContext securityContext,AccessRulesProvider accessRulesProvider) {
this.metamodel = notNull(metamodel.class,metamodel);
this.securityContext = notNull(SecurityContext.class,securityContext);
this.accessRulesProvider = notNull(AccessRulesProvider.class,accessRulesProvider);
compiler = new AccessRulesCompiler(metamodel);
}
public QueryOptimizer(metamodel metamodel,SecurePersistenceUnitUtil persistenceUnitUtil,Map<Alias,Object> aliases,Map<String,Object> namedParameters,Map<Integer,Object> positionalParameters,QueryEvaluator evaluator) {
this.evaluator = evaluator;
this.parameters = new QueryEvaluationParameters(metamodel,persistenceUnitUtil,aliases,namedParameters,positionalParameters,QueryEvaluationParameters.EvaluationType.OPTIMIZE_QUERY);
}
/**
* Returns <tt>true</tt>,if the specified type is a superclass of the selected type
* of this access rule and so this rule may be assignable if the type of the concrete
* entity is of the selected type or a subclass.
*/
public boolean mayBeAssignable(Class<?> type,metamodel metamodel) {
if (type == null) {
return false;
}
return type.isAssignableFrom(getSelectedType(metamodel));
}
/**
* Returns the types of the selected paths.
* @param metamodel the mapping @R_343_4045@ion to determine the types
* @return the types
* @see #getSelectedpaths()
*/
public Map<Path,Class<?>> getSelectedTypes(metamodel metamodel) {
Map<Path,Class<?>> selectedTypes = new HashMap<Path,Class<?>>();
for (Path selectedpath: getSelectedpaths()) {
selectedTypes.put(selectedpath,TypeDeFinition.Filter.managedTypeForPath(selectedpath)
.withmetamodel(metamodel)
.filter(getTypeDeFinitions())
.getJavaType());
}
return selectedTypes;
}
public QueryEvaluationParameters(metamodel metamodel,EvaluationType evaluationType) {
this.metamodel = notNull(metamodel.class,persistenceUnitUtil);
this.aliases = aliases;
this.namedParameters = namedParameters;
this.positionalParameters = positionalParameters;
this.evaluationType = evaluationType;
}
private List<AccessRule> initializeAccessRules(metamodel metamodel) throws ParseException {
JpqlParser parser = new JpqlParser();
AccessRulesCompiler compiler = new AccessRulesCompiler(metamodel);
String rule = "GRANT READ ACCESS TO MethodAccesstestBean testBean WHERE testBean.name = CURRENT_PRINCIPAL";
JpqlAccessRule parsedRule = parser.parseRule(rule);
return new ArrayList<AccessRule>(compiler.compile(parsedRule));
}
@Test
public void rulesOnInterfaces() {
SecurityContext securityContext = mock(SecurityContext.class);
metamodel metamodel = mock(metamodel.class);
EntityType parentTestBeanType = mock(EntityType.class);
EntityType childTestBeanType = mock(EntityType.class);
EntityType methodAccesstestBeanType = mock(EntityType.class);
BasicType stringType = mock(BasicType.class);
Singularattribute nameAttribute = mock(Singularattribute.class);
when(metamodel.getManagedTypes()).thenReturn(new HashSet(Arrays.asList(
parentTestBeanType,childTestBeanType,methodAccesstestBeanType)));
when(metamodel.getEntities()).thenReturn(new HashSet(Arrays.asList(
parentTestBeanType,methodAccesstestBeanType)));
when(metamodel.managedType(ParentTestBean.class)).thenReturn(parentTestBeanType);
when(metamodel.managedType(ChildTestBean.class)).thenReturn(childTestBeanType);
when(metamodel.managedType(MethodAccesstestBean.class)).thenReturn(methodAccesstestBeanType);
when(parentTestBeanType.getName()).thenReturn(ParentTestBean.class.getSimpleName());
when(parentTestBeanType.getJavaType()).thenReturn(ParentTestBean.class);
when(parentTestBeanType.getAttribute("name")).thenReturn(nameAttribute);
when(childTestBeanType.getName()).thenReturn(ChildTestBean.class.getSimpleName());
when(childTestBeanType.getJavaType()).thenReturn(ChildTestBean.class);
when(childTestBeanType.getAttribute("name")).thenReturn(nameAttribute);
when(methodAccesstestBeanType.getName()).thenReturn(MethodAccesstestBean.class.getSimpleName());
when(methodAccesstestBeanType.getJavaType()).thenReturn(MethodAccesstestBean.class);
when(methodAccesstestBeanType.getAttribute("name")).thenReturn(nameAttribute);
when(nameAttribute.getType()).thenReturn(stringType);
when(nameAttribute.getJavaType()).thenReturn(String.class);
when(stringType.getPersistenceType()).thenReturn(PersistenceType.BASIC);
AccessRulesParser parser
= new AccessRulesParser("interface",metamodel,securityContext,new XmlAccessRulesProvider("interface"));
assertEquals(2,parser.parseAccessRules().size());
}
private MappedpathEvaluator createPathEvaluator() throws NoSuchFieldException {
metamodel metamodel = mock(metamodel.class);
SecurePersistenceUnitUtil persistenceUnitUtil = mock(SecurePersistenceUnitUtil.class);
EntityType userType = mock(EntityType.class);
EntityType groupType = mock(EntityType.class);
Attribute groupsAttribute = mock(Attribute.class);
Attribute fullHierarchyAttribute = mock(Attribute.class);
when(metamodel.managedType(User.class)).thenReturn(userType);
when(metamodel.managedType(Group.class)).thenReturn(groupType);
when(persistenceUnitUtil.isLoaded(any())).thenReturn(true);
when(persistenceUnitUtil.initialize(any())).thenAnswer(new Answer<Object>() {
@Override
public Object answer(InvocationOnMock invocation) throws Throwable {
return invocation.getArgument(0);
}
});
when(userType.getAttributes()).thenReturn(Collections.singleton(groupsAttribute));
when(userType.getAttribute("groups")).thenReturn(groupsAttribute);
when(groupType.getAttributes()).thenReturn(Collections.singleton(fullHierarchyAttribute));
when(groupType.getAttribute("fullHierarchy")).thenReturn(fullHierarchyAttribute);
when(groupsAttribute.getName()).thenReturn("groups");
when(groupsAttribute.getJavaMember()).thenReturn(User.class.getDeclaredField("groups"));
when(fullHierarchyAttribute.getName()).thenReturn("fullHierarchy");
when(fullHierarchyAttribute.getJavaMember())
.thenReturn(Group.class.getDeclaredField("fullHierarchy"));
return new MappedpathEvaluator(metamodel,persistenceUnitUtil);
}
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;
}
项目：opencucina
文件：JpaSearchQueryGeneratorTest.java
/**
* Sets up for test
*/
@SuppressWarnings("unchecked")
@Before
public void onSetUp()
throws Exception {
queryGenerator = new JpaSearchQueryGenerator();
EntityManager entityManager = mock(EntityManager.class);
metamodel mm = mock(metamodel.class);
ManagedType<Baz> bazm = mock(ManagedType.class);
when(mm.managedType(Baz.class)).thenReturn(bazm);
ManagedType<Bar> barm = mock(ManagedType.class);
when(mm.managedType(Bar.class)).thenReturn(barm);
ManagedType<Foo> foom = mock(ManagedType.class);
when(mm.managedType(Foo.class)).thenReturn(foom);
when(entityManager.getmetamodel()).thenReturn(mm);
queryGenerator.setEntityManager(entityManager);
InstanceFactory instanceFactory = new PackageBasedInstanceFactory(ClassUtils.getPackageName(
Foo.class) + ".");
queryGenerator.setInstanceFactory(instanceFactory);
defaultAliasByType = new LinkedHashMap<String,String>();
defaultAliasByType.put(Foo.TYPE,FOO_ALIAS);
defaultTypeByAlias = new LinkedHashMap<String,String>();
defaultTypeByAlias.put(FOO_ALIAS,Foo.TYPE);
}
项目：owsi-core-parent
文件：EntityDaoImpl.java
@Override
@SuppressWarnings("unchecked")
public <E extends GenericEntity<?,?>> List<Class<? extends E>> listAssignableEntityTypes(Class<E> superclass) {
List<Class<? extends E>> classes = Lists.newLinkedList();
metamodel metamodel = entityManager.getmetamodel();
for (EntityType<?> entity : metamodel.getEntities()) {
Class<?> clazz = entity.getBindableJavaType();
if (superclass.isAssignableFrom(clazz)) {
classes.add((Class<? extends E>) clazz);
}
}
return classes;
}
项目：webanno
文件：EntityModel.java
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;
}
}
项目：random-jpa
文件：HibernateProvider.java
private Map<String,Object> getMetaDataMap(final EntityManagerFactory entityManagerFactory) {
try {
final metamodel metamodel = entityManagerFactory.getmetamodel();
return (Map<String,Object>) Util.invokeMethod(metamodel,"entityPersisters");
} catch (final Exception e) {
final Object sessionFactory = invokeMethod(entityManagerFactory,"getSessionFactory");
return (Map<String,Object>) invokeMethod(sessionFactory,"getAllClassMetadata");
}
}
项目：persistence
文件：PersistenceManagerImplJpa.java
/**
* {@inheritDoc}
*/
@Override
@SuppressWarnings({ "unchecked","rawtypes" })
protected void doInitialize() {
super.doInitialize();
if (this.entityManager == null) {
throw new ResourceMissingException("entityManager");
}
if (this.pojoFactory == null) {
DefaultPojoFactory factory = new DefaultPojoFactory();
factory.initialize();
this.pojoFactory = factory;
}
metamodel metamodel = this.entityManager.getmetamodel();
Set<EntityType<?>> entities = metamodel.getEntities();
getLogger().info("EntityManager registered with " + entities.size() + " entities.");
for (EntityType<?> entityType : entities) {
Class<?> entityClass = entityType.getJavaType();
if (entityClass == null) {
// ignore entities that have no java type such as audit/jornal tables from envers.
} else if (GenericEntity.class.isAssignableFrom(entityClass)) {
if (!hasDao((Class<? extends GenericEntity<?>>) entityClass)) {
JpaGenericDao manager = new JpaGenericDao(entityClass);
manager.setEntityManager(this.entityManager);
manager.setPojoFactory(this.pojoFactory);
manager.initialize();
addDao(manager);
getLogger().info("Added generic manager for entity " + entityClass.getName());
} else {
getLogger().debug("Found registered manager for entity " + entityClass.getName());
}
} else {
getLogger().warn(
"Entity " + entityClass.getName() + " does NOT implement " + GenericEntity.class.getName());
}
}
}
private Table addEntity(MetadataFactory mf,metamodel model,EntityType<?> entity) throws TranslatorException {
Table table = mf.getSchema().getTable(entity.getName());
if (table == null) {
table = mf.addTable(entity.getName());
table.setSupportsUpdate(true);
table.setProperty(ENTITYCLASS,entity.getJavaType().getCanonicalName());
addPrimaryKey(mf,model,entity,table);
addSingularattributes(mf,table);
}
return table;
}
private void addForeignKeys(MetadataFactory mf,ManagedType<?> entity,Table entityTable) throws TranslatorException {
for (Attribute<?,?> attr:entity.getAttributes()) {
if (attr.isCollection()) {
PluralAttribute pa = (PluralAttribute)attr;
Table forignTable = null;
for (EntityType et:model.getEntities()) {
if (et.getJavaType().equals(pa.getElementType().getJavaType())) {
forignTable = mf.getSchema().getTable(et.getName());
break;
}
}
if (forignTable == null) {
continue;
}
// add foreign keys as columns in table first; check if they exist first
ArrayList<String> keys = new ArrayList<String>();
KeyRecord pk = entityTable.getPrimaryKey();
for (Column entityColumn:pk.getColumns()) {
addColumn(mf,entityColumn.getName(),entityColumn.getDatatype().getRuntimeTypeName(),forignTable);
keys.add(entityColumn.getName());
}
if (!foreignKeyExists(keys,forignTable)) {
addForiegnKey(mf,attr.getName(),keys,entityTable.getName(),forignTable);
}
}
}
}
public void doMD(){
metamodel md = em.getmetamodel();
EntityType<Employee> employee = md.entity(Employee.class);
for(Attribute<? super Employee,?> attr : employee.getAttributes()){
System.out.println(attr.getName() + " | " + attr.getJavaType().getName() + " | " + attr.getPersistentAttributeType());
}
}
项目：tesora-dve-pub
文件：CatalogSchemaGenerator.java
private static String[] buildCreateCurrentSchema(CatalogDAO c,Properties catalogProperties) throws PEException {
ArrayList<String> buf = new ArrayList<String>();
EntityManagerFactory emf = c.getEntityManager().getEntityManagerFactory();
Configuration cfg = new Configuration();
metamodel model = emf.getmetamodel();
for(EntityType<?> e : model.getEntities()) {
cfg.addAnnotatedClass(e.getBindableJavaType());
}
String[] out = cfg.generateSchemaCreationScript(Dialect.getDialect(catalogProperties));
buf.addAll(Arrays.asList(out));
buf.addAll(Arrays.asList(getAdditionalCommands()));
// current version table must be last - necessary for the upgraded code needed test
buf.addAll(CatalogVersions.getCurrentVersion().buildCurrentVersionTable());
return buf.toArray(new String[0]);
}
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 [email protected] 举报，一经查实，本站将立刻删除。