就像@Table注解用来标识实体类与数据表的对应关系类似，@Column注解来标识实体类中属性与数据表中字段的对应关系。

该注解的定义如下：

@Target({METHOD, FIELD}) @Retention(RUNTIME)

public @interface Column {

String name() default "";

boolean unique() default false;

boolean nullable() default true;

boolean insertable() default true;

boolean updatable() default true;

String columnDefinition() default "";

String table() default "";

int length() default 255;

int precision() default 0;

int scale() default 0;

}

从定义可以看出，@Column注解一共有10个属性，这10个属性均为可选属性，各属性含义分别如下：

name

name属性定义了被标注字段在数据库表中所对应字段的名称；

unique

unique属性表示该字段是否为唯一标识，默认为false。如果表中有一个字段需要唯一标识，则既可以使用该标记，也可以使用@Table标记中的@UniqueConstraint。

nullable

nullable属性表示该字段是否可以为null值，默认为true。

insertable

insertable属性表示在使用“INSERT”脚本插入数据时，是否需要插入该字段的值。

updatable

updatable属性表示在使用“UPDATE”脚本插入数据时，是否需要更新该字段的值。insertable和updatable属性一般多用于只读的属性，例如主键和外键等。这些字段的值通常是自动生成的。

columnDefinition

columnDefinition属性表示创建表时，该字段创建的SQL语句，一般用于通过Entity生成表定义时使用。（也就是说，如果DB中表已经建好，该属性没有必要使用。）

table

table属性定义了包含当前字段的表名。

length

length属性表示字段的长度，当字段的类型为varchar时，该属性才有效，默认为255个字符。

precision和scale

precision属性和scale属性表示精度，当字段类型为double时，precision表示数值的总长度，scale表示小数点所占的位数。

API文档地址： http://docs.oracle.com/javaee/5/api/javax/persistence/Column.html

在使用此@Column标记时，需要注意以下几个问题：

此标记可以标注在getter方法或属性前，例如以下的两种标注方法都是正确的：

标注在属性前：

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.Table;

@Entity

@Table(name = "contact")

public class ContactEO {

@Column(name = " contact_name ")

private String name;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

}

标注在getter方法前：

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.Table;

@Entity

@Table(name = "contact")

public class ContactEO {

private String name;

@Column(name = " contact_name ")

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

}

提示：JPA规范中并没有明确指定那种标注方法，只要两种标注方式任选其一都可以。这根据个人的喜好来选择，笔者习惯使用第二种方法。

下面举几个小例子：

示例一：指定字段“contact_name”的长度是“512”，并且值不能为null。

private String name;

@Column(name="contact_name",nullable=false,length=512)

public String getName() {

return name;

}

创建的SQL语句如下所示。

CREATE TABLE contact (

id integer not null,

contact_name varchar (512) not null,

primary key (id)

)

示例二：指定字段“monthly_income”月收入的类型为double型，精度为12位，小数点位数为2位。

private BigDecimal monthlyIncome;

@Column(name="monthly_income",precision=12, scale=2)

public BigDecimal getMonthlyIncome() {

return monthlyIncome;

}

创建的SQL语句如下所示。

CREATE TABLE contact (

id integer not null,

monthly_income double(12,2),

primary key (id)

)

示例三：自定义生成CLOB类型字段的SQL语句。

private String name;

@Column(name=" contact_name ",columnDefinition="clob not null")

public String getName() {

return name;

}

生成表的定义SQL语句如下所示。

CREATE TABLE contact (

id integer not null,

contact_name clob (200) not null,

primary key (id)

)

其中，加粗的部分为columnDefinition属性设置的值。若不指定该属性，通常使用默认的类型建表，若此时需要自定义建表的类型时，可在该属性中设置。

提示：通过Entity定义生成表，还是通过表配置Entity，这是两种不同的ORM策略。

示例四：字段值为只读的，不允许插入和修改。通常用于主键和外键。

private Integer id;

@Column(name="id",insertable=false,updatable=false)

public Integer getId() {

return id;

}

Spring中常用的注解（@Entity，@Table，@Column，@Repository，@Service）

当项目变得比较大的时候，如何还使用hbm.xml文件来配置Hibernate实体就会变得比较复杂。这里Hibernate提供了Annotation注解方式，使得Hibernate的映射文件变得很方便管理了。

这里简单介绍Hibernate的Annotation注解

一、声明实体

@Entity

对实体注释。任何Hibernate映射对象都要有这个注释

@Table

声明此对象映射到数据库的数据表，通过它可以为实体指定表(talbe),目录(Catalog)和schema的名字。该注释不是必须的，如果没有则系统使用默认值(实体的短类名)。

@Version

该注释可用于在实体Bean中添加乐观锁支持。

二、声明主键

@Id

声明此属性为主键。该属性值可以通过应该自身创建，但是Hibernate推荐通过Hibernate生成

@GeneratedValue

指定主键的生成策略。有如下四个值

TABLE：使用表保存id值

IDENTITY：identitycolumn

SEQUENCR ：sequence

AUTO：根据数据库的不同使用上面三个

三、声明普通属性

@Column

声明该属性与数据库字段的映射关系。

1 @Column(nam=”category_name” length=20)
2 Public void getCategoryName(){
3 Return this.categoryName;
4 }

注意：

1、 当POJO有属性不需要映射的时候一定要用@Transitent修饰，该注释表示此属性与表没有映射关系，只是一个暂时的属性。

2、 @Lob注释表示该属性持久化为Blob或者Clob类型，具体取决于属性的类型。

四、声明关联关系

一对多关联关系

@OneToMany(mappedBy=” person”,cascade=CascadeType.ALL,fetch=FetchType.LAZY)

一对多声明

@ManyToOne(cascade=CascadeType.REFRESH,)

@JoinColumn

多对一声明 ,声明为双向关联

一对一关联关系

@OneToOne(optional= true,cascade =CascadeType.ALL, mappedBy = “person”)

一对一关联声明

@OneToOne(optional = false, cascade = CascadeType.REFRESH)

@JoinColumn(name = “Person_ID”, referencedColumnName = “personid”,unique = true)

声明为双向关联

多对多关联关系

@ManyToMany(mappedBy= “students”)

多对多关联声明。

@ManyToMany(cascade = CascadeType.PERSIST, fetch = FetchType.LAZY)

@JoinTable(name = “Teacher_Student”,

joinColumns = {@JoinColumn(name = “Teacher_ID”, referencedColumnName =“teacherid”)},

inverseJoinColumns = {@JoinColumn(name = “Student_ID”, referencedColumnName =“studentid”)})

实例：

有如下两个实体，商品:Goods，分类Category。两者是多对一的关联关系。

使用Hibernate Annotation注解如下

1 Goods.java
 2 
 3 @Entity
 4 @Table(name = "goods", catalog = "test")
 5 public class Goods implements java.io.Serializable {
 6 
 7 private static final long serialVersionUID = 1L;
 8 private String goodsId;
 9 private Category category;
10 private String goodsName;
11 
12 public Goods() {
13 }
14 
15 /*
16 * 主键
17 * 生成策略为自动增长
18 * 唯一、长度为20
19 */
20 @Id
21 @GeneratedValue
22 @Column(name = "goods_id", unique = true, nullable = false, length = 20)
23 public String getGoodsId() {
24 return this.goodsId;
25 }
26 
27 public void setGoodsId(String goodsId) {
28 this.goodsId = goodsId;
29 }
30 
31 /*
32 * 多对一关联关系
33 * 延迟加载：fetch = FetchType.LAZY
34 * 引用外键：category_id
35 * 
36 */
37 @ManyToOne(fetch = FetchType.LAZY,cascade=CascadeType.ALL)
38 @JoinColumn(name = "category_id")
39 public Category getCategory() {
40 return this.category;
41 }
42 
43 public void setCategory(Category category) {
44 this.category = category;
45 }
46 
47 @Column(name = "goods_name", nullable = false, length = 50)
48 public String getGoodsName() {
49 return this.goodsName;
50 }
51 
52 public void setGoodsName(String goodsName) {
53 this.goodsName = goodsName;
54 }
55 
56 }

Category.java

1 @Entity
 2 @Table(name = "category", catalog = "test")
 3 public class Category implements java.io.Serializable {
 4 
 5 private static final long serialVersionUID = -1877960009126534682L;
 6 
 7 private String categoryId;
 8 private String categoryName;
 9 private Set<Goods> goodses = new HashSet<Goods>(0);
10 
11 public Category() {
12 }
13 
14 /*
15 * 主键
16 * 生成策略为自动增长
17 * 唯一、长度为20
18 */
19 @Id
20 @GeneratedValue
21 @Column(name = "category_id", unique = true, length = 10)
22 public String getCategoryId() {
23 return this.categoryId;
24 }
25 
26 public void setCategoryId(String categoryId) {
27 this.categoryId = categoryId;
28 }
29 
30 @Column(name = "category_name", length = 20)
31 public String getCategoryName() {
32 return this.categoryName;
33 }
34 
35 public void setCategoryName(String categoryName) {
36 this.categoryName = categoryName;
37 }
38 
39 /*
40 * 一对多关联关系
41 * 级联关系：cascade=CascadeType.ALL
42 * 延迟加载：fetch = FetchType.LAZY
43 * 映射：mappedBy = "category"
44 */
45 @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "category")
46 public Set<Goods> getGoodses() {
47 return this.goodses;
48 }
49 
50 public void setGoodses(Set<Goods> goodses) {
51 this.goodses = goodses;
52 }
53 
54 }

@Repository

spring 自 2.0 版本开始，陆续引入了一些注解用于简化 Spring 的开发。@Repository注解便属于最先引入的一批，它用于将数据访问层 (DAO 层 ) 的类标识为 Spring Bean。具体只需将该注解标注在 DAO类上即可。同时，为了让 Spring 能够扫描类路径中的类并识别出 @Repository 注解，需要在 XML 配置文件中启用Bean 的自动扫描功能，这可以通过<context:component-scan/>实现。如下所示：

1 // 首先使用 @Repository 将 DAO 类声明为 Bean 
 2 package bookstore.dao; 
 3 @Repository 
 4 public class UserDaoImpl implements UserDao{ …… } 
 5 
 6 // 其次，在 XML 配置文件中启动 Spring 的自动扫描功能
 7 <beans … > 
 8 ……
 9 <context:component-scan base-package=”bookstore.dao” /> 
10 ……
11 </beans>

如此，我们就不再需要在 XML 中显式使用 <bean/> 进行Bean 的配置。Spring 在容器初始化时将自动扫描 base-package 指定的包及其子包下的所有 class文件，所有标注了 @Repository 的类都将被注册为 Spring Bean。

为什么 @Repository 只能标注在 DAO 类上呢？这是因为该注解的作用不只是将类识别为Bean，同时它还能将所标注的类中抛出的数据访问异常封装为 Spring 的数据访问异常类型。 Spring本身提供了一个丰富的并且是与具体的数据访问技术无关的数据访问异常结构，用于封装不同的持久层框架抛出的异常，使得异常独立于底层的框架。

@Service、@Controller 和 @Component 将类标识为Bean

Spring 2.5 在 @Repository的基础上增加了功能类似的额外三个注解：@Component、@Service、@Constroller，它们分别用于软件系统的不同层次：

• @Component 是一个泛化的概念，仅仅表示一个组件 (Bean) ，可以作用在任何层次。
• @Service 通常作用在业务层，但是目前该功能与 @Component 相同。
• @Constroller 通常作用在控制层，但是目前该功能与 @Component 相同。

通过在类上使用 @Repository、@Component、@Service 和 @Constroller 注解，Spring会自动创建相应的 BeanDefinition 对象，并注册到 ApplicationContext 中。这些类就成了 Spring受管组件。这三个注解除了作用于不同软件层次的类，其使用方式与 @Repository 是完全相同的。

另外，除了上面的四个注解外，用户可以创建自定义的注解，然后在注解上标注 @Component，那么，该自定义注解便具有了与所@Component 相同的功能。不过这个功能并不常用。

当一个 Bean 被自动检测到时，会根据那个扫描器的 BeanNameGenerator 策略生成它的 bean名称。默认情况下，对于包含 name 属性的 @Component、@Repository、 @Service 和@Controller，会把 name 取值作为 Bean 的名字。如果这个注解不包含 name值或是其他被自定义过滤器发现的组件，默认 Bean 名称会是小写开头的非限定类名。如果你不想使用默认 bean命名策略，可以提供一个自定义的命名策略。首先实现 BeanNameGenerator接口，确认包含了一个默认的无参数构造方法。然后在配置扫描器时提供一个全限定类名，如下所示：

<beans ...> <context:component-scan base-package="a.b" name-generator="a.SimpleNameGenerator"/> </beans>

与通过 XML 配置的 Spring Bean 一样，通过上述注解标识的Bean，其默认作用域是"singleton"，为了配合这四个注解，在标注 Bean 的同时能够指定 Bean 的作用域，Spring2.5 引入了 @Scope 注解。使用该注解时只需提供作用域的名称就行了，如下所示：

@Scope("prototype") @Repository public class Demo { … }

如果你想提供一个自定义的作用域解析策略而不使用基于注解的方法，只需实现 ScopeMetadataResolver接口，确认包含一个默认的没有参数的构造方法。然后在配置扫描器时提供全限定类名：

 <context:component-scan base-package="a.b" scope-resolver="footmark.SimpleScopeResolver" />