zoukankan      html  css  js  c++  java
  • Hibernate 注解

                                                                                        配置持久化类的常用注解

    1. @Entity

    将一个类声明为一个实体bean(即一个持久化POJO类)。

    2. @Table

    声明了该实体bean映射指定的表(table),目录(catalog)和schema名字

    3. @Id

    声明了该实体bean的标识属性(对应表中的主键)。

    4. @Column

    声明了属性到列的映射。该注解有如下的属性:

    name 可选,列名(默认值是属性名)

    unique 可选,是否在该列上设置唯一约束(默认值false)

    nullable 可选,是否设置该列的值可以为空(默认值false)

    insertable 可选,该列是否作为生成的insert语句中的一个列(默认值true)

    updatable 可选,该列是否作为生成的update语句中的一个列(默认值true)

    columnDefinition 可选,为这个特定列覆盖sql ddl片段(这可能导致无法在不同数据库间移植)

    table 可选,定义对应的表(默认为主表)

    length 可选,列长度(默认值255)

    precision 可选,列十进制精度(decimal precision)(默认值0)

    scale 可选,如果列十进制数值范围(decimal scale)可用,在此设置(默认值0)

    5. @GeneratedValue

    声明了主键的生成策略。该注解有如下属性:

    strategy 指定生成的策略(JPA定义的),这是一个GenerationType。默认是GenerationType. AUTO

    GenerationType.AUTO 主键由程序控制

    GenerationType.TABLE 使用一个特定的数据库表格来保存主键

    GenerationType.IDENTITY 主键由数据库自动生成(主要是自动增长类型)

    GenerationType.SEQUENCE 根据底层数据库的序列来生成主键,条件是数据库支持序列。这个值要与generator一起使用,generator 指定生成主键使用的生成器(可能是orcale中的序列)。

     6. SequenceGenerator

    声明了一个数据库序列。该注解有如下属性:

    name 表示该表主键生成策略名称,它被引用在@GeneratedValue中设置的“gernerator”值中

    sequenceName 表示生成策略用到的数据库序列名称。

    initialValue 表示主键初始值,默认为0。

    allocationSize 每次主键值增加的大小,例如设置成1,则表示每次创建新记录后自动加1,默认为50。

    7. GenericGenerator

    声明了一个hibernate的主键生成策略。支持十三种策略。该注解有如下属性:

    name 指定生成器名称。

    strategy 指定具体生成器的类名(指定生成策略)。

    parameters 得到strategy指定的具体生成器所用到的参数。

    其十三种策略(strategy属性的值)如下:

    ● native

    对于orcale采用Sequence方式,对于MySQL和SQL Server采用identity(处境主键生成机制),native就是将主键的生成工作将由数据库完成,hibernate不管(很常用)

    例:@GeneratedValue(generator = "paymentableGenerator")

           @GenericGenerator(name = "paymentableGenerator", strategy = "native")

    ● uuid

    采用128位的uuid算法生成主键,uuid被编码为一个32位16进制数字的字符串。占用空间大(字符串类型)。

    例:@GeneratedValue(generator = "paymentableGenerator")

           @GenericGenerator(name = "paymentableGenerator", strategy = "uuid")

    ● hilo

    要在数据库中建立一张额外的表,默认表名为hibernate_unque_key,默认字段为integer类型,名称是next_hi(比较少用)。

    例:@GeneratedValue(generator = "paymentableGenerator")

           @GenericGenerator(name = "paymentableGenerator", strategy = "hilo")

    ● assigned

    在插入数据的时候主键由程序处理(很常用),这是<generator>元素没有指定时的默认生成策略。等同于JPA中的AUTO。

    例:@GeneratedValue(generator = "paymentableGenerator")

           @GenericGenerator(name = "paymentableGenerator", strategy = "assigned")

    ● identity

    使用SQL Server和MySQL的自增字段,这个方法不能放到Oracle中,Oracle不支持自增字段,要设定sequence(MySQL和SQL Server中很常用)。等同于JPA中的IDENTITY

    例:@GeneratedValue(generator = "paymentableGenerator")

           @GenericGenerator(name = "paymentableGenerator", strategy = "identity")

    ● select

    使用触发器生成主键(主要用于早期的数据库主键生成机制,少用)

    例:@GeneratedValue(generator = "paymentableGenerator")

           @GenericGenerator(name = "paymentableGenerator", strategy = "select")

    ● sequence

    调用谨慎数据库的序列来生成主键,要设定序列名,不然hibernate无法找到。

    例:@GeneratedValue(generator = "paymentableGenerator")

           @GenericGenerator(name = "paymentableGenerator", strategy = "sequence", parameters = { @Parameter(name = "sequence", value = "seq_payablemoney") }) 

    ● seqhilo

    通过hilo算法实现,但是主键历史保存在Sequence中,适用于支持Sequence的数据库,如Orcale(比较少用)。

    例:@GeneratedValue(generator = "paymentableGenerator")

           @GenericGenerator(name = "paymentableGenerator", strategy = "seqhilo", parameters = { @Parameter(name = "max_lo", value = "5") }) 

    ● increnment

    插入数据的时候hibernate会给主键添加一个自增的主键,但是一个hibernate实例就维护一个计数器,所以在多个实例运行的时候不能使用这个方法。

    例:@GeneratedValue(generator = "paymentableGenerator")

           @GenericGenerator(name = "paymentableGenerator", strategy = "increnment")

    ● foreign

    使用另一个相关的对象的主键。通常和@OneToOne联合起来使用。

    例:@Id

           @GeneratedValue(generator = "idGenerator")

           @GenericGenerator(name = "idGenerator", strategy = "foreign", parameters = { @Parameter(name = "property", value = "info") })

           Integer id;

           @OneToOne

           EmployeeInfo info;

    ● guid

    采用数据库底层的guid算法机制,对应MySQL的uuid()函数,SQL Server的newid()函数,ORCALE的rawtohex(sys_guid())函数等。

    例:@GeneratedValue(generator = "paymentableGenerator")

           @GenericGenerator(name = "paymentableGenerator", strategy = "guid")

    ● uuid.hex

    参见uuid,建议用uuid替换。

    ● sequence-identity

    sequence策略的扩展,采用立即检索策略来获取sequence值,需要JDBC3.0和JDK4以上(含1.4)版本。

    例:@GeneratedValue(generator = "paymentableGenerator")

           @GenericGenerator(name = "paymentableGenerator", strategy = "sequence-identity", parameters = { @Parameter(name = "sequence", value = "seq_payablemoney") })

     8. @Transient

    声明了非持久化属性,即数据库中没有相应的映射字段,是一个普通属性。

    9. @Temporal

    声明了日期类型。

    TemporalType.DATE 日期,例:2011-04-12

    TemporalType.TIME 时间,例:22:50:30

    TemporalType.TIMESTAMP 日期和时间,例:2011-04-12 22:51:30

    10. @Version

    声明了对乐观锁定的支持

    例:@Version

           @Column(name="OPTLOCK")

           public Integer getVersion() { ... }

    上面这个例子中,version属性将映射到 OPTLOCK列,entity manager使用该字段来检测更新冲突(防止更新丢失,请参考last-commit-wins策略)。

    根据EJB3规范,version列可以是numeric类型(推荐方式)也可以是timestamp类型。Hibernate支持任何自定义类型,只要该类型实现了UserVersionType。

    注解配置对象关联关系示例:

    大配置关联各个持久化类:

            <!--一对一双向-->
            <mapping class="cn.happy.ontoondouble.Emp"/>
            <mapping class="cn.happy.ontoondouble.IdCard"/>
    
            <!--一对多双向-->
            <mapping class="cn.happy.onetomanydouble.Dept"/>
            <mapping class="cn.happy.onetomanydouble.Emp"/>
    
            <!--多对多双向-->
            <mapping class="cn.happy.manytomanydouble.Game"/>
            <mapping class="cn.happy.manytomanydouble.PlayerHome"/>

    1.一对一双向

    Emp(员工类):

    package cn.happy.ontoondouble;
    import javax.persistence.*;
    
    
    /**
     * Created by CKW on 2017/2/4.
     */
    @Entity
    @Table(name="EMP1")
    public class Emp{
    
        private Integer empno;
        @Column
        private String empname;
        private IdCard idCard;
        @OneToOne
        @JoinColumn(name = "iid")
        public IdCard getIdCard() {
            return idCard;
        }
    
        public void setIdCard(IdCard idCard) {
            this.idCard = idCard;
        }
    
        @Id
        @GeneratedValue
        public Integer getEmpno() {
            return empno;
        }
    
        public void setEmpno(Integer empno) {
            this.empno = empno;
        }
    
        public String getEmpname() {
            return empname;
        }
    
        public void setEmpname(String empname) {
            this.empname = empname;
        }
    
    
    }
    IdCard(身份证类):
    package cn.happy.ontoondouble;
    
    import javax.persistence.*;
    
    /**
     * Created by CKW on 2017/2/16.
     */
    @Entity
    @Table(name = "IDCARD1")
    public class IdCard {
        @Id
        @GeneratedValue
        private Integer iid;
        private String inum;
        @OneToOne(mappedBy = "idCard",cascade = CascadeType.ALL)
        private Emp emp;
    
        public Integer getIid() {
            return iid;
        }
    
        public void setIid(Integer iid) {
            this.iid = iid;
        }
    
        public String getInum() {
            return inum;
        }
    
        public void setInum(String inum) {
            this.inum = inum;
        }
    
        public Emp getEmp() {
            return emp;
        }
    
        public void setEmp(Emp emp) {
            this.emp = emp;
        }
    }

    测试类:

    package cn.happy.onetoeonedoubletest;
    
    import cn.happy.ontoondouble.Emp;
    import cn.happy.ontoondouble.IdCard;
    import org.hibernate.Session;
    import org.hibernate.SessionFactory;
    import org.hibernate.Transaction;
    import org.hibernate.cfg.Configuration;
    import org.junit.After;
    import org.junit.Before;
    import org.junit.Test;
    
    /**
     * Created by CKW on 2017/2/16.
     */
    public class annTest {
    
        Configuration cfg;
        Session session;
        Transaction tx;
        @Before
        public void myBefore(){
            //创建配置对象
            cfg=new Configuration().configure("Hibernate2.cfg.xml");
    
            // 2.根据配置对象创建SessionFactory
            SessionFactory factory=cfg.buildSessionFactory();
    
            //3.根据SessionFactory去创建Session
            session= factory.getCurrentSession();
    
            //3.5在Session创建后开启事务   xxx0001    xxxxx003
            tx= session.beginTransaction();
    
        }
    
        @After
        public void myAfter(){
            //5.提交事务
            tx.commit();
        }
    
        @Test
        public void test1(){
            Emp emp=new Emp();
            emp.setEmpname("哈士奇");
    
            IdCard idCard=new IdCard();
            idCard.setInum("351579542612452163");
            idCard.setEmp(emp);
    
            emp.setIdCard(idCard);
            session.save(idCard);
        }
    
    }

    2.一对多双向

    Dept(部门类):

    package cn.happy.onetomanydouble;
    
    import javax.persistence.*;
    import java.util.HashSet;
    import java.util.Set;
    
    @Entity
    //@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
    @Table(name = "Dept2")
    /**
     * Created by CKW on 2017/2/16.
     */
    public class Dept {
        @Id
        @GeneratedValue
        private Integer did;
        @Column
        private String dname;
        @OneToMany(mappedBy = "dept",cascade = CascadeType.ALL,fetch = FetchType.LAZY)
        //@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
        private Set<Emp> emps=new HashSet<Emp>();
    
        public Integer getDid() {
            return did;
        }
    
        public void setDid(Integer did) {
            this.did = did;
        }
    
        public String getDname() {
            return dname;
        }
    
        public void setDname(String dname) {
            this.dname = dname;
        }
    
        public Set<Emp> getEmps() {
            return emps;
        }
    
        public void setEmps(Set<Emp> emps) {
            this.emps = emps;
        }
    }

    Emp(员工类):

    package cn.happy.onetomanydouble;
    
    import javax.persistence.*;
    
    @Entity
    @Table(name = "Emp2")
    /**
     * Created by CKW on 2017/2/16.
     */
    public class Emp {
        @Id
        @GeneratedValue
        private Integer eid;
        @Column
        private String name;
        @ManyToOne
        @JoinColumn(name = "did")
        private Dept dept;
    
        public Integer getEid() {
            return eid;
        }
    
        public void setEid(Integer eid) {
            this.eid = eid;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Dept getDept() {
            return dept;
        }
    
        public void setDept(Dept dept) {
            this.dept = dept;
        }
    }

    测试类:

       @Test
        public void test1(){
            Emp emp=new Emp();
            emp.setName("哈士奇");
    
            Dept dept=new Dept();
            dept.setDname("财务部");
    
            dept.getEmps().add(emp);
            emp.setDept(dept);
            
            session.save(dept);
    
        }

    3.多对多双向

    Game(游戏类):

    package cn.happy.manytomanydouble;
    
    import javax.persistence.*;
    import java.util.HashSet;
    import java.util.Set;
    
    @Entity
    @Table(name = "Game")
    /**
     * Created by CKW on 2017/2/16.
     */
    public class Game {
        @Id
        @GeneratedValue(strategy = GenerationType.SEQUENCE,generator = "sql_Game")
        @SequenceGenerator(name = "sql_Game",sequenceName = "sql_Game",allocationSize = 1,initialValue = 1)
        private Integer gid;
        @Column
        private String gname;
        @ManyToMany(cascade = CascadeType.ALL)
        @JoinTable(name = "PG",joinColumns = {@JoinColumn(name = "gid")},inverseJoinColumns = {@JoinColumn(name = "pid")})
        private Set<PlayerHome> playerHomes=new HashSet<PlayerHome>();
    
        public Integer getGid() {
            return gid;
        }
    
        public void setGid(Integer gid) {
            this.gid = gid;
        }
    
        public String getGname() {
            return gname;
        }
    
        public void setGname(String gname) {
            this.gname = gname;
        }
    
        public Set<PlayerHome> getPlayerHomes() {
            return playerHomes;
        }
    
        public void setPlayerHomes(Set<PlayerHome> playerHomes) {
            this.playerHomes = playerHomes;
        }
    }

    PlayerHOME(玩家类):

    package cn.happy.manytomanydouble;
    
    import javax.persistence.*;
    import java.util.HashSet;
    import java.util.Set;
    
    @Entity
    @Table(name = "PlayerHome")
    /**
     * Created by CKW on 2017/2/16.
     */
    public class PlayerHome {
        @Id
        @GeneratedValue(strategy = GenerationType.SEQUENCE,generator = "sql_PlayerHome")
        @SequenceGenerator(name = "sql_PlayerHome",sequenceName = "sql_PlayerHome",allocationSize = 1,initialValue = 1)
        private Integer pid;
        @Column
        private String pname;
        @ManyToMany(cascade = CascadeType.ALL,mappedBy = "playerHomes")
        private Set<Game> games=new HashSet<Game>();
    
        public Integer getPid() {
            return pid;
        }
    
        public void setPid(Integer pid) {
            this.pid = pid;
        }
    
        public String getPname() {
            return pname;
        }
    
        public void setPname(String pname) {
            this.pname = pname;
        }
    
        public Set<Game> getGames() {
            return games;
        }
    
        public void setGames(Set<Game> games) {
            this.games = games;
        }
    }

    测试类:

       @Test
        public void myTest(){
            PlayerHome playerHome=new PlayerHome();
            playerHome.setPname("");
            PlayerHome playerHome1=new PlayerHome();
            playerHome1.setPname("");
    
            Game game=new Game();
            game.setGname("CS");
            Game game1=new Game();
            game1.setGname("CF");
    
            playerHome.getGames().add(game);
            playerHome.getGames().add(game1);
            playerHome1.getGames().add(game);
            playerHome1.getGames().add(game1);
    
            game.getPlayerHomes().add(playerHome);
            game.getPlayerHomes().add(playerHome1);
            game1.getPlayerHomes().add(playerHome);
            game1.getPlayerHomes().add(playerHome1);
    
            session.save(game);
            session.save(game1);
    
        }
  • 相关阅读:
    常用 Git 命令清单
    谈谈关于PHP的代码安全相关的一些致命知识
    九个Console命令,让 JS 调试更简单
    有趣的博客小工具
    利用fputcsv导出数据备份数据
    IT小天博客APP版本
    七牛云存储文件批量下载工具使用教程
    Mysql的常见几种错误:1045,1044
    我是一个线程
    两行代码快速创建一个iOS主流UI框架
  • 原文地址:https://www.cnblogs.com/ckwblogs/p/6405322.html
Copyright © 2011-2022 走看看