hibernate 常用1

ccccccccccccccccc关联 hibernate --------------------编程问答-------------------- ** 人－实体类 */

public class Person {

    private int id;

    private String name;

    public int getId() {return id;  }

    public void setId(int id) {this.id = id;}

    public String getName() {return name;}

    public void setName(Stringname) {this.name = name;}

}

/**身份证-实体类*/

public class IdCard {

    private int id;

    private String cardNo;

    public int getId() {return id;}

    public void setId(int id) {this.id = id;}

    public String getCardNo(){ return cardNo;}

    public void setCardNo(StringcardNo) {this.cardNo = cardNo;}

}

一对一关联映射

2        两个对象之间是一对一的关系，如Person-IdCard(人—身份证号)

2        有两种策略可以实现一对一的关联映射

?        主键关联：即让两个对象具有相同的主键值，以表明它们之间的一一对应的关系；数据库表不会有额外的字段来维护它们之间的关系，仅通过表的主键来关联。

?        唯一外键关联：外键关联，本来是用于多对一的配置（增加了外键），但是如果加上唯一的限制之后，也可以用来表示一对一关联关系

一）唯一外键关联-单向(unilateralism)

1、说明：

人—-> 身份证号(PersonàIdCard)，从IdCard看不到Person对象
6、 annotateon注解映射

注意IdCard是被引用对象，除正常注解，无需要其它注解

/**身份证*/

@Entity

public class IdCard {

  private int id;

  private String cardNo;

  @Id

  @GeneratedValue

  public int getId() {return id;}

  public void setId(int id) { this.id = id;}

  public String getCardNo(){return cardNo;}

  public void setCardNo(StringcardNo) {this.cardNo = cardNo;}

}

而引用对象的实体类需要使用@OneToOne进行注解，来表面是一对一的关系

再使用@JoinColumn注解来为数据库表中这个外键指定个字段名称就可以了。如果省略@JoinColumn注解，则hibernate会自动为其生成一个字段名(好像是：被引用对象名称_被引用对象的主键ID)

/** 人－实体类 */

@Entity

public class Person {

  private int id;

  private IdCard idCard;//引用IdCard对象

  private String name;

  @Id

  @GeneratedValue

  public int getId() {return id;}

  @OneToOne//表示一对一的关系

  @JoinColumn(name="idCard")//为数据中的外键指定个名称

  public IdCard getIdCard(){ return idCard;}

  public String getName() {return name;}

  public void setId(int id) {this.id = id;}

  public void setIdCard(IdCardidCard) {this.idCard = idCard;}

  public void setName(Stringname) {this.name = name;}

}
生成的SQL语句：

    create tableIdCard (

        id integernot null auto_increment,

        cardNo varchar(255),

        primary key(id)

    )

    create tablePerson (

        id integernot null auto_increment,

        namevarchar(255),

        idCardinteger,//新添加的外键

        primary key(id)

    )
二) 唯一外键关联-双向
1、说明：

人<—-> 身份证号(Person<->IdCard)双向：互相持有对方的引用
6、 annotateon注解映射

Person注解映射同单向一样

IdCard注解映射如下：使用@OneToOne注解来一对一，但这样会在类中多加一个字段，因为需要使用对象的外键来加载数据，所以使用属性mappedBy属性在实现这个功能

@Entity

public class IdCard {

  private int id;

  private String cardNo;

  private Person person;

  //mappedBy：在指定当前对象在被Person对象的idCard做了映射了

  //此值：当前对象持有引用对象中引用当前对象的成员属性名称(getXXX后的名称)

  //因为Person对象的持有IdCard对象的方法是getIdCard()因为需要小写,所以为idCard

  @OneToOne(mappedBy="idCard")

  public Person getPerson(){return person;}

  public void setPerson(Person person){this.person = person;}

  @Id

  @GeneratedValue

  public int getId() {return id;}

  public void setId(int id) { this.id = id;}

  public String getCardNo(){return cardNo;}

  public void setCardNo(StringcardNo) {this.cardNo = cardNo;}

}

7、生成SQL语句

因为关系模型没有变化，也就是数据库的结构没有变化，只是在数据加载时需要相互加载对方，这由hibernate来完成。因为生成的sql语句同单向一样

8、存储测试

存储同单向一样

9、总结：

规律：凡是双向关联，必设mappedBy
(三) 主键关联-单向(不重要)
主键关联：即让两个对象具有相同的主键值，以表明它们之间的一一对应的关系；数据库表不会有额外的字段来维护它们之间的关系，仅通过表的主键来关联。
3、关系模型

因为是person引用idcard，所以idcard要求先有值。而person的主键值不是自己生成的。而是参考idcard的值，person表中即是主键，同时也是外键
6、 annotateon注解映射

Person实体类注解

方法：只需要使用@OneToOne注解一对一关系，再使用@PrimaryKeyJoinColumn来注解主键关系映射。

@Entity

public class Person {

    private int id;

    private IdCard idCard;//引用IdCard对象

    private String name;

    @Id

    public int getId() {return id;}

    @OneToOne//表示一对一的关系

    @PrimaryKeyJoinColumn//注解主键关联映射

    public IdCard getIdCard(){ return idCard;}

    public String getName() {return name;}

    public void setId(int id) {this.id = id;}

    public void setIdCard(IdCard idCard){this.idCard = idCard;}

    public void setName(Stringname) {this.name = name;}

}
IdCard实体类，不需要持有对象的引用，正常注解就可以了。
7、生成SQL语句

生成的两个表并没有多余的字段，因为是通过主键在关键的

    create tableIdCard (

        id integernot null auto_increment,

        cardNovarchar(255),

        primary key (id)

    )

    create tablePerson (

        id integernot null,

        namevarchar(255),

        primary key(id)

  ) --------------------编程问答-------------------- (四) 主键关联-双向(不重要)

主键关联：即让两个对象具有相同的主键值，以表明它们之间的一一对应的关系；数据库表不会有额外的字段来维护它们之间的关系，仅通过表的主键来关联。
2、 annotateon注解映射：

Person的注解不变，同主键单向注解

IdCard注解，只需要在持有对象引用的getXXX前加上

        @OneToOne(mappedBy="idCard") 如下：

@Entity

public class IdCard {

    private int id;

    private String cardNo;

    private Person person;

    @OneToOne(mappedBy="idCard")

    public Person getPerson(){

        return person;

    }}

三、       多对一 –单向

场景：用户和组；从用户角度来，多个用户属于一个组(多对一关联)

六) annotation

Group(一的一端)注解只需要正常的注解就可以了，因为在实体类中它是被引用的。

     User*(多的一端)：@ManyToOne来注解多一对的关键，并且用@JoinColumn来指定外键的字段名

@Entity

public class User {

  private int id;

  private String name;

  private Group group;

  @ManyToOne

  @JoinColumn(name="groupId")

  public Group getGroup() {

      return group;

  }create table t_group (id integer not nullauto_increment, name varchar(255), primary key (id))

create table t_user (id integer not nullauto_increment, name varchar(255), groupid integer,primary key (id))

  八) 重要属性-cascade(级联)：

    级联的意思是指定两个对象之间的操作联运关系，对一个对象执行了操作之后，对其指定的级联对象也需要执行相同的操作，取值：all、none、save_update、delete

1、    all：代码在所有的情况下都执行级联操作

2、    none:在所有情况下都不执行级联操作

3、    save-update：在保存和更新的时候执行级联操作

4、    delete：在删除的时候执行级联操作。

(九) 多对一  加载数据
可以加载Group信息：因为采用了<many-to-one>这个标签，这个标签会在多的一端(User)加一个外键，指向一的一端(Group)，也就是它维护了从多到一的这种关系，多指向一的关系。当你加载多一端的数据时，它就能把一的这一端数据加载上来。当加载User对象后hibernate会根据User对象中的groupid再来加载Group信息给User对象中的group属性。

四、       一对多 - 单向

在对象模型中，一对多的关联关系，使用集合来表示
(六) annotateon注解

一对多多的一端只需要正常注解就可以了。

需要在一的一端进行注解一对多的关系。

使用@OneToMany

@Entity

public class Classes {

    private int id;

    private String name;



    // 一对多通常使用Set来映射，Set是不可重复内容。

    // 注意使用Set这个接口，不要使用HashSet,因为hibernate有延迟加载，

    private Set<Student>students = new HashSet<Student>();

    @OneToMany//进行注解为一对多的关系

    @JoinColumn(name="classesId")//在多的一端注解一个字段(名为classessid)

    public Set<Student>getStudents() {

        return students;

}

(七) 导出至数据库(hbmàddl)生成的SQL语句：

create table t_classes (id integer not null auto_increment, namevarchar(255), primary key (id))

create table t_student (id integer not null auto_increment, namevarchar(255), classesid integer, primary key (id))

一对多多对一数据库表的外键是一样的只是java对象表示不同

五、       一对多 - 双向
如果在一对多的映射关系中采用一的一端来维护关系的话会存在以下两个缺点：①如果多的一端那个外键设置为非空时，则多的一端就存不进数据；②会发出多于的Update语句，这样会影响效率。所以常用对于一对多的映射关系我们在多的一端维护关系，并让多的一端维护关系失效(见下面属性)。
@Entity

public class Student {

    private int id;

    private String name;

    private Classes classes;



    @ManyToOne

    @JoinColumn(name="classesId")

    public ClassesgetClasses() {

        return classes;

    }

一的一端

@Entity

public class Classes {

    private int id;

    private String name;

    // 一对多通常使用Set来映射，Set是不可重复内容。

    // 注意使用Set这个接口，不要使用HashSet,因为hibernate有延迟加载，

    private Set<Student>students = new HashSet<Student>();

    @OneToMany(mappedBy="classes")//进行注解为一对多的关系

    public Set<Student>getStudents() {

        return students;}

(三) 数据保存：

一对多数据保存，从多的一端进行保存：从多的一端保存数据比从一的一端保存数据要快，因为从一的一端保存数据时，会多更新多的一端的一个外键(是指定一的一端的。)

(四) 关于inverse属性：

inverse主要用在一对多和多对多双向关联上，inverse可以被设置到集合标签<set>上，默认inverse为false，所以我们可以从一的一端和多的一端维护关联关系，如果设置inverse为true，则我们只能从多的一端维护关联关系。

    注意：inverse属性，只影响数据的存储，也就是持久化

(五) Inverse和cascade区别：

    Inverse是关联关系的控制方向

    Casecade操作上的连锁反应




六、       多对多 - 单向

?        一般的设计中，多对多关联映射，需要一个中间表

?        Hibernate会自动生成中间表

?        Hibernate使用many-to-many标签来表示多对多的关联

?        多对多的关联映射，在实体类中，跟一对多一样，也是用集合来表示的

(六) annotation注解方式

注意：因为是多对多单向(当然用户拥有多个角色，一个角色也可属性多个用户，但这里角色看不到用户)，所以角色只需要正常注解就可以了，

现在要使用@ManyToMany来注解多对多的关系，并使用@JoinTabel来注解第三方表的名称，再使用joinColumns属性来指定当前对象在第三方表中的字段名，并且这个字段会指向当前类相对应的表，最后再用inverseJoinColumns来指定当前类持有引用的实体类在第三方表中的字段名，并且指向被引用对象相对应的表，如下：

@Entity

public class User {

  private int id;

  private String name;

  private Set<User> roles = new HashSet<User>();// Role对象的集合  @Id

  @GeneratedValue

  public int getId() {return id;}

  @ManyToMany

  @JoinTable(name="u_r",//使用@JoinTable标签的name属性注解第三方表名称

          joinColumns={@JoinColumn(name="userId")},

//使用joinColumns属性来注解当前实体类在第三方表中的字段名称并指向该对象

          inverseJoinColumns={@JoinColumn(name="roleId")}

//使用inverseJoinColumns属性来注解当前实体类持有引用对象在第三方表中的字段名称并指向被引用对象表

  )

  public Set<User> getRoles() {return roles;}

(七) 生成SQL语句
  create table t_role (id integer not null auto_increment, namevarchar(255), primary key (id))

create table t_user (id integer not null auto_increment, namevarchar(255), primary key (id))

create table t_user_role (userid integer not null, roleid integer notnull, primary key (userid, roleid))
七、       多对多 - 双向
(二) annotation注解方式

多对多关联映射双向两方都持有对象引用，修改对象模型,但数据的存储没有变化

只需要修改注解映射就可以了。

User实体类注解没有变化和单向一样：

@Entity

public class User {

  private int id;

  private Set<User> roles = new HashSet<User>();// Role对象的集合  @Id

  @GeneratedValue

  public int getId() {return id;}

  @ManyToMany

  @JoinTable(name="u_r",//使用@JoinTable标签的name属性注解第三方表名称

          joinColumns={@JoinColumn(name="userId")},//使用joinColumns属性来注解当前实体类在第三方表中的字段名称并指向该对象

          inverseJoinColumns={@JoinColumn(name="roleId")}

//使用inverseJoinColumns属性来注解当前实体类持有引用对象在第三方表中的字段名称并指向被引用对象表

  )

  public Set<User> getRoles() {return roles;}

Role实体类注解也非常的简单:使用@ManyToMany注解，并使用mappedBy属性指定引用对象持有自己的的属性名

@Entity

public class Role {

  private int id;

  private String name;

  private Set<User> users = newHashSet<User>();

  @Id

  @GeneratedValue

  public int getId() {return id;  }

  @ManyToMany(mappedBy="roles")

  public Set<User>getUsers() {return users;}

  public voidsetUsers(Set<User> users) {this.users = users;  }

八、       关联关系中的CRUD_Cascade_Fetch

1、  设定cascade可以设定在持久化时对于关联对象的操作(CUD，R归Fetch管)

2、  cascade仅仅是帮助我们省了编程的麻烦而已，不要把它的作用看的太大

a)        cascade的属性指明做什么操作的时候关系对象是绑在一起的

b)        refresh=A里面需要读B改过之后的数据

3、  铁律：双向关系在程序中要设定双向关联

4、  铁律：双向一定需要设置mappedBy

5、  fetch

a)        铁律：双向不要两边设置Eager(会有多余的查询语句发出)

b)        对多方设置fetch的时候要谨慎，结合具体应用，一般用Lazy不用eager，特殊情况(多方数量不多的可以考虑，提高效率的时候可以考虑)

具体操作

hibernate树形结构(重点)

查询方式

缓存

补充：Java ,  非技术区