JPA基本属性注解

JPA(Java Persistence API)是Sun官方提出的Java持久化规范。它为Java开发人员提供了一种对象/关系映射工具来管理Java应用中的关系数据

JPA规范要求在类路径的META-INF目录下放置persistence.xml

JPA 中将一个类注解成实体类(entity class)有两种不同的注解方式：基于属性(property-based)和基于字段(field-based)的注解
基于字段的注解, 就是直接将注解放置在实体类的字段的前面
基于属性的注解, 就是直接将注解放置在实体类相应的getter方法前面(这一点和Spring正好相反),但是同一个实体类中必须并且只能使用其中一种注解方式
Entity、Table、Id、GeneratedValue、Basic、Column、Temporal、Transient、Lob、Transient、SecondaryTable、Embeddable、Embedded

JPA注解
(1)Entity
@javax.persistence.Entity(name="xxx") 
name指定实体Bean的名称,默认值为 bean class 的非限定类名,select o from xxx o where o.id=?1

(2)Table
@javax.persistence.Table(catalog="xx",name="xx",schema="xx",uniqueConstraints={ @UniqueConstraint(columnNames={"xx","xx"})})
name:指定表的名称
catalog:指定数据库名称
schema:指定数据库的用户名
uniqueConstraints:指定唯一性字段约束,如为personid 和name 字段指定唯一性约束
uniqueConstraints={ @UniqueConstraint(columnNames={"personid", "name"})}

(3)Id
@javax.persistence.Id()
映射到数据库表的主键的属性,一个实体只能有一个属性被映射为主键.

(4)GeneratedValue
@javax.persistence.GeneratedValue(generator="xxx",strategy=GenerationType.AUTO)
strategy:表示主键生成策略,有AUTO,INDENTITY,SEQUENCE 和 TABLE 4种
分别表示让ORM框架自动选择,根据数据库的Identity字段生成,根据数据库表的Sequence字段生成,以有根据一个额外的表生成主键,默认为AUTO 
generator:表示主键生成器的名称,这个属性通常和ORM框架相关,例如,Hibernate可以指定uuid等主键生成方式. 
Hibernate UUID
@Id @GeneratedValue(generator="system-uuid")
@GenericGenerator(name="system-uuid",strategy = "uuid")

(5)Basic
@javax.persistence.Basic(fetch=FetchType.LAZY,optional=true)
fetch:抓取策略,延时加载与立即加载
optional:指定在生成数据库结构时字段是否允许为 null

(6)Column
@javax.persistence.Column(length=15,nullable=false,columnDefinition="",insertable=true,scale=10,table="",updatable=true)
@Column注解指定字段的详细定义
name:字段的名称,默认与属性名称一致 
nullable:是否允许为null,默认为true
unique:是否唯一,默认为false 
length:字段的长度,仅对String类型的字段有效 
columnDefinition:表示该字段在数据库中的实际类型
通常ORM框架可以根据属性类型自动判断数据库中字段的类型,
但是对于Date类型仍无法确定数据库中字段类型究竟是DATE,TIME还是TIMESTAMP,
此外,String的默认映射类型为VARCHAR,如果要将String类型映射到特定数据库的BLOB或TEXT字段类型,该属性非常有用
如: @Column(name="BIRTH",nullable="false",columnDefinition="DATE") 
insertable:默认情况下,JPA持续性提供程序假设所有列始终包含在 SQL INSERT 语句中。
如果该列不应包含在这些语句中，请将 insertable 设置为 false 
updatable：列始终包含在 SQL UPDATE 语句中。如果该列不应包含在这些语句中，请将 updatable 设置为 false 
table:实体的所有持久字段都存储到一个其名称为实体名称的数据库表中,如果该列与 @SecondaryTable表关联
需将 name 设置为相应辅助表名称的String名称

(7)Temporal
@javax.persistence.Temporal(TemporalType.DATE)
value:TemporalType.DATE,TemporalType.TIME,TemporalType.TIMESTAMP时间类型格式

(8)Enumerated
@javax.persistence.Enumerated(EnumType.STRING)
value:EnumType.STRING,EnumType.ORDINAL
枚举类型成员属性映射,EnumType.STRING指定属性映射为字符串,EnumType.ORDINAL指定属性映射为数据序


(9)Lob
@javax.persistence.Lob
用于标注字段类型为Clob和Blob类型
Clob(Character Large Ojects)类型是长字符串类型,实体的类型可为char[]、Character[]、或者String类型
Blob(Binary Large Objects)类型是字节类型,实体的类型可为byte[]、Byte[]、或者实现了Serializable接口的类。
通常使用惰性加载的方式, @Basic(fetch=FetchType.LAZY)

(10)Transient
@javax.persistence.Transient
@Transient表示该属性并非一个到数据库表的字段的映射,ORM框架将忽略该属性

(11)SecondaryTable 
@javax.persistence.SecondaryTable
将一个实体映射到多个数据库表中
如：
@Entity
@SecondaryTables({ 
@SecondaryTable(name = "Address"), 
    @SecondaryTable(name = "Comments") 
})
public class Forum implements Serializable {
@Column(table = "Address", length = 100) 
private String street; 
@Column(table = "Address", nullable = false) 
private String city; 
@Column(table = "Address") 
private String conutry; 
@Column(table = "Comments") 
private String title; 
@Column(table = "Comments") 
private String Comments; 
@Column(table = "Comments") 
}
table属性的值指定字段存储的表名称
没有用 @Column 注解改变属性默认的字段将会存在于 Forum 表

(12)@Embeddable
@javax.persistence.Embeddable
嵌套映射,在被嵌套的类中使用Embeddable注解,说明这个就是一个可被嵌套的类,使用 @Embedded
当同一个类被不同的注解方式的类嵌套时，可能会出现一些错误，使用 @Access(AccessType. FIELD)设定被嵌套类的注解方式 

================================================================================================
(1)
@Entity注解定义
@Target(TYPE) @Retention(RUNTIME)
public @interface Entity{
    String name() default ""; //实体bean的名称
}


(2)
@Table注解定义
@Target(value = {ElementType.TYPE}) 
@Retention(value = RetentionPolicy.RUNTIME) 
public @interface Table { 
public String name() default ""; //表的名称
public String catalog() default ""; //数据库名称
public String schema() default ""; //数据库用户名
public UniqueConstraint[] uniqueConstraints() default {}; //指定多个字段唯一性约束 
}


(3)
@UniqueConstraint注解定义
public @interface UniqueConstraint{
    String[] columnNames( ); //唯一字段属性名称
}


(4)
@Id注解定义
@Target({METHOD, FIELD}) @Retention(RUNTIME) 
public @interface Id{ }


(5)
@注解GeneratedValue定义
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface GeneratedValue{
    GenerationType strategy() default AUTO; //主键生成策略
    String generator() default "";
}


(6)
@Column注解定义
@Target(value = {ElementType.METHOD, ElementType.FIELD}) 
@Retention(value = RetentionPolicy.RUNTIME) 
public @interface Column { 
public String name() default ""; //数据库中的列名
public boolean unique() default false; //该列是否唯一
public boolean nullable() default true; //是否可以为空
public boolean insertable() default true; 
public boolean updatable() default true; 
public String columnDefinition() default ""; 
public String table() default ""; 
public int length() default 255; //该列的最大长度
public int precision() default 0; 
public int scale() default 0; 
}


(7)
@Temporal注解定义
public enum TemporalType{
    DATE, //代表 date类型 java.sql.Date 2008-08-08 
    TIME, //代表时间类型  java.sql.Time 20:00:00
    TIMESTAMP //代表时间 java.sql.Timestamp 2008-08-08 20:00:00.000000001
}
public enum TemporalType{
    DATE, //代表 date类型 //java.sql.Date 2008-08-08 
    TIME, //代表时间类型   //java.sql.Time 20:00:00
    TIMESTAMP //代表时间 //java.sql.Timestamp 2008-08-08 20:00:00.000000001

}

转载自  http://blog.csdn.net/ljhabc1982/article/details/6556349

中场休息 ===========================================================

Spring3 MVC 注解（一）---注解基本配置及@controller和 @RequestMapping 常用解释

一：配置web.xml

      1)问题：spring项目中有多个配置文件mvc.xml   dao.xml

      2）解决：在web.xml中

       <init-param>

             <param-name>contextConfigLocation</param-name>

             <param-value>/WEB-INF/xxx/*.xml</param-value>     

              xxx表示xml文件路径    *.xml表示后缀名为xml的任意文件

      </init-param>    

    3）可以使用  逗号分隔

二：controller

       1:spring mvc 中将  controller  认为是 MVC中的C --控制层

       2：规范命名 类名  xxxController 

      3：如果不基于注解：   该类需要继承  CommandController   或者 其他很多 参见  spring帮助

            如果基于注解：在类名前  加上         @controller   

      4:补充：将类名前加上该注解，当spring启动  或者web服务启动  spring会自动扫描所有包（当然，这个可以设置）

         作用:  就是告诉服务器  这个类是MVC中的C    这个类可以接收用户请求    处理用户请求

三：问题：如何接收用户请求

     1：假设用户请求URL 是： http://localhost:8080/项目名/xxx.do      do不do都一样  不管这个do  你用什么都可以

     2：这个时候，spring开始在所有的 C  中，找对应的处理请求的方法

     3：在任意的可以 C 的类中，在你想要处理此请求的方法定义的前面 

         @RequestMapping("/xxx")          这个时候的xxx  就是用户请求的xxx     不管do

         public  String  方法名（）

         {

           return  “aaa”；                          

            返回一个字符串，非常有用   要注意   用来决定要显示的MVC的 V  视图层 是哪个 

          }

四：上面  配置好了  MVC的   C  也就是 控制层   , 在方法中返回字符串  用来决定MVC的V  视图层

       问题：如何让spring 去扫描类  建立关联

       1：在配置文件中  （spring）的 假设是 mvc.xml  中

       2：加入 <context:component-scan  base-package="包路径"/>  

     

五：问题 如何返回到视图层 V

     1： 解决：此时，需要在配置文件中，加入视图解析器    有很多种 ，太多了 

     2：这里用基于jsp/jstl  视图

     3：在web.xml 中加入bean 配置

<bean class="org.s...f....web.servlet.view.InternalResourceViewResolver">

       <property  name="prefix" value="/WEB-INF/views"/>                     前缀

      <property  name="suffix"   value=".jsp"/>                                        后缀

</bean>

 

 

小结：通过上述5步  ，基本完成 C   V 的配置

 1：spring 中的C  一般起类名     XXXController   在这个类里面 需要加入@controller  标志这个类可以作为请求处理类   也就是 控制类

2：这个控制类里面可以有很多方法，哪个方法用来处理用户请求，就在那个方法前面 加  @RequestMapping（“/xxxxx请求路径”）

3;当请求处理完毕后  返回值  决定了  该处理完毕后  用户将跳转到那个页面   这个很重要  

4：例如

@RequestMapping("/xxx")          这个时候的xxx  就是用户请求的xxx     不管do

         public  String  方法名（）

         {

             return  “aaa”；                         

            返回一个字符串，非常有用   要注意   用来决定要显示的MVC的 V  视图层 是哪个 

       }

   返回 aaa   根据配置文件中的 视图处理器配置    加入前缀  后缀

  页面将跳转到 /WEB-INF/views/aaa.jsp

========================= 中场休息

@GeneratedValue

一、JPA通用策略生成器 
通过annotation来映射hibernate实体的,基于annotation的hibernate主键标识为@Id, 
其生成规则由@GeneratedValue设定的.这里的@id和@GeneratedValue都是JPA的标准用法, 
JPA提供四种标准用法,由@GeneratedValue的源代码可以明显看出. 

Java代码  

1. @Target({METHOD,FIELD})    
2.     @Retention(RUNTIME)    
3.     public @interface GeneratedValue{    
4.         GenerationType strategy() default AUTO;    
5.         String generator() default "";    
6.     }   

其中GenerationType: 

Java代码  

1. public enum GenerationType{    
2.     TABLE,    
3.     SEQUENCE,    
4.     IDENTITY,    
5.     AUTO   
6. }  

JPA提供的四种标准用法为TABLE,SEQUENCE,IDENTITY,AUTO. 
TABLE：使用一个特定的数据库表格来保存主键。 
SEQUENCE：根据底层数据库的序列来生成主键，条件是数据库支持序列。 
IDENTITY：主键由数据库自动生成（主要是自动增长型） 
AUTO：主键由程序控制。 

1、TABLE 

Java代码  

1. @Id  
2. @GeneratedValue(strategy = GenerationType.TABLE, generator="payablemoney_gen")  
3. @TableGenerator(name = "pk_gen",  
4.     table="tb_generator",  
5.     pkColumnName="gen_name",  
6.     valueColumnName="gen_value",  
7.     pkColumnValue="PAYABLEMOENY_PK",  
8.     allocationSize=1  
9. )  

这里应用表tb_generator，定义为 

Sql代码  

1. CREATE TABLE  tb_generator (  
2.   id NUMBER NOT NULL,  
3.   gen_name VARCHAR2(255) NOT NULL,  
4.   gen_value NUMBER NOT NULL,  
5.   PRIMARY KEY(id)  
6. )  

插入纪录，供生成主键使用， 

Sql代码  

1. INSERT INTO tb_generator(id, gen_name, gen_value) VALUES (1,PAYABLEMOENY_PK', 1);  

在主键生成后，这条纪录的value值，按allocationSize递增。 


@TableGenerator的定义： 

Java代码  

1. @Target({TYPE, METHOD, FIELD})   
2. @Retention(RUNTIME)  
3. public @interface TableGenerator {  
4.   String name();  
5.   String table() default "";  
6.   String catalog() default "";  
7.   String schema() default "";  
8.   String pkColumnName() default "";  
9.   String valueColumnName() default "";  
10.   String pkColumnValue() default "";  
11.   int initialValue() default 0;  
12.   int allocationSize() default 50;  
13.   UniqueConstraint[] uniqueConstraints() default {};  
14. }  

其中属性说明： 
name属性表示该表主键生成策略的名称，它被引用在@GeneratedValue中设置的“generator”值中。 
table属性表示表生成策略所持久化的表名，例如，这里表使用的是数据库中的“tb_generator”。 
catalog属性和schema具体指定表所在的目录名或是数据库名。 
pkColumnName属性的值表示在持久化表中，该主键生成策略所对应键值的名称。例如在“tb_generator”中将“gen_name”作为主键的键值 
valueColumnName属性的值表示在持久化表中，该主键当前所生成的值，它的值将会随着每次创建累加。例如，在“tb_generator”中将“gen_value”作为主键的值 
pkColumnValue属性的值表示在持久化表中，该生成策略所对应的主键。例如在“tb_generator”表中，将“gen_name”的值为“CUSTOMER_PK”。 
initialValue表示主键初识值，默认为0。 
allocationSize表示每次主键值增加的大小，例如设置成1，则表示每次创建新记录后自动加1，默认为50。 
UniqueConstraint与@Table标记中的用法类似。 

2、SEQUENCE 

Java代码  

1. @Id  
2. @GeneratedValue(strategy = GenerationType.SEQUENCE,generator="payablemoney_seq")  
3. @SequenceGenerator(name="payablemoney_seq", sequenceName="seq_payment")  

@SequenceGenerator定义 

Java代码  

1. @Target({TYPE, METHOD, FIELD})   
2. @Retention(RUNTIME)  
3. public @interface SequenceGenerator {  
4.  String name();  
5.  String sequenceName() default "";  
6.  int initialValue() default 0;  
7.  int allocationSize() default 50;  
8. }  

name属性表示该表主键生成策略的名称，它被引用在@GeneratedValue中设置的“generator”值中。 
sequenceName属性表示生成策略用到的数据库序列名称。 
initialValue表示主键初识值，默认为0。 
allocationSize表示每次主键值增加的大小，例如设置成1，则表示每次创建新记录后自动加1，默认为50。 


3、IDENTITY 

Java代码  

1. @Id  
2. @GeneratedValue(strategy = GenerationType.IDENTITY)  

4、AUTO 

Java代码  

1. @Id  
2. @GeneratedValue(strategy = GenerationType.AUTO)  

在指定主键时，如果不指定主键生成策略，默认为AUTO。 

Java代码  

1. @Id  

跟下面的定义是一样的。 

Java代码  

1. @Id  
2. @GeneratedValue(strategy = GenerationType.AUTO)  

二、hibernate主键策略生成器 
hibernate提供多种主键生成策略，有点是类似于JPA，有的是hibernate特有： 
native: 对于 oracle 采用 Sequence 方式，对于MySQL 和 SQL Server 采用identity（自增主键生成机制），native就是将主键的生成工作交由数据库完成，hibernate不管（很常用）。 
uuid: 采用128位的uuid算法生成主键，uuid被编码为一个32位16进制数字的字符串。占用空间大（字符串类型）。 
hilo: 使用hilo生成策略，要在数据库中建立一张额外的表，默认表名为hibernate_unique_key,默认字段为integer类型，名称是next_hi（比较少用）。 
assigned: 在插入数据的时候主键由程序处理（很常用），这是 <generator>元素没有指定时的默认生成策略。等同于JPA中的AUTO。 
identity: 使用SQL Server 和 MySQL 的自增字段，这个方法不能放到 Oracle 中，Oracle 不支持自增字段，要设定sequence（MySQL 和 SQL Server 中很常用）。 
          等同于JPA中的INDENTITY。 
select: 使用触发器生成主键（主要用于早期的数据库主键生成机制，少用）。 
sequence: 调用底层数据库的序列来生成主键，要设定序列名，不然hibernate无法找到。 
seqhilo: 通过hilo算法实现，但是主键历史保存在Sequence中，适用于支持 Sequence 的数据库，如 Oracle（比较少用） 
increment: 插入数据的时候hibernate会给主键添加一个自增的主键，但是一个hibernate实例就维护一个计数器，所以在多个实例运行的时候不能使用这个方法。 
foreign: 使用另外一个相关联的对象的主键。通常和<one-to-one>联合起来使用。 
guid: 采用数据库底层的guid算法机制，对应MYSQL的uuid()函数，SQL Server的newid()函数，ORACLE的rawtohex(sys_guid())函数等。 
uuid.hex: 看uuid，建议用uuid替换。 
sequence-identity: sequence策略的扩展，采用立即检索策略来获取sequence值，需要JDBC3.0和JDK4以上（含1.4）版本 

hibernate提供了多种生成器供选择,基于Annotation的方式通过@GenericGenerator实现. 
hibernate每种主键生成策略提供接口org.hibernate.id.IdentifierGenerator的实现类,如果要实现自定义的主键生成策略也必须实现此接口. 

Java代码  

1. public interface IdentifierGenerator {  
2.     /** 
3.      * The configuration parameter holding the entity name 
4.      */  
5.     public static final String ENTITY_NAME = "entity_name";  
6.       
7.   /** 
8.    * Generate a new identifier. 
9.    * @param session 
10.    * @param object the entity or toplevel collection for which the id is being generated 
11.    * 
12.    * @return a new identifier 
13.    * @throws HibernateException 
14.    */  
15.   public Serializable generate(SessionImplementor session, Object object)   
16.     throws HibernateException;  
17. }  

IdentifierGenerator提供一generate方法,generate方法返回产生的主键. 


三、@GenericGenerator 
自定义主键生成策略，由@GenericGenerator实现。 
hibernate在JPA的基础上进行了扩展，可以用一下方式引入hibernate独有的主键生成策略，就是通过@GenericGenerator加入的。 

比如说，JPA标准用法 

Java代码  

1. @Id  
2. @GeneratedValue(GenerationType.AUTO)  

就可以用hibernate特有以下用法来实现 

Java代码  

1. @GeneratedValue(generator = "paymentableGenerator")    
2. @GenericGenerator(name = "paymentableGenerator", strategy = "assigned")  

@GenericGenerator的定义: 

Java代码  

1. @Target({PACKAGE, TYPE, METHOD, FIELD})  
2. @Retention(RUNTIME)  
3. public @interface GenericGenerator {  
4.  /** 
5.   * unique generator name 
6.   */  
7.  String name();  
8.  /** 
9.   * Generator strategy either a predefined Hibernate 
10.   * strategy or a fully qualified class name. 
11.   */  
12.  String strategy();  
13.  /** 
14.   * Optional generator parameters 
15.   */  
16.  Parameter[] parameters() default {};  
17. }  

name属性指定生成器名称。 
strategy属性指定具体生成器的类名。 
parameters得到strategy指定的具体生成器所用到的参数。 

对于这些hibernate主键生成策略和各自的具体生成器之间的关系,在org.hibernate.id.IdentifierGeneratorFactory中指定了, 

Java代码  

1. static {  
2.   GENERATORS.put("uuid", UUIDHexGenerator.class);  
3.   GENERATORS.put("hilo", TableHiLoGenerator.class);  
4.   GENERATORS.put("assigned", Assigned.class);  
5.   GENERATORS.put("identity", IdentityGenerator.class);  
6.   GENERATORS.put("select", SelectGenerator.class);  
7.   GENERATORS.put("sequence", SequenceGenerator.class);  
8.   GENERATORS.put("seqhilo", SequenceHiLoGenerator.class);  
9.   GENERATORS.put("increment", IncrementGenerator.class);  
10.   GENERATORS.put("foreign", ForeignGenerator.class);  
11.   GENERATORS.put("guid", GUIDGenerator.class);  
12.   GENERATORS.put("uuid.hex", UUIDHexGenerator.class); //uuid.hex is deprecated  
13.   GENERATORS.put("sequence-identity", SequenceIdentityGenerator.class);  
14. }  

上面十二种策略，加上native，hibernate一共默认支持十三种生成策略。 

1、native 

Java代码  

1. @GeneratedValue(generator = "paymentableGenerator")    
2. @GenericGenerator(name = "paymentableGenerator", strategy = "native")   

2、uuid 

Java代码  

1. @GeneratedValue(generator = "paymentableGenerator")    
2. @GenericGenerator(name = "paymentableGenerator", strategy = "uuid")   

3、hilo 

Java代码  

1. @GeneratedValue(generator = "paymentableGenerator")    
2. @GenericGenerator(name = "paymentableGenerator", strategy = "hilo")   

4、assigned 

Java代码  

1. @GeneratedValue(generator = "paymentableGenerator")    
2. @GenericGenerator(name = "paymentableGenerator", strategy = "assigned")   

5、identity 

Java代码  

1. @GeneratedValue(generator = "paymentableGenerator")    
2. @GenericGenerator(name = "paymentableGenerator", strategy = "identity")   

6、select 

Java代码  

1. @GeneratedValue(generator = "paymentableGenerator")  
2. @GenericGenerator(name="select", strategy="select",  
3.      parameters = { @Parameter(name = "key", value = "idstoerung") })  

7、sequence 

Java代码  

1. @GeneratedValue(generator = "paymentableGenerator")  
2. @GenericGenerator(name = "paymentableGenerator", strategy = "sequence",   
3.          parameters = { @Parameter(name = "sequence", value = "seq_payablemoney") })  

8、seqhilo 

Java代码  

1. @GeneratedValue(generator = "paymentableGenerator")  
2. @GenericGenerator(name = "paymentableGenerator", strategy = "seqhilo",   
3.          parameters = { @Parameter(name = "max_lo", value = "5") })  

9、increment 

Java代码  

1. @GeneratedValue(generator = "paymentableGenerator")    
2. @GenericGenerator(name = "paymentableGenerator", strategy = "increment")   

10、foreign 

Java代码  

1. @GeneratedValue(generator = "idGenerator")  
2. @GenericGenerator(name = "idGenerator", strategy = "foreign",   
3.          parameters = { @Parameter(name = "property", value = "employee") })  

注意：直接使用@PrimaryKeyJoinColumn 报错（?） 

Java代码  

1. @OneToOne(cascade = CascadeType.ALL)   
2. @PrimaryKeyJoinColumn   

例如 

Java代码  

1. @Entity  
2. public class Employee {  
3.   @Id Integer id;  
4.       
5.   @OneToOne @PrimaryKeyJoinColumn  
6.   EmployeeInfo info;  
7.   ...  
8. }  

应该为 

Java代码  

1. @Entity  
2. public class Employee {  
3.   @Id   
4.   @GeneratedValue(generator = "idGenerator")  
5.   @GenericGenerator(name = "idGenerator", strategy = "foreign",   
6.          parameters = { @Parameter(name = "property", value = "info") })   
7.   Integer id;  
8.       
9.   @OneToOne  
10.   EmployeeInfo info;  
11.   ...  
12. }  

11、guid 

Java代码  

1. @GeneratedValue(generator = "paymentableGenerator")    
2. @GenericGenerator(name = "paymentableGenerator", strategy = "guid")   

12、uuid.hex 

Java代码  

1. @GeneratedValue(generator = "paymentableGenerator")    
2. @GenericGenerator(name = "paymentableGenerator", strategy = "uuid.hex")   

13、sequence-identity 

Java代码  

1. @GeneratedValue(generator = "paymentableGenerator")  
2. @GenericGenerator(name = "paymentableGenerator", strategy = "sequence-identity",   
3.          parameters = { @Parameter(name = "sequence", value = "seq_payablemoney") })  

四、通过@GenericGenerator自定义主键生成策略 
如果实际应用中，主键策略为程序指定了就用程序指定的主键（assigned），没有指定就从sequence中取。 
明显上面所讨论的策略都不满足，只好自己扩展了，集成assigned和sequence两种策略。 

Java代码  

1. public class AssignedSequenceGenerator extends SequenceGenerator implements   
2.  PersistentIdentifierGenerator, Configurable {  
3.  private String entityName;  
4.     
5.  public void configure(Type type, Properties params, Dialect dialect) throws MappingException {  
6.   entityName = params.getProperty(ENTITY_NAME);  
7.   if (entityName==null) {  
8.    throw new MappingException("no entity name");  
9.   }  
10.     
11.   super.configure(type, params, dialect);    
12.  }  
13.    
14.  public Serializable generate(SessionImplementor session, Object obj)   
15.   throws HibernateException {  
16.     
17.   Serializable id = session.getEntityPersister( entityName, obj )   
18.     .getIdentifier( obj, session.getEntityMode() );  
19.     
20.   if (id==null) {  
21.    id = super.generate(session, obj);  
22.   }  
23.     
24.   return id;  
25.  }  
26. }  

实际应用中，定义同sequence。 

Java代码  

1. @GeneratedValue(generator = "paymentableGenerator")  
2. @GenericGenerator(name = "paymentableGenerator", strategy = "AssignedSequenceGenerator",   
3.      parameters = { @Parameter(name = "sequence", value = "seq_payablemoney") })  

四种数据库的支持情况如下：

 

数据库名称	支持的id策略
mysql	GenerationType.TABLE GenerationType.AUTO GenerationType.IDENTITY 不支持GenerationType.SEQUENCE
oracle	strategy=GenerationType.AUTO GenerationType.SEQUENCE GenerationType.TABLE 不支持GenerationType.IDENTITY
postgreSQL	GenerationType.TABLE GenerationType.AUTO GenerationType.IDENTITY GenerationType.SEQUENCE 都支持
kingbase	GenerationType.TABLE GenerationType.SEQUENCE GenerationType.IDENTITY GenerationType.AUTO 都支持

================================== 中场休息

@Target Annotation的使用

转载自：http://yahaitt.iteye.com/blog/144562

@Target Annotation表示的是这个Annotation可以应用在哪里，是对Annotation应用的限制，如果没有这个标识的话，Annotation可以用在任何地方，比如类上，方法上，变量、属性上等，可以从java.lang.Enum.ElementType这个枚举里选择。

1、只能用在方法上的限制的应用

java 代码     

    package com.test;   
      
    import java.lang.annotation.ElementType;   
    import java.lang.annotation.Target;   
      
    @Target(ElementType.METHOD)   
    public @interface TargetTest {   
        String hello();   
    }   

 

java 代码

    package com.test;   
      
      
    public class TargetClass {   
        @TargetTest(hello = "abc")   
        public void doSomething()   
        {   
            System.out.println("do something");   
        }   
    }   

2、只能用于类上的限制应用

java 代码

    package com.test;   
      
    import java.lang.annotation.ElementType;   
    import java.lang.annotation.Target;   
      
    @Target(ElementType.TYPE)   
    public @interface TargetTest {   
        String hello();   
    }   

java 代码

    package com.test;   
      
      
    @TargetTest(hello = "abc")   
    public class TargetClass {   
        public void doSomething()   
        {   
            System.out.println("do something");   
        }   
    }   

================================中场休息

参见：

Java注释@interface的用

java用  @interface Annotation{ } 定义一个注解 @Annotation，一个注解是一个类。
@Override，@Deprecated，@SuppressWarnings为常见的3个注解。
注解相当于一种标记，在程序中加上了注解就等于为程序加上了某种标记，以后，

JAVAC编译器，开发工具和其他程序可以用反射来了解你的类以及各种元素上有无任何标记，看你有什么标记，就去干相应的事。

注解@Override用在方法上，当我们想重写一个方法时，在方法上加@Override，当我们方法
的名字出错时，编译器就会报错，如图：

       注解@Deprecated，用来表示某个类的属性或方法已经过时，不想别人再用时，在属性和方法
上用@Deprecated修饰，如图：

 

  注解@SuppressWarnings用来压制程序中出来的警告，比如在没有用泛型或是方法已经过时的时候，
 如图：

 

注解@Retention可以用来修饰注解，是注解的注解，称为元注解。
Retention注解有一个属性value，是RetentionPolicy类型的，Enum RetentionPolicy是一个枚举类型，
这个枚举决定了Retention注解应该如何去保持，也可理解为Rentention 搭配 RententionPolicy使用。RetentionPolicy有3个值：CLASS  RUNTIME   SOURCE
用@Retention(RetentionPolicy.CLASS)修饰的注解，表示注解的信息被保留在class文件(字节码文件)中当程序编译时，但不会被虚拟机读取在运行的时候；
用@Retention(RetentionPolicy.SOURCE )修饰的注解,表示注解的信息会被编译器抛弃，不会留在class文件中，注解的信息只会留在源文件中；
用@Retention(RetentionPolicy.RUNTIME )修饰的注解，表示注解的信息被保留在class文件(字节码文件)中当程序编译时，会被虚拟机保留在运行时，
所以他们可以用反射的方式读取。RetentionPolicy.RUNTIME 可以让你从JVM中读取Annotation注解的信息，以便在分析程序的时候使用.

package com.self;  
import java.lang.annotation.Retention;  
import java.lang.annotation.RetentionPolicy;  
  
@Retention(RetentionPolicy.RUNTIME)  
public @interface MyTarget  
{ }  
定义个一注解@MyTarget，用RetentionPolicy.RUNTIME修饰；  
package com.self;  
import java.lang.reflect.Method;  
public class MyTargetTest  
{  
 @MyTarget  
 public void doSomething()  
 {  
  System.out.println("hello world");  
 }  
   
 public static void main(String[] args) throws Exception  
 {  
  Method method = MyTargetTest.class.getMethod("doSomething",null);  
  if(method.isAnnotationPresent(MyTarget.class))//如果doSomething方法上存在注解@MyTarget，则为true  
  {  
   System.out.println(method.getAnnotation(MyTarget.class));  
  }  
  }  
}  
上面程序打印：@com.self.MyTarget()，如果RetentionPolicy值不为RUNTIME,则不打印。  
  
 @Retention(RetentionPolicy.SOURCE )  
public @interface Override  
  
@Retention(RetentionPolicy.SOURCE )  
public @interface SuppressWarnings  
  
@Retention(RetentionPolicy.RUNTIME )  
public @interface Deprecated  
由上可以看出，只有注解@Deprecated在运行时可以被JVM读取到  
  
注解中可以定义属性，看例子：  
@Retention(RetentionPolicy.RUNTIME)  
public @interface MyAnnotation  
{  
 String hello() default "gege";  
  String world();  
  int[] array() default { 2, 4, 5, 6 };  
  EnumTest.TrafficLamp lamp() ;  
  TestAnnotation lannotation() default @TestAnnotation(value = "ddd");  
  Class style() default String.class;  
}  
上面程序中，定义一个注解@MyAnnotation，定义了6个属性，他们的名字为：  
hello,world,array,lamp,lannotation,style.  
属性hello类型为String,默认值为gege  
属性world类型为String,没有默认值  
属性array类型为数组,默认值为2，4，5，6  
属性lamp类型为一个枚举,没有默认值  
属性lannotation类型为注解,默认值为@TestAnnotation，注解里的属性是注解  
属性style类型为Class,默认值为String类型的Class类型  
  
看下面例子:定义了一个MyTest类，用注解@MyAnnotation修饰，注解@MyAnnotation定义的属性都赋了值  
@MyAnnotation(hello = "beijing", world="shanghai",array={},lamp=TrafficLamp.RED,style=int.class)  
public class MyTest  
{  
 @MyAnnotation(lannotation=@TestAnnotation(value="baby"), world = "shanghai",array={1,2,3},lamp=TrafficLamp.YELLOW)  
 @Deprecated  
 @SuppressWarnings("")  
 public void output()  
 {  
  System.out.println("output something!");  
 }  
}  
 接着通过反射读取注解的信息：  
public class MyReflection  
{  
 public static void main(String[] args) throws Exception  
 {  
  MyTest myTest = new MyTest();  
    Class<MyTest> c = MyTest.class;  
    Method method = c.getMethod("output", new Class[] {});  
       //如果MyTest类名上有注解@MyAnnotation修饰，则为true  
  if(MyTest.class.isAnnotationPresent(MyAnnotation.class))  
  {  
   System.out.println("have annotation");  
  }  
   if (method.isAnnotationPresent(MyAnnotation.class))  
   {  
   method.invoke(myTest, null); //调用output方法  
   //获取方法上注解@MyAnnotation的信息  
     MyAnnotation myAnnotation = method.getAnnotation(MyAnnotation.class);  
    String hello = myAnnotation.hello();  
   String world = myAnnotation.world();  
   System.out.println(hello + ", " + world);//打印属性hello和world的值  
   System.out.println(myAnnotation.array().length);//打印属性array数组的长度  
   System.out.println(myAnnotation.lannotation().value()); //打印属性lannotation的值  
   System.out.println(myAnnotation.style());  
   }  
    //得到output方法上的所有注解，当然是被RetentionPolicy.RUNTIME修饰的  
     Annotation[] annotations = method.getAnnotations();  
      for (Annotation annotation : annotations)  
  {  
   System.out.println(annotation.annotationType().getName());  
  }  
   }  
}  
上面程序打印：  
have annotation  
output something!  
gege, shanghai  
3  
baby  
class java.lang.String  
com.heima.annotation.MyAnnotation  
java.lang.Deprecated  
  
如果注解中有一个属性名字叫value,则在应用时可以省略属性名字不写。  
可见，@Retention(RetentionPolicy.RUNTIME )注解中，RetentionPolicy.RUNTIME是注解属性值，属性名字是value,  
属性的返回类型是RetentionPolicy，如下：  
public @interface MyTarget  
{  
    String value();  
}  
可以这样用：  
  @MyTarget("aaa")  
 public void doSomething()  
 {  
  System.out.println("hello world");  
 }  
   
注解@Target也是用来修饰注解的元注解，它有一个属性ElementType也是枚举类型，  
值为：ANNOTATION_TYPE CONSTRUCTOR  FIELD LOCAL_VARIABLE METHOD PACKAGE PARAMETER TYPE  
如@Target(ElementType.METHOD) 修饰的注解表示该注解只能用来修饰在方法上。  
@Target(ElementType.METHOD)  
@Retention(RetentionPolicy.RUNTIME)  
public @interface MyTarget  
{  
 String value() default "hahaha";  
}  
如把@MyTarget修饰在类上，则程序报错，如：  
@MyTarget  
public class MyTargetTest  
注解大都用在开发框架中吧，好了有关注解就学习那么多了，谢谢。

================中场休息

Java 注释类之常用元注解

自定义Java注释类时，我们使用方式如下：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
class @interface Author{
　　publicString name();
　　publicString company();
}

这次我们重点讨论修饰注解的注解，也就是我们说的元注解。

@Retention

注解@Retention可以用来修饰注解，是注解的注解，称为元注解。

Retention注解有一个属性value，是RetentionPolicy类型的，Enum RetentionPolicy是一个枚举类型， 
这个枚举决定了Retention注解应该如何去保持，也可理解为Rentention 搭配 RententionPolicy使用。

RetentionPolicy有3个值：CLASS,RUNTIME,SOURCE

• 用@Retention(RetentionPolicy.CLASS)修饰的注解，表示注解的信息被保留在class文件(字节码文件)中当程序编译时，但不会被虚拟机读取在运行的时候；
• 用@Retention(RetentionPolicy.SOURCE )修饰的注解,表示注解的信息会被编译器抛弃，不会留在class文件中，注解的信息只会留在源文件中；
• 用@Retention(RetentionPolicy.RUNTIME )修饰的注解，表示注解的信息被保留在class文件(字节码文件)中当程序编译时，会被虚拟机保留在运行时， 
  所以他们可以用反射的方式读取。

RetentionPolicy.RUNTIME 可以让你从JVM中读取Annotation注解的信息，以便在分析程序的时候使用.

---

@Target

注解@Target也是用来修饰注解的元注解。

它有一个属性ElementType也是枚举类型，值为：ANNOTATION_TYPE,CONSTRUCTOR,FIELD,LOCAL_VARIABLE,METHOD,PACKAGE,PARAMETER,TYPE

如@Target(ElementType.METHOD) 修饰的注解表示该注解只能用来修饰在方法上。 
其他同理。

================中场休息

总结一下

JPA 规范中，有关ORM关系映射的相关注释参考。

javax.persistence.Table 标注表

javax.persistence.SecondaryTable标注从表

javax.persistence.SecondaryTables 标注多个从表

javax.persistence.uniqueConstraints 标注唯一约束

javax.persistence.Column 标注列

javax.persistence.JoinColumn 标注关联列

javax.persistence.JoinColumns 标注多个关联列

javax.persistence.Id 标注主键

javax.persistence.GeneratedValue 标注生成键

javax.persistence.AttributeOverride 标注覆盖属性

javax.persistence.AttributeOverrides 标注多个覆盖属性

javax.persistence.AssociationOverride 标注关联覆盖列

javax.persistence.AssociationOverrides 标注多个关联覆盖列

javax.persistence.EmbeddedId 标注嵌入主键

javax.persistence.IdClass 标注主键类

javax.persistence.Transient 标注非持久化属性

javax.persistence.Version 标注版本

javax.persistence.Basic 标注基本属性

javax.persistence.Lob 标注Lob属性

javax.persistence.Temporal 标注日期时间类型

javax.persistence.Enumerated 标注枚举类型

javax.persistence.ManyToOne 标注多对一关系

javax.persistence.OneToOne 标注一对一关系

javax.persistence.OneToMany 标注一对多关系

javax.persistence.JoinTable 标注关联表

javax.persistence.ManyToMany 标注多对多关系

javax.persistence.MapKey 标注映射键值

javax.persistence.OrderBy 标注排序列

javax.persistence.Inheritance 标注继承关系

javax.persistence.DiscriminatorColumn 标注标识列

javax.persistence.DiscriminatorValue 标注标识列值

javax.persistence.PrimaryKeyJoinColumn 标注关联主键列

javax.persistence.PrimaryKeyJoinColumns 标注多个关联主键列

javax.persistence.Embeddable 标注可嵌入类

javax.persistence.Embedded 标注嵌入类

javax.persistence.MappedSuperclass 标注映射父类

javax.persistence.SequenceGenerator 标注Sequence生成策略

javax.persistence.TableGenerator 标注生成策略

除了 ORM 关系映射外，JPA规范中的其他注释

 javax.persistence.Entity 标注实体

 javax.persistence.ExcludeSuperclassListeners  标注排除父类实体监听器

 javax.persistence.ExcludedDefaultListeners  标注排除父类实体监听器

 javax.persistence.PrePersist 标注持久化前监听器

 javax.persistence.PostPersist 标注持久化后监听器

 javax.persistence.PreRemove 标注删除前监听器

 javax.persistence.PostRemove 标注删除后监听器

 javax.persistence.PreUpdate 标注更新前监听器

 javax.persistence.PostUpdate 标注更新后监听器

 javax.persistence.PosLoad 标注加载后监听器

 javax.persistence.NamedQuery 标注命名查询

 javax.persistence.QueryHint 标注命名查询提示

 javax.persistence.NamedQuerys 标注多个命名查询提示

 javax.persistence.NamedNativeQuery 标注本地命名查询

 javax.persistence.NamedNativeQuerys 标注多个本地命名查询

 javax.persistence.SqlResultSetMapping  标注查询结果映射

 javax.persistence.SqlResultSetMappings  标注多个查询结果映射

 javax.persistence.EntityResult  标注查询结果实体映射

 javax.persistence.FieldResult  标注查询结果属性映射

 javax.persistence.ColumnResult  标注查询结果列映射

 javax.persistence.PersistenceContext  标注持久化上下文

 javax.persistence.PersistenceProperty  标注持久化上下文属性

 javax.persistence.PersistenceContexts  标注多个持久化上下文属性

 javax.persistence.PersistenceUnit  标注持久化单元

 javax.persistence.PersistenceUnits  标注多个持久化单元