|
Hibernate example source code file (HibernateMappingProcessor.java)
This example Hibernate source code file (HibernateMappingProcessor.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.
The Hibernate HibernateMappingProcessor.java source code
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* Copyright (c) 2011, 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.metamodel.source.hbm;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.hibernate.engine.spi.FilterDefinition;
import org.hibernate.internal.util.StringHelper;
import org.hibernate.internal.util.Value;
import org.hibernate.metamodel.binding.FetchProfile;
import org.hibernate.metamodel.binding.TypeDef;
import org.hibernate.metamodel.relational.AuxiliaryDatabaseObject;
import org.hibernate.metamodel.relational.BasicAuxiliaryDatabaseObjectImpl;
import org.hibernate.metamodel.source.MappingException;
import org.hibernate.metamodel.source.MetadataImplementor;
import org.hibernate.metamodel.source.Origin;
import org.hibernate.metamodel.source.hbm.jaxb.mapping.XMLFetchProfileElement;
import org.hibernate.metamodel.source.hbm.jaxb.mapping.XMLHibernateMapping;
import org.hibernate.metamodel.source.hbm.jaxb.mapping.XMLParamElement;
import org.hibernate.metamodel.source.hbm.jaxb.mapping.XMLQueryElement;
import org.hibernate.metamodel.source.hbm.jaxb.mapping.XMLSqlQueryElement;
import org.hibernate.service.classloading.spi.ClassLoaderService;
import org.hibernate.service.classloading.spi.ClassLoadingException;
import org.hibernate.type.Type;
/**
* Responsible for processing a {@code <hibernate-mapping/>} element. Allows processing to be coordinated across
* all hbm files in an ordered fashion. The order is essentially the same as defined in
* {@link org.hibernate.metamodel.source.MetadataSourceProcessor}
*
* @author Steve Ebersole
*/
public class HibernateMappingProcessor {
private final MetadataImplementor metadata;
private final MappingDocument mappingDocument;
private Value<ClassLoaderService> classLoaderService = new Value(
new Value.DeferredInitializer<ClassLoaderService>() {
@Override
public ClassLoaderService initialize() {
return metadata.getServiceRegistry().getService( ClassLoaderService.class );
}
}
);
public HibernateMappingProcessor(MetadataImplementor metadata, MappingDocument mappingDocument) {
this.metadata = metadata;
this.mappingDocument = mappingDocument;
}
private XMLHibernateMapping mappingRoot() {
return mappingDocument.getMappingRoot();
}
private Origin origin() {
return mappingDocument.getOrigin();
}
private HbmBindingContext bindingContext() {
return mappingDocument.getMappingLocalBindingContext();
}
private <T> Class classForName(String name) {
return classLoaderService.getValue().classForName( bindingContext().qualifyClassName( name ) );
}
public void processIndependentMetadata() {
processDatabaseObjectDefinitions();
processTypeDefinitions();
}
private void processDatabaseObjectDefinitions() {
if ( mappingRoot().getDatabaseObject() == null ) {
return;
}
for ( XMLHibernateMapping.XMLDatabaseObject databaseObjectElement : mappingRoot().getDatabaseObject() ) {
final AuxiliaryDatabaseObject auxiliaryDatabaseObject;
if ( databaseObjectElement.getDefinition() != null ) {
final String className = databaseObjectElement.getDefinition().getClazz();
try {
auxiliaryDatabaseObject = (AuxiliaryDatabaseObject) classForName( className ).newInstance();
}
catch (ClassLoadingException e) {
throw e;
}
catch (Exception e) {
throw new MappingException(
"could not instantiate custom database object class [" + className + "]",
origin()
);
}
}
else {
Set<String> dialectScopes = new HashSet();
if ( databaseObjectElement.getDialectScope() != null ) {
for ( XMLHibernateMapping.XMLDatabaseObject.XMLDialectScope dialectScope : databaseObjectElement.getDialectScope() ) {
dialectScopes.add( dialectScope.getName() );
}
}
auxiliaryDatabaseObject = new BasicAuxiliaryDatabaseObjectImpl(
metadata.getDatabase().getDefaultSchema(),
databaseObjectElement.getCreate(),
databaseObjectElement.getDrop(),
dialectScopes
);
}
metadata.getDatabase().addAuxiliaryDatabaseObject( auxiliaryDatabaseObject );
}
}
private void processTypeDefinitions() {
if ( mappingRoot().getTypedef() == null ) {
return;
}
for ( XMLHibernateMapping.XMLTypedef typedef : mappingRoot().getTypedef() ) {
final Map<String, String> parameters = new HashMap();
for ( XMLParamElement paramElement : typedef.getParam() ) {
parameters.put( paramElement.getName(), paramElement.getValue() );
}
metadata.addTypeDefinition(
new TypeDef(
typedef.getName(),
typedef.getClazz(),
parameters
)
);
}
}
public void processTypeDependentMetadata() {
processFilterDefinitions();
processIdentifierGenerators();
}
private void processFilterDefinitions() {
if ( mappingRoot().getFilterDef() == null ) {
return;
}
for ( XMLHibernateMapping.XMLFilterDef filterDefinition : mappingRoot().getFilterDef() ) {
final String name = filterDefinition.getName();
final Map<String,Type> parameters = new HashMap();
String condition = null;
for ( Object o : filterDefinition.getContent() ) {
if ( o instanceof String ) {
// represents the condition
if ( condition != null ) {
// log?
}
condition = (String) o;
}
else if ( o instanceof XMLHibernateMapping.XMLFilterDef.XMLFilterParam ) {
final XMLHibernateMapping.XMLFilterDef.XMLFilterParam paramElement = (XMLHibernateMapping.XMLFilterDef.XMLFilterParam) o;
// todo : should really delay this resolution until later to allow typedef names
parameters.put(
paramElement.getName(),
metadata.getTypeResolver().heuristicType( paramElement.getType() )
);
}
else {
throw new MappingException( "Unrecognized nested filter content", origin() );
}
}
if ( condition == null ) {
condition = filterDefinition.getCondition();
}
metadata.addFilterDefinition( new FilterDefinition( name, condition, parameters ) );
}
}
private void processIdentifierGenerators() {
if ( mappingRoot().getIdentifierGenerator() == null ) {
return;
}
for ( XMLHibernateMapping.XMLIdentifierGenerator identifierGeneratorElement : mappingRoot().getIdentifierGenerator() ) {
metadata.registerIdentifierGenerator(
identifierGeneratorElement.getName(),
identifierGeneratorElement.getClazz()
);
}
}
public void processMappingDependentMetadata() {
processFetchProfiles();
processImports();
processResultSetMappings();
processNamedQueries();
}
private void processFetchProfiles(){
if ( mappingRoot().getFetchProfile() == null ) {
return;
}
processFetchProfiles( mappingRoot().getFetchProfile(), null );
}
public void processFetchProfiles(List<XMLFetchProfileElement> fetchProfiles, String containingEntityName) {
for ( XMLFetchProfileElement fetchProfile : fetchProfiles ) {
String profileName = fetchProfile.getName();
Set<FetchProfile.Fetch> fetches = new HashSet();
for ( XMLFetchProfileElement.XMLFetch fetch : fetchProfile.getFetch() ) {
String entityName = fetch.getEntity() == null ? containingEntityName : fetch.getEntity();
if ( entityName == null ) {
throw new MappingException(
"could not determine entity for fetch-profile fetch [" + profileName + "]:[" +
fetch.getAssociation() + "]",
origin()
);
}
fetches.add( new FetchProfile.Fetch( entityName, fetch.getAssociation(), fetch.getStyle() ) );
}
metadata.addFetchProfile( new FetchProfile( profileName, fetches ) );
}
}
private void processImports() {
if ( mappingRoot().getImport() == null ) {
return;
}
for ( XMLHibernateMapping.XMLImport importValue : mappingRoot().getImport() ) {
String className = mappingDocument.getMappingLocalBindingContext().qualifyClassName( importValue.getClazz() );
String rename = importValue.getRename();
rename = ( rename == null ) ? StringHelper.unqualify( className ) : rename;
metadata.addImport( className, rename );
}
}
private void processResultSetMappings() {
if ( mappingRoot().getResultset() == null ) {
return;
}
// bindResultSetMappingDefinitions( element, null, mappings );
}
private void processNamedQueries() {
if ( mappingRoot().getQueryOrSqlQuery() == null ) {
return;
}
for ( Object queryOrSqlQuery : mappingRoot().getQueryOrSqlQuery() ) {
if ( XMLQueryElement.class.isInstance( queryOrSqlQuery ) ) {
// bindNamedQuery( element, null, mappings );
}
else if ( XMLSqlQueryElement.class.isInstance( queryOrSqlQuery ) ) {
// bindNamedSQLQuery( element, null, mappings );
}
else {
throw new MappingException(
"unknown type of query: " +
queryOrSqlQuery.getClass().getName(), origin()
);
}
}
}
}
Other Hibernate examples (source code examples)
Here is a short list of links related to this Hibernate HibernateMappingProcessor.java source code file:
|