Spring2.5 及 Hibernate Annotation 配置文件笔记

1. web.xml 配置

 <context-param>  
   
     <param-name>contextConfigLocation</param-name>  
        <param-value>  
            /WEB-INF/applicationContext.xml  
            <!--classpath*:/spring-config/applicationContext.xml-->  
        </param-value>  
   
 </context-param>  
    <!-- hibernate open session in view -->  
    <filter>   
       <filter-name>hibernateFilter</filter-name>  
       <filter-class>       org.springframework.orm.hibernate3.support.OpenSessionInViewFilter  
       </filter-class>  
   </filter>     
     
   <!-- 编码 -->  
   <filter>   
       <filter-name>encodingFilter</filter-name>  
       <filter-class>  
           org.springframework.web.filter.CharacterEncodingFilter  
       </filter-class>  
       <init-param>  
           <param-name>encoding</param-name>  
           <param-value>UTF-8</param-value>  
       </init-param>  
       <init-param>  
           <param-name>forceEncoding</param-name>  
           <param-value>true</param-value>  
       </init-param>  
   </filter>     
   <!-- hibernate open session in view -->  
   <filter-mapping>    
       <filter-name>hibernateFilter</filter-name>  
       <url-pattern>/*<url-pattern>     
   </filter-mapping>    
   <!-- 编码 -->  
   <filter-mapping>    
       <filter-name>encodingFilter</filter-name>  
       <url-pattern>*.jsp<url-pattern>     
   </filter-mapping>  
     
   <listener>  
       <listener-class>  
           org.springframework.web.context.ContextLoaderListener  
       </listener-class>  
   </listener>  
     
   <listener>  
       <listener-class>             org.springframework.web.context.request.RequestContextListener  
       </listener-class>  
   </listener>  
     
   <!-- 要负责处理由　 JavaBeans Introspector的使用而引起的缓冲泄露 -->  
   <listener>  
       <listener-class>  
           org.springframework.web.util.IntrospectorCleanupListener  
       </listener-class>  
   </listener>  

2.applicationContext.xml 配置
对于dataSource就省略了 可以使用c3p0连接池

 <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">  
        <property name="dataSource" ref="dataSource"/>  
        <property name="annotatedClasses" ref="annotatedClasses"/>  
        <property name="hibernateProperties" ref="hibernateProperties"/>  
    </bean>  
      
    <bean name="hibernateProperties" class="org.springframework.beans.factory.config.PropertiesFactoryBean">  
        <property name="properties">  
            <props>  
               <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>  
               <prop key="hibernate.show_sql">true</prop>  
               <prop key="hibernate.hbm2ddl.auto">none</prop>  
               <prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>  
               <prop key="hibernate.cache.use_query_cache">true</prop>  
               <prop key="hibernate.default_batch_fetch_size">30</prop>  
           </props>  
       </property>  
   </bean>  
     
   <!-- annotation table 类 -->  
   <bean id="annotatedClasses" class="org.springframework.beans.factory.config.ListFactoryBean">  
       <property name="sourceList">  
           <list>  
               <value>com.bask.model.Promotion</value>  
               <value>com.bask.model.PromotionGroup</value>  
               <value>com.bask.model.Largess</value>  
           </list>  
       </property>  
   </bean>  
     
   <!-- 事务 begin -->  
   <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
       <property name="sessionFactory" ref="sessionFactory" />  
   </bean>  
     
   <!-- 支持 @Transactional -->  
   <tx:annotation-driven/>  
     
   <!-- 支持 @AspectJ -->  
   <aop:aspectj-autoproxy/>  
     
   <!-- 以AspectJ方式定义AOP -->  
   <aop:config proxy-target-class="true">    
       <aop:advisor pointcut="execution(* com.bask.service.*Manager.*(..))" advice-ref="txAdvice"/>    
   </aop:config>  
     
   <tx:advice id="txAdvice" transaction-manager="transactionManager">  
       <tx:attributes>  
           <!-- 以get 、 find 开头的方法是只读事务 -->  
           <tx:method name="get*" read-only="true" />  
           <tx:method name="find*" read-only="true" />  
           <!-- 其他方法是默认 -->  
           <tx:method name="save*" />  
       </tx:attributes>  
   </tx:advice>  
   <!-- 事务 end -->  
     
   <context:annotation-config/>  
   <!-- service下是spring使用注解 -->  
   <context:component-scan base-package="com.bask.service"/>  

3.说明
在这里我们将会根据class生产数据库表 自动创建|更新|验证数据库表结构

<prop key="hibernate.hbm2ddl.auto">none</prop>  
<!-- auto 可以有create update and none 等-->  

接下来是Hibernate Annotation使用笔记

@Entity                         //声明为一个实体bean  
@Table(name="promotion_info")   //为实体bean映射指定表(表名="promotion_info)  
@Id                             //声明了该实体bean的标识属性  
@GeneratedValue                 //可以定义标识字段的生成策略.  
@Transient                      //将忽略这些字段和属性,不用持久化到数据库  
@Column(name="promotion_remark")//声明列(字段名="promotion_total") 属性还包括(length=200等)  
@Temporal(TemporalType.TIMESTAMP)//声明时间格式  
@Enumerated                     //声明枚举  
@Version                        //声明添加对乐观锁定的支持  
@OneToOne                       //可以建立实体bean之间的一对一的关联  
@OneToMany                      //可以建立实体bean之间的一对多的关联  
@ManyToOne                      //可以建立实体bean之间的多对一的关联  
@ManyToMany                     //可以建立实体bean之间的多对多的关联  
@Formula                        //一个SQL表达式，这种属性是只读的,不在数据库生成属性(可以使用sum、average、max等)  

以上是基本常用注解，下面是例子说明
a.Promotion

@Entity  
@Table(name="promotion_info")  
public class Promotion implements Serializable {  
      
        //AUTO--可以是identity类型的字段,或者sequence类型或者table类型,取决于不同的底层数据库  
  @Id   
  @GeneratedValue(strategy = GenerationType.AUTO)  
  private Long id;  
      
  @Column(name="group_start_amount")  
  private Integer groupStartAmount=0;  
         
  @Column(name="promotion_remark",length=200)  
  //@Lob 如果是文章内容可以使用 只需要把length=200去掉就可以了  
   private String remark;  
  //DATE      - java.sql.Date  
  //TIME      - java.sql.Time  
  //TIMESTAMP - java.sql.Timestamp  
  @Temporal(TemporalType.TIMESTAMP)  
  @Column(name="start_time")  
  private Date startTime;  
     
  //显示0 隐藏1  
  public static enum DisplayType {  
           显示,隐藏  
  }  
  @Enumerated(value = EnumType.ORDINAL)//ORDINAL序数  
  private DisplayType displayType = DisplayType.显示;  
     
  @Version  
  private Integer version;  
     
  //CascadeType.PERSIST   -- 触发级联创建(create)  
  //CascadeType.MERGE     -- 触发级联合并(update)  
  //FetchType.LAZY        -- 延迟加载  
  @ManyToOne(cascade = {CascadeType.PERSIST,CascadeType.MERGE},fetch = FetchType.LAZY)  
  private PromotionGroup promotionGroup;  
     
  //单向ManyToMany  
  //@JoinTable(关联的表名)  
  //joinColumns -- promotion关联的列的外键  
  //inverseJoinColumns -- largess 关联列的外键  
  @ManyToMany(cascade = {CascadeType.PERSIST,CascadeType.MERGE})  
  @JoinTable(name="promotion_largess",joinColumns={@JoinColumn(name="promotion_id")},inverseJoinColumns={@JoinColumn(name="largess_id")})  
  private Set<Largess> largess;   
     
  //get set 省略.  
     
}  

b.PrmotionGroup

@Entity  
@Table(name="promotion_group")  
public class PromotionGroup implements Serializable {  
  @Id   
  @GeneratedValue(strategy = GenerationType.AUTO)  
  private Long id;  
         
  //mappedBy的值"promotionGroup"指向owner(Promotion)端的关联属性,并且是双向关系  
   @OneToMany(mappedBy="promotionGroup",cascade=CascadeType.ALL)  
   private List<Promotion> promotion;  
     
   //get set 省略.  
} 

c.Largess

@Entity  
@Table(name="largess")  
public class Largess implements Serializable {  
  @Id   
  @GeneratedValue(strategy = GenerationType.AUTO)  
  private Long id;  
     
  //1.sql语句中的字段和表名都应该和数据库相应,而不是类中的字段,  
  //若带有参数如la.id= id,这个=id才是类中属性  
  //2.操作字段一定要用别名  
  @Formula(select max(la.id) from largess as la)  
  private int maxId;  
     
  @Formula(select COUNT(la.id) from largess la)  
  private int count;  
     
  @Transient  
  private String img  
     
  //get set 省略.  
}