绿色记忆 » Hibernate

Spring配置：集成Hibernate、JacksonJSON、AspectJ等框架

Alex — Mon, 26 Nov 2012 08:39:24 +0000

本文提及的该套配置文件，覆盖了JavaEE项目开发的最常见需求，包括：依赖注入、事务控制、AOP、任务调度、缓存、MVC框架等方面的内容。
容易改变的配置项独立到属性文件中：

hibernateDialect=org.hibernate.dialect.MySQL5Dialect
#启用了log4jdbc支持
jdbcDriver=net.sf.log4jdbc.DriverSpy
jdbcDriverUrl=jdbc:log4jdbc:mysql://192.168.0.201:3306/initpemsdb1.1.1
jdbcUserName=root
jdbcPassword=root

Spring配置文件部分：



    
    
    
    
        
        
        
        
        
        
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
        
    
    
    
    
      
    
    
        
        
        
        
        
        
        
        
        
        
    
    
    
    
        
            
                cc.gmem.demo.**.domain
            
        
        
            
                hibernate.dialect=#{appCfg.hibernateDialect}
                hibernate.jdbc.batch_size=30
                hibernate.show_sql=false
                hibernate.format_sql=true
                hibernate.generate_statistics=true
                hibernate.transaction.factory_class=org.hibernate.transaction.JDBCTransactionFactory
                hibernate.current_session_context_class=org.springframework.orm.hibernate3.SpringSessionContext
                hibernate.query.factory_class=org.hibernate.hql.ast.ASTQueryTranslatorFactory
                hibernate.hbm2ddl.auto=update
                #启用二级缓存
                hibernate.cache.use_second_level_cache=true
                hibernate.cache.use_query_cache=true
                hibernate.cache.region.factory_class=org.hibernate.cache.SingletonEhCacheRegionFactory
            
        
    
    
    
        
    
    
        
            classpath:ehcache.xml
        
        
    
    
    
    
    
        
            
                
            
        
    
    
    
         
             
                 classpath:message.gmemdemo
             
         
         
         
    
    
    
    
    
        
            
                
                    
                        
                            yyyy-MM-dd
                            yyyy-MM-dd HH:mm:ss
                            yyyy-MM-dd HH:mm:ss.SSS
                       
                    
                
            
       
       
           
               
                   
                       yyyy-MM-dd

Spring MVC配置文件部分：

ehcache配置部分：

Web.xml配置（使用了Spring的JavaConfig）：



    
        contextClass
        org.springframework.web.context.support.AnnotationConfigWebApplicationContext
    
    
        contextConfigLocation
        cc.gmem.demo.spring.SpringBeanDefinitionRegistrar
    
    
        org.springframework.web.context.ContextLoaderListener
    
    
        springmvc
        org.springframework.web.servlet.DispatcherServlet
        
            contextClass
            org.springframework.web.context.support.AnnotationConfigWebApplicationContext
        
        
            contextConfigLocation
            cc.gmem.demo.spring.SpringMVCBeanDefinitionRegistrar
        
    
    
        springmvc
        /
    

    
        adminServlet
        /proxool
    

    
        60
    

    
        404
        /WEB-INF/jsp/error-404.jsp
    
    
        401
        /WEB-INF/jsp/error-401.jsp
    
    
        500
        /WEB-INF/jsp/error-500.jsp
    
     
        index.jsp

Java Config类：

@Configuration
/* XML-based bean definitions */
@ImportResource ( "classpath:applicationContext.xml" )
public class SpringBeanDefinitionRegistrar
{

    /* Auto injected spring context */
    @SuppressWarnings ( "unused" )
    @Inject
    private ApplicationContext applicationContext;

    /* Programmatic bean definition */
    @Bean ( name = "helper" )
    public Helper helper()
    {
        Helper helper = new Helper();
        return helper;
    }

}

@Configuration
@ImportResource ( "classpath:spring-mvc.xml" )
public class SpringMVCBeanDefinitionRegistrar
{

}

Maven依赖包列表：


    UTF-8
    3.1.2.RELEASE
    3.6.10.Mod
    1.6.11
    2.0.4


    
        org.springframework
        spring-core
        ${spring.version}
    
    
        org.springframework
        spring-jdbc
        ${spring.version}
    
    
        org.springframework
        spring-beans
        ${spring.version}
    
    
        org.springframework
        spring-webmvc
        ${spring.version}
    

    
        org.springframework
        spring-orm
        ${spring.version}
    
    
        org.springframework
        spring-test
        ${spring.version}
    

    
        org.hibernate
        hibernate-core
        ${hibernate.version}
    

    
        org.aspectj
        aspectjweaver
        ${aspectj.version}
    
    
        org.aspectj
        aspectjrt
        ${aspectj.version}
    

    
        com.fasterxml.jackson.core
        jackson-core
        ${jackson.version}
    
    
        com.fasterxml.jackson.core
        jackson-databind
        ${jackson.version}
    
    
        com.fasterxml.jackson.core
        jackson-annotations
        ${jackson.version}
    

    
        javax.servlet
        servlet-api
        2.4
        provided
    
    
        javax.servlet.jsp
        jsp-api
        2.0
        provided
    
    
        javax.servlet
        jstl
        1.2
    
    
        taglibs
        standard
        1.1.2
        provided
    
    
        javax.el
        el-api
        2.2
        provided
    

    
        proxool
        proxool
        0.9.1
    

    
        org.javassist
        javassist
        3.15.0-GA
    

    
        net.sf.log4jdbc
        log4jdbc3
        1.2-ext-3
    
    
        com.sqlinform
        sqlinform
        0.0.1
    

    
        javax.annotation
        jsr250-api
        1.0
    
    
        javax.inject
        javax.inject
        1
    

    
        joda-time
        joda-time
        2.1
    

    
        cglib
        cglib
        2.2.2
    

    
        org.apache.poi
        poi
        3.9
    
    
    
        opensymphony
        quartz-all
        1.6.3

Maven插件配置（支持AspectJ）：


    org.codehaus.mojo
    aspectj-maven-plugin
    1.4
    
        
            compile
            
                true
                true
                true
                1.5
                1.5
                UTF-8
                true
                true
                
                    
                        org.springframework
                        spring-aspects
                    
                
            
            
                compile

The post Spring配置：集成Hibernate、JacksonJSON、AspectJ等框架 appeared first on 绿色记忆.

基于JavaConfig方式的Spring+Hibernate集成

Alex — Mon, 05 Nov 2012 05:47:36 +0000

JavaConfig类

包含Spring、Hibernate、事务管理等功能的样例

package sparknet.wnet.saic.intf.spring;

import java.io.IOException;
import java.util.Properties;

import javax.inject.Inject;
import javax.sql.DataSource;

import net.greenmemory.breeze.persist.OracleProxoolDataSource;
import net.greenmemory.commons.db.QueryRunner;
import net.greenmemory.commons.lang.NumberUtils;
import net.greenmemory.spring.core.io.ClassPathResource;

import org.hibernate.SessionFactory;
import org.springframework.aop.framework.autoproxy.InfrastructureAdvisorAutoProxyCreator;
import org.springframework.beans.factory.BeanInitializationException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.context.annotation.FilterType;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.orm.hibernate3.HibernateTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.AnnotationTransactionAttributeSource;
import org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor;
import org.springframework.transaction.interceptor.TransactionInterceptor;

import cc.gmem.tools.hibernatetools.spring.Hibernate3LocalSessionFactoryBean;

@Configuration
@ComponentScan (
        basePackages = { "cc.gmem.saic", "cc.gmem.intf" },
        excludeFilters = { @Filter ( type = FilterType.ANNOTATION, value = Configuration.class ) } )
@EnableAspectJAutoProxy
public class BeanDefinitionRegistrar
{

    @Inject
    private ApplicationContext applicationContext;

    @Bean ( name = "cfg" )
    public Properties getAppConfig()
    {
        Properties props = new Properties();
        try
        {
            props.load( new ClassPathResource( "wsi.properties" ).getInputStream() );
        }
        catch ( IOException e )
        {
            throw new BeanInitializationException( e.getMessage(), e );
        }
        return props;
    }

    @Bean ( name = "dataSource" )
    public DataSource getDataSource()
    {
        OracleProxoolDataSource dataSource = new OracleProxoolDataSource();
        dataSource.setAlias( getAppConfig().getProperty( "jdbc.alias" ) );
        dataSource.setDriver( getAppConfig().getProperty( "jdbc.driverClass" ) );
        dataSource.setDriverUrl( getAppConfig().getProperty( "jdbc.url" ) );
        dataSource.setUser( getAppConfig().getProperty( "jdbc.user" ) );
        dataSource.setPassword( getAppConfig().getProperty( "jdbc.password" ) );
        dataSource.setMinimumConnectionCount( NumberUtils.toInt( getAppConfig().getProperty( "jdbc.minimumConnectionCount" ), 10 ) );
        dataSource.setMaximumConnectionCount( NumberUtils.toInt( getAppConfig().getProperty( "jdbc.maximumConnectionCount" ), 100 ) );
        dataSource.setSimultaneousBuildThrottle( NumberUtils.toInt( getAppConfig().getProperty( "jdbc.simultaneousBuildThrottle" ), 50 ) );
        dataSource.setMaximumActiveTime( NumberUtils.toInt( getAppConfig().getProperty( "jdbc.maximumActiveTime" ), 1200000 ) );
        dataSource.setEncrypted( false );
        dataSource.init();
        return dataSource;
    }

    @Bean ( name = "sessionFactory" )
    public SessionFactory getSessionFactory() throws Exception
    {
        Hibernate3LocalSessionFactoryBean bean = new Hibernate3LocalSessionFactoryBean();
        bean.setApplicationContext( applicationContext );
        bean.setDataSource( getDataSource() );
        bean.setMappingResources( new String[] { "wnetJhInterface.hbm.xml" } );
        bean.setAutoRegister( true );
        Properties hibernateProperties = new Properties();
        hibernateProperties.setProperty( "hibernate.dialect", "org.hibernate.dialect.Oracle10gDialect" );
        hibernateProperties.setProperty( "hibernate.jdbc.batch_size", "100" );
        hibernateProperties.setProperty( "hibernate.default_entity_mode", "dom4j" );
        hibernateProperties.setProperty( "hibernate.transaction.factory_class", "org.hibernate.transaction.JDBCTransactionFactory" );
        hibernateProperties.setProperty( "hibernate.current_session_context_class", "org.springframework.orm.hibernate3.SpringSessionContext" );
        bean.setHibernateProperties( hibernateProperties );
        bean.afterPropertiesSet();
        return bean.getObject();
    }

    @Bean ( name = "txManager" )
    public PlatformTransactionManager getTransactionManager() throws Exception
    {
        HibernateTransactionManager txMgr = new HibernateTransactionManager();
        txMgr.setSessionFactory( getSessionFactory() );
        return txMgr;
    }

    @Bean ( name = "jdbcTemplate" )
    public JdbcTemplate getJdbcTemplate()
    {
        return new JdbcTemplate( getDataSource() );
    }

    @Bean ( name = "queryRunner" )
    public QueryRunner getQueryRunner()
    {
        return new QueryRunner( getDataSource() );
    }

    @Bean
    public AnnotationTransactionAttributeSource transactionAttributeSource()
    {
        return new AnnotationTransactionAttributeSource();
    }

    @Bean
    public TransactionInterceptor transactionInterceptor() throws Exception
    {
        return new TransactionInterceptor( getTransactionManager(), transactionAttributeSource() );
    }

    @Bean
    public TransactionAttributeSourceAdvisor internalTransactionAdvisor() throws Exception
    {
        return new TransactionAttributeSourceAdvisor( transactionInterceptor() );
    }

    @Bean
    public InfrastructureAdvisorAutoProxyCreator internalAutoProxyCreator()
    {
        return new InfrastructureAdvisorAutoProxyCreator();
    }
}

初始化Spring ApplicationContext的代码

ApplicationContext ctx = new AnnotationConfigApplicationContext(BeanDefinitionRegistrar.class);
DataSource ds= ctx.getBean(DataSource.class);

The post 基于JavaConfig方式的Spring+Hibernate集成 appeared first on 绿色记忆.

Hibernate知识集锦

Alex — Wed, 11 Apr 2012 04:28:04 +0000

重要概念

get和load

在Hibernate 3.6.x中：

get会返回实际的对象实例，如果不存在则返回null，session.get(Superclass.class,id)与session.get(Concreteclass,id)的返回值完全一致。

load则返回一个生成的代理（类名以类似_$$_javassist_*结尾），即使给定ID的对象不存在也可以得到代理实例，只有第一次访问其非ID属性时才会从数据库寻找实例，找不到抛出异常。代理的父类就是session.load(Class.class,id)中指定的类，如果在多态映射时不指定具体类型，则不能cast为实际类型。

指定ManyToOne关的FetchType为Lazy时，可能导致关联实体使用类似于load的方式加载（调用SessionImplementor.internalLoad方法），除非指定为其指定注解：@NotFound ( action = NotFoundAction.IGNORE )，相关的Hibernate代码：

protected final Object resolveIdentifier(Serializable id, SessionImplementor session) throws HibernateException {
	boolean isProxyUnwrapEnabled = unwrapProxy &&
			session.getFactory()
					.getEntityPersister( getAssociatedEntityName() )
					.isInstrumented( session.getEntityMode() );
        //EntityType是ManyToOneType的父类，后者的isNullable() == ignoreNotFound，对应@NotFound注解
	Object proxyOrEntity = session.internalLoad(
			getAssociatedEntityName(),
			id,
			eager,
			isNullable() && !isProxyUnwrapEnabled
	);

	if ( proxyOrEntity instanceof HibernateProxy ) {
		( ( HibernateProxy ) proxyOrEntity ).getHibernateLazyInitializer()
				.setUnwrap( isProxyUnwrapEnabled );
	}

	return proxyOrEntity;
}

public Object internalLoad(String entityName, Serializable id, boolean eager, boolean nullable) throws HibernateException {
		// todo : remove
		LoadEventListener.LoadType type = nullable
                                //如果设置NotFoundAction.IGNORE，则走该分支，不创建代理
				? LoadEventListener.INTERNAL_LOAD_NULLABLE
				: eager
						? LoadEventListener.INTERNAL_LOAD_EAGER //不创建代理
						: LoadEventListener.INTERNAL_LOAD_LAZY; //只有这个会进行代理的创建
		LoadEvent event = new LoadEvent(id, entityName, true, this);
		fireLoad(event, type);
		if ( !nullable ) {
			UnresolvableObjectException.throwIfNull( event.getResult(), id, entityName );
		}
		return event.getResult();
	}

因此使用多态的ManyToOne时，要确保关联对象的类型准确，要么禁止延迟加载，要么启用延迟加载的同时打开 NotFoundAction.IGNORE

实体的状态

状态	说明
New (Transient)	新创建的对象，并且从来没有和Hibernate会话（持久化上下文，persistence context）关联过，没有和数据库表的一行关联要将瞬时对象变为持久化对象，你需要明确的调用持久化API，例如persist
Persistent (Managed)	已经关联到数据库表的一行，并且被当前Hibernate管理。对这类对象的任何修改都被自动检测到，并自动在flush期间入库
Detached	如果当前Hibernate会话关闭，则先前Persistent对象变为Detached，之后对实体的更新不会被跟踪因而不会自动入库要把Detached对象重新关联到Hibernate会话，你可以： Reattaching，通过session.update()方法。注意：在一个会话中，对于每个数据库行，只能有一个JVM对象与之关联 Merging，拷贝Detached对象的字段到一个Managed对象中，如果当前会话中对应Persistent尚不存在则从数据库中抓取。在此操作后，Detached对象的持久化状态不变对于配置了自动生成ID的实体类型，如果手工赋予了ID，会被看作是Detached，即使它是new出来的没有入库过的对象。对这种对象调用session.persist()会导致错误：detached entity passed to persist
Removed	实体对象被从数据库中删除，实际删除动作在flush时发生 JPA要求仅仅Managed对象才可以被删除，但是Hibernate允许调用session.delete删除Detached对象

实体状态转换示意图：

持久化API

本节以如下实体来描述常用持久化API的行为：

@Entity
public class Person {
    @Id
    @GeneratedValue
    private Long id;

    private String name;
 
}

注意下表中的API都不会立即导致SQL操作，SQL操作仅仅在flush时执行。

session.	说明
persist	用于将瞬时（new）对象转换为受管状态，例如： Person person = new Person(); person.setName("Alex"); session.persist(person); 注意该方法的返回值为void，它是直接把入参对象纳入受管状态，而非进行对象状态的拷贝。它的语义严格遵守JSR-220规范：导致瞬时对象变为受管状态，并且对cascade=PERSIST\|ALL的关联对象级联此操作如果对象已经处于受管状态，调用此API无效果，但是级联操作仍然被执行如果对象处于Detached状态，在此API调用后或者提交/flush时抛出异常不保证id立即生成 —— 调用此方法后id可以为null，无论id的生成策略。规范允许在提交/flush时生成id
save	该方法是Hibernate原始的持久化接口，不遵守JPA规范。其行为类似于persist但是实现细节不同该方法执行后，立即返回为瞬时对象分配的id 如果对Detached对象执行调用save()，会生成一个新的id
update	该方法是Hibernate原始的持久化接口：在入参对象上进行操作，返回值是void。将入参对象从detached转换为persistent 如果你传入transient对象，抛出异常
merge	逻辑如下：根据id从数据库中加载实体从入参对象拷贝字段到加载的实体返回加载的实体，该对象与入参是两个对象 JSR-220的语义被遵守：如果实体是detached，则拷贝字段到加载的受管实体上如果实体是transient，则拷贝字段到新建的受管实体上级联关联的cascade=MERGE\|ALL对象如果实体目前已经是受管的，不拷贝字段，但是级联操作仍然进行
saveOrUpdate	Hibernate的特殊API，JPA中没有对应的接口行为类似于update，可以被用来reattaching一个实例，不管它是transient还是detached

常见问题

Hibernate3使用XRM（EntityMode=dom4j），修改query.list()的dom元素后报错

报错信息：
org.springframework.orm.hibernate3.HibernateSystemException: identifier of an instance of *** was altered from 248178 to null; nested exception is org.hibernate.HibernateException: identifier of an instance of wnetJhInterface was altered from 248178 to null
at org.springframework.orm.hibernate3.SessionFactoryUtils.convertHibernateAccessException(SessionFactoryUtils.java:690)
解决：查询完成后，调用sess.clear();

Hibernate HQL is null问题

HQL应该写成：prop is null。不能用参数： prop is :p 并把值传进去

Hibernate setParameter()报错

报错信息：Position beyond number of declared ordinal parameters. Remember that ordinal parameters are 1-based! Position: 2
报错原因：位置参数第一个设置为0，和JDBC不一样，JDBC的索引以1开始

Hibernate setParameter()传递对象给位置参数?报错

报错信息：Expected positional parameter count: ?, actual parameters ...
报错原因：未知，可以使用命名参数（named parameters）解决

如何为HQL命名参数传递多个值(IN子句)

String hql = "update user where id in (:id)";
sess = getSessionFactory().getCurrentSession();
Session msess = sess.getSession( EntityMode.MAP );
Query q = msess.createQuery( hql.toString() );
List params = new ArrayList();
for ( Map d : dataSet.getAllData() )
{
    params.add( d.get( "id") );
}
q.setParameterList( "id", params );

Hibernate序列化对象时出错

报错信息：org.hibernate.type.SerializationException: could not serialize

报错原因：某些时候Hibernate需要使用Java串行化机制来序列化对象，因此，必须在注解@Transient的同时，为字段添加transient关键字，这样Java串行化机制才能忽略该字段。

@Inject
@Transient
@JsonIgnore
private  transient ServiceHelper     service;

HQL报错：org.hibernate.QueryException: could not resolve property

非实体属性不能存在于HQL的SELECT或者WHERE子句中
对于任意多态映射（@Any），即使关联的所有类型的实体均有属性A（通过@MappedSuperclass指定），A亦不能出现在SELECT或者WHERE子句中

@AnyMetaDef的@MetaValue的targetEntity不精确到具体子类时，无法保存元数据列的问题

在Hibernate 3.6.x中，使用任意多态映射时，如果其中某个关联目标是一个实体类层次，例如：

@AnyMetaDef (
    name = "adminMetaDef",
    idType = "integer",
    metaType = "integer",
    metaValues = {
        @MetaValue ( value = "1", targetEntity = Child.class ),
        //如果Org是一个抽象实体类，其下面有若干个具体实体子类，则在该配置下，任何子实体均无法关联上
        @MetaValue ( value = "2", targetEntity = Org.class )
    } 
)
@Any ( metaDef = "adminMetaDef", metaColumn = @Column ( name = "ADMIN_TYPE") )
@JoinColumn ( name = "ADMIN_ID" )
private Admin mainAdmin;

则必须把所有子类的@MetaValue全部定义出来，否则在入库时元数据列ADMIN_TYPE保存为null，导致后续无法读取出mainAdmin属性。下面的补丁解决此问题：

public void nullSafeSet( PreparedStatement st, Object value, int index, SessionImplementor session )
        throws HibernateException, SQLException
{
    baseType.nullSafeSet( st, value == null ? null : getKey( value ), index, session );
}
private Object getSuperclass( Object clsName )
{
    try
    {
        Class c = Class.forName( clsName.toString() );
        return c.getSuperclass().getName();
    }
    catch ( Exception e )
    {
        return null;
    }
}

private Object getKey( Object clsName )
{
    Object key = this.keys.get( clsName );
    if ( key == null )
    {
        return getKey( getSuperclass( clsName ) );
    }
    return key;
}

应用上述补丁之后，加载对象后，发现mainAdmin属性的类型与其真实类型不对应，其类型是@metaValue中声明的Org类，下面的补丁解决此问题：

//修改此文件的130、210、216行，改为调用下面的方法：

private Object internalLoad( String entityName, Serializable id, SessionImplementor session )
{
    //这边第三个参数改为true，即禁止了延迟加载，避免了代理对象类型不正确的问题
    return session.internalLoad( entityName, id, true, false );
}
//上面的方法返回的对象不是代理，和原代码语义可能存在不一致（本人未验证）

配置示例

Spring配置：Hibernate4


        
            
                cc.gmem.mgr.*.model
            
        
        
            
                hibernate.dialect=org.hibernate.dialect.Oracle10gDialect
                hibernate.jdbc.batch_size=20
                hibernate.show_sql=false
                hibernate.format_sql=false
                hibernate.generate_statistics=true
                hibernate.transaction.factory_class=org.hibernate.transaction.JDBCTransactionFactory
                hibernate.current_session_context_class=org.springframework.orm.hibernate4.SpringSessionContext

The post Hibernate知识集锦 appeared first on 绿色记忆.

Hibernate基于注解的配置样例

Alex — Fri, 24 Dec 2010 03:35:43 +0000

实体类上的常用注解

@Entity ( name = "ChristmasTree" )
@Table ( name = "T_CRISMS_TREE" )
//给自动生成的表添加注释
@org.hibernate.annotations.Table ( appliesTo = "T_CRISMS_TREE", comment = "圣诞树" )
@Cacheable  //JPA注解，表示该类型的实体支持缓存
//启用二级缓存时有意义，指定Hibernate缓存策略、存放区域
@Cache ( usage = CacheConcurrencyStrategy.READ_WRITE, region = "entityCache" )
public class ChristmasTree
{
    //集合属性的缓存策略必须单独配置
    @Cache ( usage = CacheConcurrencyStrategy.READ_WRITE, region = "entityCache" )
    private List branches;
}

使用注解方式进行对象-数据库映射时，应当以JPA注解为主，仅Hibernate特有的功能则使用其私有的注解类。

简单主键和简单属性映射

//简单的主键映射
@Id  //该注解指明此实体的标识符属性，对应了关系型数据库的主键
@Column ( name = "ID", columnDefinition = "int(11) comment '主键'" )
private Integer id;

//UUID方式的主键生成器配置，其它任何自定义的主键生成器可以依样扩展
@Id
@Column ( name = "ID", columnDefinition = "varchar(36) comment '主键,36位UUID'" )
@GeneratedValue ( generator = "uuid" )
@GenericGenerator ( name = "uuid", strategy = "org.hibernate.id.UUIDGenerator" )
private String            id;

//可以指定普通属性的延迟加载
@Basic ( fetch = FetchType.EAGER, optional = true )
@Column ( name = "BUILD_COST", columnDefinition = "decimal(10,2) comment '建造费用'" )
private BigDecimal buildCost;

//时间映射
//只能用于java.util.Date或者java.util.Calendar，用于表示日期、时间或者时间戳
@Temporal ( TemporalType.TIMESTAMP )
@Column ( name = "BUILD_TIME", columnDefinition = "datetime comment '建造时间'" )
private Date buildTime;

//大字段映射
@Lob
@Column ( name = "REMARK", columnDefinition = "longtext comment '圣诞树备注信息'" )
private String remark;

//枚举类型映射
@Enumerated ( EnumType.ORDINAL )
//根据枚举元素的声明顺序，从0开始
@Column ( name = "STATUS", columnDefinition = "tinyint comment '状态'" )
private Status status;


//乐观并发控制用列
@Version
@Column ( name = "VERSION" )
public Integer version;

复合主键映射

//复合主键映射
@Embeddable
public class TreeId 
{
    @Column ( name = "ORG_ID" )
    private Integer org;
    @Column ( name = "SEQ_ID" )
    private Integer seq;
}
//可以覆写默认映射
@EmbeddedId
@AttributeOverride ( name = "seq", column = @Column (name = "SEQ_NO" ) )
private TreeId treeId;
//复合主键中甚至可以包含实体类
@Embeddable
public class TreeId
{
    @ManyToOne
    @JoinColumn  (name = "ORG_ID", referencedColumnName="ID" )
    private Org org;
    @Column ( name = "SEQ_ID" )
    private Integer seq;
}
//也可以使用多个属性作为主键
public class ChristmasTree
{
    @Id
    @OneToOne
    @JoinColumn (name = "ORG_ID", referencedColumnName="ID" )
    private Org org;

    @Id
    @Column ( name = "SEQ_ID" )
    private Integer seq;
}

嵌入式（embeddable）对象映射

//嵌入式对象映射，也叫组件映射
@Embeddable
public class Country 
{
    @ManyToOne
    @JoinColumn (name = "ORG_ID", referencedColumnName="ID" )
    private Org adminOrg;
    private String name;
}
@Embeddable
public class Address implements Serializable 
{
    String city;
    Country nationality; // 递归嵌入
}
@Entity
public class Person implements Serializable 
{

    private Address homeAddress; //由于Address声明为@Embeddable，所以自动进行组件映射
    @Embedded
    @AttributeOverrides( { //进行映射覆写
        @AttributeOverride ( name = "adminOrg", column = @Column ( name = "ADMIN_ORG_ID" ) ),
        @AttributeOverride ( name = "name", column = @Column ( name = "COUNTRY_NAME" ) )
    } )
    Country bornIn;
}

//嵌入式对象的集合也可以被映射，注意子表不需要主键，也没有实体地位
@Embeddable
public class Address implements Comparable
{
    @Column ( name = "ZIP_CODE" )
    private Integer zip;

    @Column ( name = "STREET" )
    private String  street;
}
@Entity
@Table ( name = "T_PERSON" )
public class Person
{
    @Id
    private Integer      id;

    @ElementCollection
    @CollectionTable ( name = "T_ADDRESS", joinColumns = @JoinColumn ( name = "PERSON_ID" ) )
    //两种定义集合元素顺序的方法：
    @Sort ( type = SortType.NATURAL )
    @OrderBy ( "zip DESC" )
    private Set addresses;
}

关联映射

//基于主键共享的一对一关联
public class ChristmasTree 
{
    @Id
    private Long id;
 
    @OneToOne ( cascade = CascadeType.ALL, optional = false )
    @MapsId  //共享主键
    private TreeRoot root; 
}
public class TreeRoot 
{
    @Id
    private Long id;
}
//基于外键的多对一关联
@ManyToOne (
    fetch = FetchType.EAGER,//默认非延迟加载
    optional = false //是否可选，如果设置为真则允许为空，默认否
)
@JoinColumn ( /*本表外键列*/
    name = "ROOM_ID", 
    columnDefinition = "varchar(36) comment '所在房间'" ,
    referencedColumnName = "NOT_PK_COLUMN" //可以指定不和目标表的主键，而是其它唯一键列进行映射
)
@NotFound ( action = NotFoundAction.IGNORE ) //当对应数据找不到的时候，是否抛出异常
@OnDelete ( action = OnDeleteAction.CASCADE ) //父表ROOM的数据被删除时，在数据库级别自动级联删除当前表的相关数据
@ForeignKey (name = "FK_CRISMS_TREE_ROOM" ) //指定外键名称
private Room              room;

//基于映射表的多对一关联
@ManyToOne
@JoinTable (
    name = "T_M_CRISMS_TREE_ROOM",
    joinColumns = @JoinColumn ( name = "TREE_ID" ),
    inverseJoinColumns = @JoinColumn ( name = "ROOM_ID" ) )
private Room room;
//多对多关联
@ManyToMany
@JoinTable ( /*映射表*/
    name = "T_M_CRISMS_TREE_CHILD",
    joinColumns = @JoinColumn ( name = "TREE_ID" ),
    inverseJoinColumns = @JoinColumn ( name = "CHILD_ID" ) )
private Set        children;

//一对多映射：有序集合
@OneToMany (
    fetch = FetchType.LAZY,//延迟加载（直到第一次访问时才加载），集合默认真
    orphanRemoval = true,//是否在目标实体从集合中移除时，对其进行删除
    targetEntity = AbstractFurit.class,//目标实体，不使用泛型时，必须指定
    cascade = CascadeType.ALL //在进行各种增删改操作时，关联的目标实体是否也要进行同样的操作
)
@JoinColumn ( /*子表外键列*/name = "TREE_ID", columnDefinition = "varchar(36) comment '该水果挂在哪棵树上'" )
//集合属性可以设置（在Java中的）排序方式
@Sort ( type = SortType.NATURAL )
private SortedSet furits;               //如果不需要支持排序，可以使用Set接口

//一对多映射：列表
@OneToMany
@JoinColumn ( name = "TREE_ID", columnDefinition = "varchar(36) comment '该树枝是哪棵树的'" )
//子表索引列必须为整数，从0开始，不得跳跃
@IndexColumn ( name = "ORD", columnDefinition = "int(11) comment '序号'" )
@Cache ( usage = CacheConcurrencyStrategy.READ_WRITE, region = "entityCache" )
private List      branches;

//任意多态映射，关联目标不再同一个实体层次下
@AnyMetaDef (
    //该元数据可以在包上定义，以便重用
    name = "adminMetaDef",
    idType = "string", //目标实体的标识符类型
    metaType = "integer", //元数据列的数据类型
    metaValues = {
        @MetaValue ( value = "1", targetEntity = Child.class ),
        @MetaValue ( value = "2", targetEntity = Org.class )
    } )
@Any ( metaDef = "adminMetaDef",
       metaColumn = @Column ( name = "ADMIN_TYPE", columnDefinition = "int(11) comment '管理者类别:1孩子,2机构'" ) )
@JoinColumn ( name = "ADMIN_ID", columnDefinition = "varchar(36) comment '圣诞树主管理者'" )
private Admin             mainAdmin;

//任意多态集合映射
@ManyToAny ( metaDef = "adminMetaDef", metaColumn = @Column ( name = "ADMIN_TYPE" ) )
@JoinTable (
    name = "T_M_CRISMS_TREE_ADMIN", //必须使用映射表，以便指定元数据列
    joinColumns = @JoinColumn ( name = "TREE_ID" ),
    inverseJoinColumns = @JoinColumn ( name = "ADMIN_ID" ) )
private Set        admins;

继承映射

//*** 整个实体层次使用单张表
@Entity ( name = "AbstractFurit" )
@Table ( name = "T_FURIT" )
@Inheritance ( strategy = InheritanceType.SINGLE_TABLE )
@DiscriminatorColumn ( name = "TYPE_ID", columnDefinition = "int(11) comment '水果类型'" )
public class AbstractFurit implements IFurit, Serializable
{}
@Entity ( name = "Apple" )
@DiscriminatorValue ( "1" )
public class Apple extends AbstractFurit
{}

//*** 公共属性放在一张表，子类中的属性放在各自单独表中
@Entity ( name = "AbstractFurit" )
@Table ( name = "T_FURIT" )
@Inheritance ( strategy = InheritanceType.JOINED )
public class AbstractFurit implements IFurit, Serializable
{
    @id
    private Integer id;
}
@Entity ( name = "Apple" )
@Table ( name = "T_APPLE" )
@PrimaryKeyJoinColumn ( name = "FURIT_ID" )
public class Apple extends AbstractFurit
{}

//*** 每个子类使用一张表
@Entity ( name = "AbstractFurit" )
@Inheritance ( strategy = InheritanceType.TABLE_PER_CLASS )
public class AbstractFurit implements IFurit, Serializable
{}

其它注解

//领域驱动风格的建模时，实体的瞬时属性，必须同时使用注解和关键字
@Inject
@Transient //表示该字段不支持持久化
@JsonIgnore //结合JacksonJSON使用，忽略无业务意义的字段
private transient ServiceHelper   service; //指定transient关键字，不会在Java串行化时尝试串行化该字段

//公式列，可以使用SQL表达式定义一个只读的列，在数据库端完成计算
@Formula("length * height * width")
private long volume;

// 一个或者多个字段可以作为自然键的组成，具有惟一性非空约束
@NaturalId ( mutable = true ) //可以配置自然键是否可变
@Column ( name = "COLOR", columnDefinition = "varchar(50) comment '颜色'" )
private String color;

//定义一个用于继承的父类，该父类不具有实体资格，但是可以定义若干公用的映射属性
@MappedSuperclass
public class Admin
{
    @Column ( name = "NAME" )
    private String name;
}
@Entity ( name = "Child" )
//可以在上述父类的某个作为实体层次根的子类上，对属性（AttributeOverride）、关联映射（AssociationOverride）进行覆写
@AttributeOverride ( name = "name", column = @Column ( name = "CHILD_NAME" ) )
public class Child extends Admin
{}

//把一个实体映射到多张表上，这种映射方式支持在实体层次（例如单表/类层次）中的某个分支上使用
@SecondaryTables ( {
    @SecondaryTable ( name = "T_CRISMS_TREE_OTHER", pkJoinColumns = {
        @PrimaryKeyJoinColumn ( name = "cat_id", referencedColumnName = "id" ) }
    ),
    @SecondaryTable ( name = "T_CRISMS_TREE_OTHER_2" )
} )
public class ChristmasTree implements Serializable
{
    @Column ( table = "T_CRISMS_TREE_OTHER" ) //指定某个列存放在哪张表上
    private String otherInfo;
}

The post Hibernate基于注解的配置样例 appeared first on 绿色记忆.

Hibernate基于XML的配置文件样例

Alex — Sun, 12 Jul 2009 03:11:40 +0000

Hibernate 3.0配置文件




 
  oracle.jdbc.driver.OracleDriver
  CASTOR
  jdbc:oracle:thin:@RD-DB-5.sparknet.com.cn:1522:CPDB
  CASTOR
  org.hibernate.dialect.Oracle10gDialect
  20
  true
  true
  true
  thread

XRM配置文件样例

XRM是Hibernate3里面的一个试验性功能，用于在数据库和XML文件之间进行映射




	
		
			
		
		
		
			
				
					database Code
				
			
			
				
					corporation identifier
				
			
			
				
					changing sequence
				
			
			
				corpOther
			
		
		
		
			
				corporation name
			
		
		
			
				registered capital
			
		
		
			
				 corporation start date
			
		
		
			
				 corporation start time
			
		
		
		
			
				
					address of street
				
			
			
				
					building
				
			
			
				
					zip code
				
			
		
		
		
		
		
			
				address of city
			
		
		
			
			
			
		
		
		
			
				
				
				
			
			
				
					list index
				
			
			
				
				
				
			
		
        
        
            
                
                
                
            
            
        
		
			
				Version column
			
		
	
	
		
			
				
					database Code
				
			
			
				
					stock identifier
				
			
			
				
					changing sequence
				
			
			
		
		
			
				stock's name
			
		
		
			
				type of a stock
			
		
		
			
				registered capital of a stock
			
		
		
			
				actual capital of a stock
			
		
		
			
				capi type of a stock
			
		
		
		
			
				
				
				
			
			
			
				
				
				
			
		
	
	
		
			
				
					database Code
				
			
			
				
					gong shang org identifier
				
			
			
				
					changing sequence
				
			
			
		
		
			
				city name
			
		
	
	
		
			
				
					database Code
				
			
			
				
					corporation identifier
				
			
			
				
					changing sequence
				
			
			
		
		
			
				web site url
			
		
		
			
				city village flag
			
		
	
	
		
			
		
        
		
			
				city identifier
			
			
				SEQ_HXM
			
		
		
			
				city name
			
		
		
			
				city code

The post Hibernate基于XML的配置文件样例 appeared first on 绿色记忆.