Hibernate example source code file (PersistenceXmlLoader.java)

This example Hibernate source code file (PersistenceXmlLoader.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Hibernate tags/keywords

arraylist, dom, element, element, errorlogger, exception, inputstream, inputstream, list, list, net, network, nodelist, parser, persistencemetadata, persistenceunittransactiontype, sax, string, string, util

The Hibernate PersistenceXmlLoader.java source code

/*
 * Hibernate, Relational Persistence for Idiomatic Java
 *
 * Copyright (c) 2010, Red Hat Inc. or third-party contributors as
 * indicated by the @author tags or express copyright attribution
 * statements applied by the authors.  All third-party contributions are
 * distributed under license by Red Hat Inc.
 *
 * This copyrighted material is made available to anyone wishing to use, modify,
 * copy, or redistribute it subject to the terms and conditions of the GNU
 * Lesser General Public License, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this distribution; if not, write to:
 * Free Software Foundation, Inc.
 * 51 Franklin Street, Fifth Floor
 * Boston, MA  02110-1301  USA
 */
package org.hibernate.ejb.packaging;

import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import javax.persistence.PersistenceException;
import javax.persistence.spi.PersistenceUnitTransactionType;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
import javax.xml.validation.Validator;
import org.hibernate.ejb.AvailableSettings;
import org.hibernate.ejb.internal.EntityManagerMessageLogger;
import org.hibernate.ejb.util.ConfigurationHelper;
import org.hibernate.internal.util.StringHelper;
import org.jboss.logging.Logger;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.EntityResolver;
import org.xml.sax.ErrorHandler;
import org.xml.sax.InputSource;
import org.xml.sax.SAXParseException;

/**
 * Handler for persistence.xml files.
 *
 * @author <a href="mailto:bill@jboss.org">Bill Burke
 * @author Emmanuel Bernard
 */
public final class PersistenceXmlLoader {

    private static final EntityManagerMessageLogger LOG = Logger.getMessageLogger(EntityManagerMessageLogger.class,
                                                                           PersistenceXmlLoader.class.getName());

	private PersistenceXmlLoader() {
	}

	private static Document loadURL(URL configURL, EntityResolver resolver) throws Exception {
		/*
		 * try and parse the document:
		 *  - try and validate the document with persistence_2_0.xsd
		  * - if it fails because of the version attribute mismatch, try and validate the document with persistence_1_0.xsd
		 */
		InputStream is = null;
		if (configURL != null) {
			URLConnection conn = configURL.openConnection();
			conn.setUseCaches( false ); //avoid JAR locking on Windows and Tomcat
			is = conn.getInputStream();
		}
		if ( is == null ) {
			throw new IOException( "Failed to obtain InputStream while reading persistence.xml file: " + configURL );
		}

		DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
		docBuilderFactory.setNamespaceAware( true );
		final Schema v2Schema = SchemaFactory.newInstance( javax.xml.XMLConstants.W3C_XML_SCHEMA_NS_URI )
				.newSchema( new StreamSource( getStreamFromClasspath( "persistence_2_0.xsd" ) ) );
		final Validator v2Validator = v2Schema.newValidator();
		final Schema v1Schema = SchemaFactory.newInstance( javax.xml.XMLConstants.W3C_XML_SCHEMA_NS_URI )
				.newSchema( new StreamSource( getStreamFromClasspath( "persistence_1_0.xsd" ) ) );
		final Validator v1Validator = v1Schema.newValidator();

		InputSource source = new InputSource( is );
		DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder();
		docBuilder.setEntityResolver( resolver );
		List<SAXParseException> errors = new ArrayList();
		Document doc = null;

		//first sparse document and collect syntaxic errors
		try {
			doc = docBuilder.parse( source );
		}
		catch ( SAXParseException e ) {
			errors.add( e );
		}

		if (errors.size() == 0) {
			v2Validator.setErrorHandler( new ErrorLogger( errors ) );
            LOG.trace("Validate with persistence_2_0.xsd schema on file " + configURL);
			v2Validator.validate( new DOMSource( doc ) );
			boolean isV1Schema = false;
			if ( errors.size() != 0 ) {
				//v2 fails, it could be because the file is v1.
                LOG.trace("Found error with persistence_2_0.xsd schema on file " + configURL);
				SAXParseException exception = errors.get( 0 );
				final String errorMessage = exception.getMessage();
				//is it a validation error due to a v1 schema validated by a v2
				isV1Schema = errorMessage.contains("1.0")
						&& errorMessage.contains("2.0")
						&& errorMessage.contains("version");

			}
			if (isV1Schema) {
                LOG.trace("Validate with persistence_1_0.xsd schema on file " + configURL);
				errors.clear();
				v1Validator.setErrorHandler( new ErrorLogger( errors ) );
				v1Validator.validate( new DOMSource( doc ) );
			}
		}
		if ( errors.size() != 0 ) {
			//report all errors in the exception
			StringBuilder errorMessage = new StringBuilder( );
			for (SAXParseException error : errors) {
				errorMessage.append("Error parsing XML (line")
							.append(error.getLineNumber())
							.append(" : column ")
							.append(error.getColumnNumber())
							.append("): ")
							.append(error.getMessage())
							.append("\n");
			}
			throw new PersistenceException( "Invalid persistence.xml.\n" + errorMessage.toString() );
		}
		return doc;
	}

	private static InputStream getStreamFromClasspath(String fileName) {
		String path = "org/hibernate/ejb/" + fileName;
		InputStream dtdStream = PersistenceXmlLoader.class.getClassLoader().getResourceAsStream( path );
		return dtdStream;
	}

	/**
     * Method used by JBoss AS 4.0.5 for parsing
     */
	public static List<PersistenceMetadata> deploy(URL url, Map overrides, EntityResolver resolver) throws Exception {
        return deploy(url, overrides, resolver, PersistenceUnitTransactionType.JTA);
    }

	/**
	 * Method used by JBoss EJB3 (4.2 and above) for parsing
	 * Object used by Hibernate OGM as well, consider this some kind of exposed service at the SPI level
	 */
    public static List<PersistenceMetadata> deploy(URL url, Map overrides, EntityResolver resolver,
												   PersistenceUnitTransactionType defaultTransactionType) throws Exception {
		Document doc = loadURL( url, resolver );
		Element top = doc.getDocumentElement();
		//version is mandatory
		final String version = top.getAttribute( "version" );

		NodeList children = top.getChildNodes();
		ArrayList<PersistenceMetadata> units = new ArrayList();
		for ( int i = 0; i < children.getLength() ; i++ ) {
			if ( children.item( i ).getNodeType() == Node.ELEMENT_NODE ) {
				Element element = (Element) children.item( i );
				String tag = element.getTagName();
				if ( tag.equals( "persistence-unit" ) ) {
					PersistenceMetadata metadata = parsePersistenceUnit( element );
					metadata.setVersion(version);
					//override properties of metadata if needed
					if ( overrides.containsKey( AvailableSettings.PROVIDER ) ) {
						String provider = (String) overrides.get( AvailableSettings.PROVIDER );
						metadata.setProvider( provider );
					}
					if ( overrides.containsKey( AvailableSettings.TRANSACTION_TYPE ) ) {
						String transactionType = (String) overrides.get( AvailableSettings.TRANSACTION_TYPE );
						metadata.setTransactionType( PersistenceXmlLoader.getTransactionType( transactionType ) );
					}
					if ( overrides.containsKey( AvailableSettings.JTA_DATASOURCE ) ) {
						String dataSource = (String) overrides.get( AvailableSettings.JTA_DATASOURCE );
						metadata.setJtaDatasource( dataSource );
					}
					if ( overrides.containsKey( AvailableSettings.NON_JTA_DATASOURCE ) ) {
						String dataSource = (String) overrides.get( AvailableSettings.NON_JTA_DATASOURCE );
						metadata.setNonJtaDatasource( dataSource );
					}
					/*
					 * if explicit => use it
					 * if JTA DS => JTA transaction
					 * if non JTA DA => RESOURCE_LOCAL transaction
					 * else default JavaSE => RESOURCE_LOCAL
					 */
					PersistenceUnitTransactionType transactionType = metadata.getTransactionType();
					Boolean isJTA = null;
					if ( StringHelper.isNotEmpty( metadata.getJtaDatasource() ) ) {
						isJTA = Boolean.TRUE;
					}
					else if ( StringHelper.isNotEmpty( metadata.getNonJtaDatasource() ) ) {
						isJTA = Boolean.FALSE;
					}
					if (transactionType == null) {
						if (isJTA == Boolean.TRUE) {
							transactionType = PersistenceUnitTransactionType.JTA;
						}
						else if (isJTA == Boolean.FALSE) {
							transactionType = PersistenceUnitTransactionType.RESOURCE_LOCAL;
						}
						else {
							transactionType = defaultTransactionType;
						}
					}
					metadata.setTransactionType( transactionType );
					Properties properties = metadata.getProps();
					ConfigurationHelper.overrideProperties( properties, overrides );
					units.add( metadata );
				}
			}
		}
		return units;
	}

	private static PersistenceMetadata parsePersistenceUnit(Element top)
			throws Exception {
		PersistenceMetadata metadata = new PersistenceMetadata();
		String puName = top.getAttribute( "name" );
		if ( StringHelper.isNotEmpty( puName ) ) {
            LOG.trace("Persistent Unit name from persistence.xml: " + puName);
			metadata.setName( puName );
		}
		NodeList children = top.getChildNodes();
		for ( int i = 0; i < children.getLength() ; i++ ) {
			if ( children.item( i ).getNodeType() == Node.ELEMENT_NODE ) {
				Element element = (Element) children.item( i );
				String tag = element.getTagName();
//				if ( tag.equals( "name" ) ) {
//					String puName = XmlHelper.getElementContent( element );
//					log.trace( "FOUND PU NAME: " + puName );
//					metadata.setName( puName );
//				}
//				else
				if ( tag.equals( "non-jta-data-source" ) ) {
					metadata.setNonJtaDatasource( XmlHelper.getElementContent( element ) );
				}
				else if ( tag.equals( "jta-data-source" ) ) {
					metadata.setJtaDatasource( XmlHelper.getElementContent( element ) );
				}
				else if ( tag.equals( "provider" ) ) {
					metadata.setProvider( XmlHelper.getElementContent( element ) );
				}
				else if ( tag.equals( "class" ) ) {
					metadata.getClasses().add( XmlHelper.getElementContent( element ) );
				}
				else if ( tag.equals( "mapping-file" ) ) {
					metadata.getMappingFiles().add( XmlHelper.getElementContent( element ) );
				}
				else if ( tag.equals( "jar-file" ) ) {
					metadata.getJarFiles().add( XmlHelper.getElementContent( element ) );
				}
				else if ( tag.equals( "exclude-unlisted-classes" ) ) {
					metadata.setExcludeUnlistedClasses( true );
				}
				else if ( tag.equals( "delimited-identifiers" ) ) {
					metadata.setUseQuotedIdentifiers( true );
				}
				else if ( tag.equals( "validation-mode" ) ) {
					metadata.setValidationMode( XmlHelper.getElementContent( element ) );
				}
				else if ( tag.equals( "shared-cache-mode" ) ) {
					metadata.setSharedCacheMode( XmlHelper.getElementContent( element ) );
				}
				else if ( tag.equals( "properties" ) ) {
					NodeList props = element.getChildNodes();
					for ( int j = 0; j < props.getLength() ; j++ ) {
						if ( props.item( j ).getNodeType() == Node.ELEMENT_NODE ) {
							Element propElement = (Element) props.item( j );
							if ( !"property".equals( propElement.getTagName() ) ) continue;
							String propName = propElement.getAttribute( "name" ).trim();
							String propValue = propElement.getAttribute( "value" ).trim();
							if ( StringHelper.isEmpty( propValue ) ) {
								//fall back to the natural (Hibernate) way of description
								propValue = XmlHelper.getElementContent( propElement, "" );
							}
							metadata.getProps().put( propName, propValue );
						}
					}

				}
			}
		}
		PersistenceUnitTransactionType transactionType = getTransactionType( top.getAttribute( "transaction-type" ) );
		if (transactionType != null) metadata.setTransactionType( transactionType );

		return metadata;
	}

	public static PersistenceUnitTransactionType getTransactionType(String elementContent) {
		if ( StringHelper.isEmpty( elementContent ) ) {
			return null; //PersistenceUnitTransactionType.JTA;
		}
		else if ( elementContent.equalsIgnoreCase( "JTA" ) ) {
			return PersistenceUnitTransactionType.JTA;
		}
		else if ( elementContent.equalsIgnoreCase( "RESOURCE_LOCAL" ) ) {
			return PersistenceUnitTransactionType.RESOURCE_LOCAL;
		}
		else {
			throw new PersistenceException( "Unknown TransactionType: " + elementContent );
		}
	}

	public static class ErrorLogger implements ErrorHandler {
		private List<SAXParseException> errors;

		ErrorLogger(List<SAXParseException> errors) {
			this.errors = errors;
		}

		public void error(SAXParseException error) {
			//what was this commented code about?
//			if ( resolver instanceof EJB3DTDEntityResolver ) {
//				if ( ( (EJB3DTDEntityResolver) resolver ).isResolved() == false ) return;
//			}
			errors.add( error );
		}

		public void fatalError(SAXParseException error) {
			errors.add( error );
		}

		public void warning(SAXParseException warn) {
		}
	}

}