configuration.java

通过系统把几乎所有与人力资源相关的数据统一管理

	/**
	 * Configure an <tt>Interceptor</tt>
	 */
	public Configuration setInterceptor(Interceptor interceptor) {
		this.interceptor = interceptor;
		return this;
	}

	/**
	 * Specify a completely new set of properties
	 */
	public Configuration setProperties(Properties properties) {
		this.properties = properties;
		return this;
	}

	/**
	 * Set the given properties
	 */
	public Configuration addProperties(Properties extraProperties) {
		this.properties.putAll(extraProperties);
		return this;
	}

	/**
	 * Set a property
	 */
	public Configuration setProperty(String propertyName, String value) {
		properties.setProperty(propertyName, value);
		return this;
	}

	/**
	 * Get a property
	 */
	public String getProperty(String propertyName) {
		return properties.getProperty(propertyName);
	}

	private void addProperties(Element parent) {
		Iterator iter = parent.elementIterator("property");
		while ( iter.hasNext() ) {
			Element node = (Element) iter.next();
			String name = node.attributeValue("name");
			String value = node.getText().trim();
			log.debug(name + "=" + value);
			properties.setProperty(name, value);
			if ( !name.startsWith("hibernate") ) properties.setProperty("hibernate." + name, value);
		}
		Environment.verifyProperties(properties);
	}

	/**
	 * Get the configuration file as an <tt>InputStream</tt>. Might be overridden
	 * by subclasses to allow the configuration to be located by some arbitrary
	 * mechanism.
	 */
	protected InputStream getConfigurationInputStream(String resource) throws HibernateException {

		log.info("Configuration resource: " + resource);

		InputStream stream = Environment.class.getResourceAsStream(resource);
		if (stream==null) {
			log.warn(resource + " not found");
			throw new HibernateException(resource + " not found");
		}
		return stream;

	}

	/**
	 * Use the mappings and properties specified in an application
	 * resource named <tt>hibernate.cfg.xml</tt>.
	 */
	public Configuration configure() throws HibernateException {
		configure("/hibernate.cfg.xml");
		return this;
	}

	/**
	 * Use the mappings and properties specified in the given application
	 * resource. The format of the resource is defined in
	 * <tt>hibernate-configuration-2.0.dtd</tt>.
	 *
	 * The resource is found via <tt>getConfigurationInputStream(resource)</tt>.
	 */
	public Configuration configure(String resource) throws HibernateException {
		log.info("configuring from resource: " + resource);
		InputStream stream = getConfigurationInputStream(resource);
		return doConfigure(stream, resource);
	}

	/**
	 * Use the mappings and properties specified in the given document.
	 * The format of the document is defined in
	 * <tt>hibernate-configuration-2.0.dtd</tt>.
	 *
	 * @param url URL from which you wish to load the configuration
	 * @return A configuration configured via the file
	 * @throws HibernateException
	 */
	public Configuration configure(URL url) throws HibernateException {
		log.info( "configuring from url: " + url.toString() );
		try {
			return doConfigure( url.openStream(), url.toString() );
		}
		catch (IOException ioe) {
			throw new HibernateException("could not configure from URL: " + url, ioe);
		}
	}

	/**
	 * Use the mappings and properties specified in the given application
	 * file. The format of the file is defined in
	 * <tt>hibernate-configuration-2.0.dtd</tt>.
	 *
	 * @param configFile <tt>File</tt> from which you wish to load the configuration
	 * @return A configuration configured via the file
	 * @throws HibernateException
	 */
	public Configuration configure(File configFile) throws HibernateException {
		log.info( "configuring from file: " + configFile.getName() );
		try {
			return doConfigure( new FileInputStream(configFile), configFile.toString() );
		}
		catch (FileNotFoundException fnfe) {
			throw new HibernateException("could not find file: " + configFile, fnfe);
		}
	}

	/**
	 * Use the mappings and properties specified in the given application
	 * resource. The format of the resource is defined in
	 * <tt>hibernate-configuration-2.0.dtd</tt>.
	 *
	 * @param stream Inputstream to be read from
	 * @param resourceName The name to use in warning/error messages
	 * @return A configuration configured via the stream
	 * @throws HibernateException
	 */
	protected Configuration doConfigure(InputStream stream, String resourceName) throws HibernateException {

		org.dom4j.Document doc;
		try {
			List errors = new ArrayList();
			doc = XMLHelper.createSAXReader(resourceName, errors).read( new InputSource(stream) );
			if ( errors.size()!=0 ) throw new MappingException( "invalid configuration", (Throwable) errors.get(0) );
		}
		catch (Exception e) {
			log.error("problem parsing configuration" + resourceName, e);
			throw new HibernateException("problem parsing configuration" + resourceName, e);
		}
		finally {
			try{
				stream.close();
			} 
			catch (IOException ioe){
				log.error("could not close stream on: " + resourceName, ioe);	
			}
		}
		
		return doConfigure(doc);

	}

	/**
	 * Use the mappings and properties specified in the given XML document.
	 * The format of the file is defined in
	 * <tt>hibernate-configuration-2.0.dtd</tt>.
	 *
	 * @param document an XML document from which you wish to load the configuration
	 * @return A configuration configured via the <tt>Document</tt>
	 * @throws HibernateException if there is problem in accessing the file.
	 */
	public Configuration configure(Document document) throws HibernateException {
		log.info("configuring from XML document");
		org.dom4j.Document doc;
		try {
			doc = XMLHelper.createDOMReader().read(document);
		}
		catch (Exception e) {
			log.error("problem parsing document", e);
			throw new HibernateException("problem parsing document", e);
		}

		return doConfigure(doc);
	}

	protected Configuration doConfigure(org.dom4j.Document doc) throws HibernateException {

		Element sfNode = doc.getRootElement().element("session-factory");
		String name = sfNode.attributeValue("name");
		if (name!=null) properties.setProperty(Environment.SESSION_FACTORY_NAME, name);
		addProperties(sfNode);

		Iterator elements = sfNode.elementIterator();
		while ( elements.hasNext() ) {
			Element mapElement = (Element) elements.next();
			String elemname = mapElement.getName();
			if ( "mapping".equals(elemname) ) {
				Attribute rsrc = mapElement.attribute("resource");
				Attribute file = mapElement.attribute("file");
				Attribute jar = mapElement.attribute("jar");
				if (rsrc!=null) {
					log.debug(name + "<-" + rsrc);
					try {
						addResource( rsrc.getValue(), Thread.currentThread().getContextClassLoader() );
					}
					catch (MappingException me) {
						addResource( rsrc.getValue(), Environment.class.getClassLoader() );
					}
				}
				else if ( jar!=null ) {
					log.debug(name + "<-" + jar);
					addJar( jar.getValue() );
				}
				else {
					if (file==null) throw new MappingException("<mapping> element in configuration specifies no attributes");
					log.debug(name + "<-" + file);
					addFile( file.getValue() );
				}
			}
			else if ( "jcs-class-cache".equals(elemname) || "class-cache".equals(elemname) ) {
				String className = mapElement.attributeValue("class");
				final Class clazz;
				try {
					clazz = ReflectHelper.classForName(className);
				}
				catch (ClassNotFoundException cnfe) {
					throw new MappingException("Could not find class: " + className, cnfe);
				}
				Attribute regionNode = mapElement.attribute("region");
				final String region = (regionNode==null) ? className : regionNode.getValue();
				CacheConcurrencyStrategy cache = CacheFactory.createCache(
					mapElement, region, getRootClassMapping(clazz).isMutable()
				);
				setCacheConcurrencyStrategy(clazz, cache, region);
			}
			else if ( "jcs-collection-cache".equals(elemname) || "collection-cache".equals(elemname) ) {
				String role = mapElement.attributeValue("collection");
				Collection collection = getCollectionMapping(role);
				Attribute regionNode = mapElement.attribute("region");
				final String region = (regionNode==null) ? role : regionNode.getValue();
				CacheConcurrencyStrategy cache = CacheFactory.createCache( 
					mapElement, region, collection.getOwner().isMutable()
				);
				setCacheConcurrencyStrategy(role, cache, region);
			}
		}

		log.info("Configured SessionFactory: " + name);
		log.debug("properties: " + properties);

		return this;

	}
	
	RootClass getRootClassMapping(Class clazz) throws MappingException {
		try {
			return (RootClass) getClassMapping(clazz);
		}
		catch (ClassCastException cce) {
			throw new MappingException("You may only specify a cache for root <class> mappings");
		}
	}
	
	/**
	 * Set up a cache for an entity class
	 * @param clazz
	 * @param concurrencyStrategy
	 * @return Configuration
	 * @throws MappingException
	 */
	public Configuration setCacheConcurrencyStrategy(Class clazz, CacheConcurrencyStrategy concurrencyStrategy) 
	throws MappingException {
		setCacheConcurrencyStrategy( clazz, concurrencyStrategy, clazz.getName() );
		return this;
	}
	
	void setCacheConcurrencyStrategy(Class clazz, CacheConcurrencyStrategy concurrencyStrategy, String region) 
	throws MappingException {
		RootClass rootClass = getRootClassMapping(clazz);
		rootClass.setCache(concurrencyStrategy);
		caches.put( rootClass.getMappedClass().getName(), concurrencyStrategy );
	}
	
	/**
	 * Set up a cache for a collection role
	 * @param collectionRole
	 * @param concurrencyStrategy
	 * @return Configuration
	 * @throws MappingException
	 */
	public Configuration setCacheConcurrencyStrategy(String collectionRole, CacheConcurrencyStrategy concurrencyStrategy) 
	throws MappingException {
		setCacheConcurrencyStrategy(collectionRole, concurrencyStrategy, collectionRole);
		return this;
	}
	
	void setCacheConcurrencyStrategy(String collectionRole, CacheConcurrencyStrategy concurrencyStrategy, String region) 
	throws MappingException {
		Collection collection = getCollectionMapping(collectionRole);
		collection.setCache(concurrencyStrategy);
		Object old = caches.put( collection.getRole(), concurrencyStrategy );
		if (old!=null) throw new MappingException("duplicate cache region");
	}
	
	protected void configureCaches(Settings settings) throws HibernateException {
		
		//TODO: this is actually broken, I guess, since changing the
		//      cache provider property and rebuilding the SessionFactory
		//      will affect existing SessionFactory!

		log.info("instantiating and configuring caches");
		
		String prefix = properties.getProperty(Environment.CACHE_REGION_PREFIX);
		
		Iterator iter = caches.entrySet().iterator();
		while ( iter.hasNext() ) {
			Map.Entry me = (Map.Entry) iter.next();
			String name = (String) me.getKey();
			if (prefix != null)
			    name = prefix + "." + name;
			CacheConcurrencyStrategy strat = (CacheConcurrencyStrategy) me.getValue();
			if ( log.isDebugEnabled() ) log.debug("instantiating cache " + name);
			Cache cache;
			try {
				cache = settings.getCacheProvider().buildCache(name, properties);
			}
			catch (CacheException e) {
				throw new HibernateException( "Could not instantiate Cache", e );
			}
			strat.setCache(cache);
			strat.setMinimalPuts( settings.isMinimalPutsEnabled() );
		}
		
		caches.clear();
	}

	/**
	 * Get the query language imports
	 *
	 * @return a mapping from "import" names to fully qualified class names
	 */
	public Map getImports() {
		return imports;
	}

	/**
	 * Create an object-oriented view of the configuration properties
	 */
	protected Settings buildSettings() throws HibernateException {
		return SettingsFactory.buildSettings(properties);
	}

	public Map getNamedSQLQueries() {
		return namedSqlQueries;
	}

	/**
	 * @return the NamingStrategy.
	 */
	public NamingStrategy getNamingStrategy() {
		return namingStrategy;
	}

	/**
	 * Set a custom naming strategy
	 * 
	 * @param namingStrategy the NamingStrategy to set
	 */
	public void setNamingStrategy(NamingStrategy namingStrategy) {
		this.namingStrategy = namingStrategy;
	}

}