protected void populateCaches(String targetMode, Map<String, Object> managerMap) { final EntityManager em = getEntityManager(managerMap); final PlatformTransactionManager txManager = getTransactionManager(managerMap); final EJB3ConfigurationDao ejb3ConfigurationDao = getEJB3ConfigurationDao(managerMap); SessionFactory sessionFactory = em.unwrap(Session.class).getSessionFactory(); for (Object item : sessionFactory.getAllClassMetadata().values()) { ClassMetadata metadata = (ClassMetadata) item; Class<?> mappedClass = metadata.getMappedClass(); String managerCacheKey = buildManagerCacheKey(targetMode, mappedClass); ENTITY_MANAGER_CACHE.put(managerCacheKey, em); TRANSACTION_MANAGER_CACHE.put(managerCacheKey, txManager); String ejb3ConfigDaoCacheKey = buildEJB3ConfigDaoCacheKey(mappedClass); if (!EJB3_CONFIG_DAO_CACHE.containsKey(ejb3ConfigDaoCacheKey)) { EJB3_CONFIG_DAO_CACHE.put(ejb3ConfigDaoCacheKey, ejb3ConfigurationDao); } } }
for (Object item : sessionFactory.getAllClassMetadata().values()) { ClassMetadata metadata = (ClassMetadata) item; Class<?> mappedClass = metadata.getMappedClass(); if (mappedClass != null && ceilingClass.isAssignableFrom(mappedClass)) { entities.add(mappedClass);
ClassMetadata metadata = (ClassMetadata) item; String idProperty = metadata.getIdentifierPropertyName(); Class<?> mappedClass = metadata.getMappedClass(); Field idField; try {
public MetamodelUtilFromSessionFactory(SessionFactory factory) { // Go through all the entities for (String entityClassName: factory.getAllClassMetadata().keySet()) { ClassMetadata entityData = factory.getClassMetadata(entityClassName); classToEntityName.put(entityData.getMappedClass(), entityData.getEntityName()); classNameToEntityName.put(entityClassName, entityData.getEntityName()); //System.out.println(entityClassName + " " + entityData.getMappedClass().getCanonicalName() + " " + entityData.getEntityName()); // TODO: It turns out all three values are the same, but I think it's ok for now. scanClassMetadata(entityData); } }
Class<?> entityClass = classMetadata.getMappedClass(); if (Order.class.equals(entityClass)) {
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 Class getMappedClass() { return metadata.getMappedClass(); }
public Class<?> getJavaClass() { return metadata.getMappedClass(); }
private FeatureInvocationHandler(Object o, ClassMetadata meta) { //TODO check if this is sufficiently general. What if not a POJO? if (meta.getMappedClass(EntityMode.POJO) != o.getClass()) { throw new RuntimeException("Metadata and POJO class do not cohere"); } this.target = o; this.metadata = meta; }
@Override protected Class<?> getClassForName(final String name) throws ClassNotFoundException { Collection<ClassMetadata> classes = metadata.values(); for (ClassMetadata classMetadata : classes) { Class<?> mappedClass = classMetadata.getMappedClass(); if (name.equals(mappedClass.getSimpleName())) { return mappedClass; } } return super.getClassForName(name); }
public <T> Class<? extends T> findEntityClassForEntityInterface( SessionFactory sessionFactory, Class<T> entityInterface ) { for (ClassMetadata metadata : sessionFactory.getAllClassMetadata().values()) { Class entityClass = metadata.getMappedClass(EntityMode.POJO); if (entityInterface.isAssignableFrom(entityClass)) { return entityClass; } } return null; }
@Override public void populateEntityDictionary(EntityDictionary dictionary) { /* bind all entities */ for (ClassMetadata meta : sessionFactory.getAllClassMetadata().values()) { dictionary.bindEntity(meta.getMappedClass(EntityMode.POJO)); } }
private ClassMetadata getIndexClassMetadata(String ownerClassName) { if (metaDataMap.containsKey(ownerClassName)) { return metaDataMap.get(ownerClassName); } String indexClassName = ownerClassName + "ContentIndex"; ClassMetadata meta = sessionFactory.getClassMetadata(indexClassName); if (meta != null) { Class<?> indexClass = meta.getMappedClass(); if (ContentIndex.class.isAssignableFrom(indexClass)) { Filter filter = indexClass.getAnnotation(Filter.class); Assert.isTrue(filter != null && filter.name().equals("contentIndex"), String.format("%s must be annotated with @Filter(name=\"contentIndex\")", indexClass.getName())); } else { meta = null; log.warn("Class {} matches the naming convention for content " + "indexes but does not extend ContentIndex.", indexClass); } } metaDataMap.put(ownerClassName, meta); return meta; }
private Method getGetterFor(String property) { Class cl = this.metadata.getMappedClass(EntityMode.POJO); Getter getter = ReflectHelper.getGetter(cl, property); return getter.getMethod(); }
public static void configureHibernateDomainClasses(SessionFactory sessionFactory, String sessionFactoryName, GrailsApplication application) { Map<String, GrailsDomainClass> hibernateDomainClassMap = new HashMap<String, GrailsDomainClass>(); for (Object o : sessionFactory.getAllClassMetadata().values()) { ClassMetadata classMetadata = (ClassMetadata) o; configureDomainClass(sessionFactory, sessionFactoryName, application, classMetadata, classMetadata.getMappedClass(EntityMode.POJO), hibernateDomainClassMap); } configureInheritanceMappings(hibernateDomainClassMap); }
@SuppressWarnings("unchecked") public void postProcessConfiguration(Configuration config) throws IOException, TemplateException { TemplateHashModel statics = getBeansWrapper(config).getStaticModels(); Collection<ClassMetadata> allMetadata = sessionFactory.getAllClassMetadata().values(); for (ClassMetadata meta : allMetadata) { Class<?> mappedClass = meta.getMappedClass(); if (ActiveRecord.class.isAssignableFrom(mappedClass)) { String key = ClassUtils.getShortName(mappedClass); if (config.getSharedVariable(key) != null) { log.warn("Another shared variable with the name '{}'" + " already exist. Use statics[\"{}\"] in your" + " FreeMarker templates to access the static" + " methods of your ActiveRecord class.", key, mappedClass.getName()); } else { TemplateModel tm = statics.get(mappedClass.getName()); config.setSharedVariable(key, tm); } } } }
@Override @SuppressWarnings("deprecation") public Map getAllClassMetadata() throws HibernateException { try { final Map<Class, ClassMetadata> map = new HashMap<>(); for (String entityName : getSessionFactoryV5().getMetamodel().getAllEntityNames()) { org.hibernate.metadata.ClassMetadata metadata = getSessionFactoryV5().getClassMetadata(entityName); map.put(metadata.getMappedClass(), ClassMetadataV2Adapter.adapt(metadata, getSessionFactoryV5(), null)); } return map; } catch (final PersistenceException ex) { throw HibernateExceptionAdapter.adapt(ex); } }
public static References getReferencingClasses(SessionFactory sessionFactory, Class<?> clazz) { References references = new References(); for (Map.Entry<String, ClassMetadata> entry: sessionFactory.getAllClassMetadata().entrySet()) { Class<?> mappedClass = entry.getValue().getMappedClass(); for (String propertyName: entry.getValue().getPropertyNames()) { Type t = entry.getValue().getPropertyType(propertyName); if (t instanceof EntityType) { EntityType entityType=(EntityType) t; if (entityType.getAssociatedEntityName().equals(clazz.getName())) { references.addEntityReference(propertyName, mappedClass); } } else if (t.isCollectionType()) { CollectionType cType = (CollectionType) t; QueryableCollection collectionPersister = (QueryableCollection) ((SessionFactoryImplementor) sessionFactory).getCollectionPersister( cType.getRole()); if (collectionPersister.getElementType().isEntityType() && collectionPersister.getElementPersister().getEntityName().equals(clazz.getName())) { references.addCollectionReference(propertyName, mappedClass); } } } } return references; }
/** * Contributes {@link ApplicationStateContribution}s for all registered Hibernate entity classes. * * @param configuration * Configuration to contribute * @param entitySessionStatePersistenceStrategyEnabled * indicates if contribution should take place * @param sessionSource * creates Hibernate session */ public static void contributeApplicationStateManager( MappedConfiguration<Class, ApplicationStateContribution> configuration, @Symbol(HibernateSymbols.ENTITY_SESSION_STATE_PERSISTENCE_STRATEGY_ENABLED) boolean entitySessionStatePersistenceStrategyEnabled, HibernateSessionSource sessionSource) { if (!entitySessionStatePersistenceStrategyEnabled) return; for (ClassMetadata classMetadata : sessionSource.getSessionFactory().getAllClassMetadata().values()) { final Class entityClass = classMetadata.getMappedClass(); configuration.add(entityClass, new ApplicationStateContribution(HibernatePersistenceConstants.ENTITY)); } }
@Override public void destroy() throws HibernateException { if (grailsApplication.isWarDeployed()) { MetaClassRegistry registry = GroovySystem.getMetaClassRegistry(); Map<?, ?> classMetaData = getSessionFactory().getAllClassMetadata(); for (Object o : classMetaData.values()) { ClassMetadata classMetadata = (ClassMetadata) o; Class<?> mappedClass = classMetadata.getMappedClass(EntityMode.POJO); registry.removeMetaClass(mappedClass); } } try { super.destroy(); } catch (HibernateException e) { if (e.getCause() instanceof NameNotFoundException) { LOG.debug(e.getCause().getMessage(), e); } else { throw e; } } }