org.hibernate.boot.cfgxml.spi.LoadedConfig.java Source code

Java tutorial

Introduction

Here is the source code for org.hibernate.boot.cfgxml.spi.LoadedConfig.java

Source

/*
 * 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);
    }
}