Java tutorial
/* * Hibernate, Relational Persistence for Idiomatic Java * * License: GNU Lesser General Public License (LGPL), version 2.1 or later. * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>. */ package org.hibernate.boot.cfgxml.spi; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import org.hibernate.boot.CacheRegionDefinition; import org.hibernate.boot.jaxb.cfg.spi.JaxbCfgCollectionCacheType; import org.hibernate.boot.jaxb.cfg.spi.JaxbCfgConfigPropertyType; import org.hibernate.boot.jaxb.cfg.spi.JaxbCfgEntityCacheType; import org.hibernate.boot.jaxb.cfg.spi.JaxbCfgEventListenerGroupType; import org.hibernate.boot.jaxb.cfg.spi.JaxbCfgEventListenerType; import org.hibernate.boot.jaxb.cfg.spi.JaxbCfgHibernateConfiguration; import org.hibernate.boot.jaxb.cfg.spi.JaxbCfgMappingReferenceType; import org.hibernate.event.spi.EventType; import org.hibernate.secure.spi.GrantedPermission; import org.hibernate.secure.spi.JaccPermissionDeclarations; import org.jboss.logging.Logger; /** * Models the information gleaned from parsing a {@code cfg.xml} file. * <p/> * A LoadedConfig is built via {@link #consume}. An aggregated representation * can be maintained through calls to {@link #merge} */ public class LoadedConfig { private static final Logger log = Logger.getLogger(LoadedConfig.class); private String sessionFactoryName; private final Map configurationValues = new ConcurrentHashMap(16, 0.75f, 1); private Map<String, JaccPermissionDeclarations> jaccPermissionsByContextId; private List<CacheRegionDefinition> cacheRegionDefinitions; private List<MappingReference> mappingReferences; private Map<EventType, Set<String>> eventListenerMap; public LoadedConfig(String sessionFactoryName) { this.sessionFactoryName = sessionFactoryName; } public String getSessionFactoryName() { return sessionFactoryName; } public Map getConfigurationValues() { return configurationValues; } public Map<String, JaccPermissionDeclarations> getJaccPermissionsByContextId() { return jaccPermissionsByContextId; } public JaccPermissionDeclarations getJaccPermissions(String jaccContextId) { return jaccPermissionsByContextId.get(jaccContextId); } public List<CacheRegionDefinition> getCacheRegionDefinitions() { return cacheRegionDefinitions == null ? Collections.<CacheRegionDefinition>emptyList() : cacheRegionDefinitions; } public List<MappingReference> getMappingReferences() { return mappingReferences == null ? Collections.<MappingReference>emptyList() : mappingReferences; } public Map<EventType, Set<String>> getEventListenerMap() { return eventListenerMap == null ? Collections.<EventType, Set<String>>emptyMap() : eventListenerMap; } /** * Consumes the JAXB representation of a {@code cfg.xml} file and builds the * LoadedConfig representation. * * @param jaxbCfg The JAXB representation of a {@code cfg.xml} file * * @return The parsed representation */ public static LoadedConfig consume(JaxbCfgHibernateConfiguration jaxbCfg) { final LoadedConfig cfg = new LoadedConfig(jaxbCfg.getSessionFactory().getName()); for (JaxbCfgConfigPropertyType jaxbProperty : jaxbCfg.getSessionFactory().getProperty()) { cfg.addConfigurationValue(jaxbProperty.getName(), jaxbProperty.getValue()); } for (JaxbCfgMappingReferenceType jaxbMapping : jaxbCfg.getSessionFactory().getMapping()) { cfg.addMappingReference(MappingReference.consume(jaxbMapping)); } for (Object cacheDeclaration : jaxbCfg.getSessionFactory().getClassCacheOrCollectionCache()) { cfg.addCacheRegionDefinition(parseCacheRegionDefinition(cacheDeclaration)); } if (jaxbCfg.getSecurity() != null) { for (JaxbCfgHibernateConfiguration.JaxbCfgSecurity.JaxbCfgGrant grant : jaxbCfg.getSecurity() .getGrant()) { final JaccPermissionDeclarations jaccPermissions = cfg .getOrCreateJaccPermissions(jaxbCfg.getSecurity().getContext()); jaccPermissions.addPermissionDeclaration( new GrantedPermission(grant.getRole(), grant.getEntityName(), grant.getActions())); } } if (!jaxbCfg.getSessionFactory().getListener().isEmpty()) { for (JaxbCfgEventListenerType listener : jaxbCfg.getSessionFactory().getListener()) { final EventType eventType = EventType.resolveEventTypeByName(listener.getType().value()); cfg.addEventListener(eventType, listener.getClazz()); } } if (!jaxbCfg.getSessionFactory().getEvent().isEmpty()) { for (JaxbCfgEventListenerGroupType listenerGroup : jaxbCfg.getSessionFactory().getEvent()) { if (listenerGroup.getListener().isEmpty()) { continue; } final String eventTypeName = listenerGroup.getType().value(); final EventType eventType = EventType.resolveEventTypeByName(eventTypeName); for (JaxbCfgEventListenerType listener : listenerGroup.getListener()) { if (listener.getType() != null) { log.debugf("Listener [%s] defined as part of a group also defined event type", listener.getClazz()); } cfg.addEventListener(eventType, listener.getClazz()); } } } return cfg; } private static String trim(String value) { if (value == null) { return null; } return value.trim(); } @SuppressWarnings("unchecked") private void addConfigurationValue(String propertyName, String value) { value = trim(value); configurationValues.put(propertyName, value); if (!propertyName.startsWith("hibernate.")) { configurationValues.put("hibernate." + propertyName, value); } } private void addMappingReference(MappingReference mappingReference) { if (mappingReferences == null) { mappingReferences = new ArrayList<MappingReference>(); } mappingReferences.add(mappingReference); } private static CacheRegionDefinition parseCacheRegionDefinition(Object cacheDeclaration) { if (JaxbCfgEntityCacheType.class.isInstance(cacheDeclaration)) { final JaxbCfgEntityCacheType jaxbClassCache = (JaxbCfgEntityCacheType) cacheDeclaration; return new CacheRegionDefinition(CacheRegionDefinition.CacheRegionType.ENTITY, jaxbClassCache.getClazz(), jaxbClassCache.getUsage().value(), jaxbClassCache.getRegion(), "all".equals(jaxbClassCache.getInclude())); } else { final JaxbCfgCollectionCacheType jaxbCollectionCache = (JaxbCfgCollectionCacheType) cacheDeclaration; return new CacheRegionDefinition(CacheRegionDefinition.CacheRegionType.COLLECTION, jaxbCollectionCache.getCollection(), jaxbCollectionCache.getUsage().value(), jaxbCollectionCache.getRegion(), false); } } public void addCacheRegionDefinition(CacheRegionDefinition cacheRegionDefinition) { if (cacheRegionDefinitions == null) { cacheRegionDefinitions = new ArrayList<CacheRegionDefinition>(); } cacheRegionDefinitions.add(cacheRegionDefinition); } public void addEventListener(EventType eventType, String listenerClass) { if (eventListenerMap == null) { eventListenerMap = new HashMap<EventType, Set<String>>(); } Set<String> listenerClasses = eventListenerMap.get(eventType); if (listenerClasses == null) { listenerClasses = new HashSet<String>(); eventListenerMap.put(eventType, listenerClasses); } listenerClasses.add(listenerClass); } public JaccPermissionDeclarations getOrCreateJaccPermissions(String contextId) { if (jaccPermissionsByContextId == null) { jaccPermissionsByContextId = new HashMap<String, JaccPermissionDeclarations>(); } JaccPermissionDeclarations jaccPermission = jaccPermissionsByContextId.get(contextId); if (jaccPermission == null) { jaccPermission = new JaccPermissionDeclarations(contextId); } jaccPermissionsByContextId.put(contextId, jaccPermission); return jaccPermission; } /** * Merge information from loaded a {@code cfg.xml} represented by the incoming parameter * into this LoadedConfig representation * * @param incoming The incoming config information to merge in. */ public void merge(LoadedConfig incoming) { if (sessionFactoryName != null) { if (incoming.getSessionFactoryName() != null) { log.debugf( "More than one cfg.xml file attempted to supply SessionFactory name: [%s], [%s]. Keeping initially discovered one [%s]", getSessionFactoryName(), incoming.getSessionFactoryName(), getSessionFactoryName()); } } else { sessionFactoryName = incoming.getSessionFactoryName(); } addConfigurationValues(incoming.getConfigurationValues()); addMappingReferences(incoming.getMappingReferences()); addCacheRegionDefinitions(incoming.getCacheRegionDefinitions()); addJaccPermissions(incoming.getJaccPermissionsByContextId()); addEventListeners(incoming.getEventListenerMap()); } @SuppressWarnings("unchecked") protected void addConfigurationValues(Map configurationValues) { if (configurationValues == null) { return; } this.configurationValues.putAll(configurationValues); } private void addMappingReferences(List<MappingReference> mappingReferences) { if (mappingReferences == null) { return; } if (this.mappingReferences == null) { this.mappingReferences = new ArrayList<MappingReference>(); } this.mappingReferences.addAll(mappingReferences); } private void addCacheRegionDefinitions(List<CacheRegionDefinition> cacheRegionDefinitions) { if (cacheRegionDefinitions == null) { return; } if (this.cacheRegionDefinitions == null) { this.cacheRegionDefinitions = new ArrayList<CacheRegionDefinition>(); } this.cacheRegionDefinitions.addAll(cacheRegionDefinitions); } private void addJaccPermissions(Map<String, JaccPermissionDeclarations> jaccPermissionsByContextId) { if (jaccPermissionsByContextId == null) { return; } if (this.jaccPermissionsByContextId == null) { this.jaccPermissionsByContextId = new HashMap<String, JaccPermissionDeclarations>(); } for (Map.Entry<String, JaccPermissionDeclarations> incomingEntry : jaccPermissionsByContextId.entrySet()) { JaccPermissionDeclarations permissions = jaccPermissionsByContextId.get(incomingEntry.getKey()); if (permissions == null) { permissions = new JaccPermissionDeclarations(incomingEntry.getKey()); this.jaccPermissionsByContextId.put(incomingEntry.getKey(), permissions); } permissions.addPermissionDeclarations(incomingEntry.getValue().getPermissionDeclarations()); } } private void addEventListeners(Map<EventType, Set<String>> eventListenerMap) { if (eventListenerMap == null) { return; } if (this.eventListenerMap == null) { this.eventListenerMap = new HashMap<EventType, Set<String>>(); } for (Map.Entry<EventType, Set<String>> incomingEntry : eventListenerMap.entrySet()) { Set<String> listenerClasses = this.eventListenerMap.get(incomingEntry.getKey()); if (listenerClasses == null) { listenerClasses = new HashSet<String>(); this.eventListenerMap.put(incomingEntry.getKey(), listenerClasses); } listenerClasses.addAll(incomingEntry.getValue()); } } public static LoadedConfig baseline() { return new LoadedConfig(null); } }