zoukankan      html  css  js  c++  java

  • 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 }

    参考资料：http://www.cnblogs.com/chenssy/p/3149210.html

    @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" />  
  • 相关阅读:
    工作的思考十七：工作中容易犯的错误
    学习之路三十四：再一次重构缓存设计
    学习之路三十五：Android和WCF通信
    学习之路二十：两周工作技术总结
    学习之路三十三：重构技巧的学习
    工作的思考十五：升职前需要做的准备（TeamLeader）
    学习之路三十二：VS调试的简单技巧
    maven pom
    maven环境配置
    maven的背景
  • 原文地址：https://www.cnblogs.com/hoojjack/p/6568920.html
Copyright © 2011-2022 走看看