hibernate学习一对一，一对多，多对一，多对多，注解版和XML版

最新推荐文章于 2020-05-31 09:43:03 发布

CL_slacking

最新推荐文章于 2020-05-31 09:43:03 发布

阅读量2.8k

点赞数 1

分类专栏： JavaWeb 文章标签： hibernate

本文链接：https://blog.csdn.net/I_do_can/article/details/50380213

版权

JavaWeb 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

只是个人简单的一点小结

hibernate的配置文件 hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

<!-- Database connection settings -->
<property name="connection.driver_class">
com.mysql.jdbc.Driver
</property>
<property name="connection.url">
jdbc:mysql://localhost/hibernate
</property>
<property name="connection.username">root</property>
<property name="connection.password"></property>

<!-- JDBC connection pool (use the built-in) -->
<property name="connection.pool_size">10</property>

<!-- SQL dialect -->
<property name="dialect">
org.hibernate.dialect.MySQLDialect
</property>

<!-- Enable Hibernate's automatic session context management -->
<property name="current_session_context_class">thread</property>

<!-- Disable the second-level cache   不缓存-->
<property name="cache.provider_class">
org.hibernate.cache.NoCacheProvider
</property>

<!-- Echo all executed SQL to stdout -->
<property name="show_sql">true</property>

<!-- Drop and re-create the database schema on startup -->
<property name="hbm2ddl.auto">create</property>

<property name="format_sql">true</property>

</session-factory>


</hibernate-configuration>

一对一的映射关系

我们假设一个妻子对应一个老公，一个老公也只有一个妻子，其他社会问题我们不讨论

注解版：

首先在配置文件里添加映射关系：

 <mapping class="com.cl.hiberanate.bean.Husband" />
<mapping class="com.cl.hiberanate.bean.Wife" />

Husband类

@Entity
public class Husband {


private int id;
private String name;
private Wife wife;

@OneToOne
public Wife getWife() {
return wife;
}
public void setWife(Wife wife) {
this.wife = wife;
}
@Id
@GeneratedValue
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}

}

wife类

@Entity
public class Wife {

private int id;
private String name;
@Id
@GeneratedValue
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

查看sql语句：

 create table Husband (
        id integer not null auto_increment,
        name varchar(255),
        wife_id integer,
        primary key (id)
     )


    create table Wife (
        id integer not null auto_increment,
        name varchar(255),
        primary key (id)
    )
    alter table Husband 
        add index FKAEEA401BA8A19199 (wife_id), 
        add constraint FKAEEA401BA8A19199 
        foreign key (wife_id) 
        references Wife (id)

以上是单向映射，下面看看双向映射，即两个类都要写上映射关系

husband不需要修改，只需要修改wife类

@Entity
public class Wife {

private int id;
private String name;
//双向
private Husband husband;
//被 com.cl.hiberanate.bean.Husband.wife 所映射
//只是内存间的映射，知道即可，基本不用
@OneToOne(mappedBy="wife")
public Husband getHusband() {
return husband;
}
public void setHusband(Husband husband) {
this.husband = husband;
}
@Id
@GeneratedValue
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

编写一个测试类测试一下就好了，JunitTest,实在不会就去 main函数里运行

Session session  = new AnnotationConfiguration().configure().buildSessionFactory().openSession();

Wife w = new Wife();
w.setName("Helen");

Husband h = new Husband();
h.setName("Tom");
h.setWife(w);

session.save(w);
session.save(h);

session.beginTransaction().commit();

再来看看xml版，现在公司很少使用这个，开发速度太慢

hibernate.cfg.xml这个肯定要有，

类就直接用上面的类好了

新增：映射文件Husband.hbm.xml，Wife.hbm.xml切记和你的类同名且在一个包下

Husband.hbm.xml：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">


<hibernate-mapping package="com.cl.hiberanate.bean">

<class name="Husband">
<id name="id" column="id">
<generator class="native"></generator>
</id>
<property name="name"></property>
<!-- one-to-one   不要怀疑，就是这么写的   加上unique-->

<many-to-one name="wife" column="wifeId" unique="true"></many-to-one>

</class>

</hibernate-mapping>

Wife.hbm.xml 双向的只需要把注释取消即可

<hibernate-mapping package="com.cl.hiberanate.bean">


<class name="Wife">
<id name="id" column="id">
<generator class="native"></generator>
</id>
<property name="name" column="name" not-null="true" length="20" type="java.lang.String"></property>
<!-- one-to-one 双向 -->
<!-- <one-to-one name="husband" property-ref="wife"></one-to-one> -->
</class>


</hibernate-mapping>

hibernate.cfg.xml里新增：

<mapping resource="com/cl/hiberanate/bean/Husband.hbm.xml" />
<mapping resource="com/cl/hiberanate/bean/Wife.hbm.xml" />

注意跟注解版的区别

看看数据库语句，跟上面是一样的

create table Husband (
        id integer not null auto_increment,
        name varchar(255),
        wifeId integer unique,
        primary key (id)
    )
    create table Wife (
        id integer not null auto_increment,
        name varchar(20) not null,
        primary key (id)
    )
    alter table Husband 
        add index FKAEEA401B29AAB07C (wifeId), 
        add constraint FKAEEA401B29AAB07C 
        foreign key (wifeId) 
        references Wife (id)

测试：

Session session  = new Configuration().configure().buildSessionFactory().openSession();

Wife w = new Wife();
w.setName("Helen");

Husband h = new Husband();
h.setName("Tom");
h.setWife(w);

session.save(w);
session.save(h);

session.beginTransaction().commit();

OK ,再看看一对多

一本书只属于一个类型，比如《操作系统》这本书属于“计算机类”，而计算机类除了有操作系统，还有计算机组成原理、Java等等，即一类里有多本书

不要较真什么我有基本相同名字的书，那个跟我们现在讨论的没关系，他们可以通过Id区分，我们假设只有一本

一对多：一个类有多本书,

注解版

Book :

@Entity
public class Book {

private int id;
private String bookname;

@Id
@GeneratedValue
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getBookname() {
return bookname;
}
public void setBookname(String bookname) {
this.bookname = bookname;
}

}

BookType :

@Entity
public class BookType {

private int id;
private String typename;

@Id
@GeneratedValue
public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}
public String getTypename() {
return typename;
}
public void setTypename(String typename) {
this.typename = typename;
} 
//一对多
private Set<Book> books;
@OneToMany
public Set<Book> getBooks() {
return books;
}

public void setBooks(Set<Book> books) {
this.books = books;
}
}

修改hibernate.cfg.xml

<mapping class="com.cl.hibernate.bean.Book" />
<mapping class="com.cl.hibernate.bean.BookType" />

测试，

Session session  = new AnnotationConfiguration().configure().buildSessionFactory().openSession();

Book book = new Book();
BookType booktype = new BookType();
book.setBookname("hibernate");
booktype.setTypename("computer");
Set<Book> books = new HashSet<Book>() ;
books.add(book);
booktype.setBooks(books);

session.save(book);
session.save(booktype);

session.beginTransaction().commit();

看看建表语句

create table Book (
        id integer not null auto_increment,
        bookname varchar(255),
        primary key (id)
    )

    create table BookType (
        id integer not null auto_increment,
        typename varchar(255),
        primary key (id)
    )

    create table BookType_Book (
        BookType_id integer not null,
        books_id integer not null,
        primary key (BookType_id, books_id),
        unique (books_id)
    )

    alter table BookType_Book 
        add index FK13FA97E56EF30904 (BookType_id), 
        add constraint FK13FA97E56EF30904 
        foreign key (BookType_id) 
        references BookType (id)

    alter table BookType_Book 
        add index FK13FA97E53B4450C3 (books_id), 
        add constraint FK13FA97E53B4450C3 
        foreign key (books_id) 
        references Book (id)

自动帮我们新增了一张表

一对多的双向（反向）即多对一，这里先不讨论，到多对一再讨论

再看看XML版的

同上面的规则一样，新建一个映射文件，同名同包

BookType

<hibernate-mapping package="com.cl.hibernate.bean">

<class name="BookType">
<id name="id" column="id">
<generator class="native"></generator>
</id>
<property name="typename"></property>
<!-- 一对多 -->
<set name="books">
<!-- 加在book那张表 -->
<key column="typeId"></key>
<one-to-many class="com.cl.hibernate.bean.Book"/>
</set>
</class>

</hibernate-mapping>

Book：双向的就把那个注释取消即可

<class name="Book">
<id name="id" column="id">
<generator class="native"></generator>
</id>
<property name="bookname"></property>
<!-- many-to-one  -->
<!-- <many-to-one name="booktype" column="typeId" ></many-to-one> -->

</class>

建表语句同上面是一样的

多对一

还是上面的图书和分类的例子

Book ：

@Entity
public class Book {


private int id;
private String bookname;
//一本书属于一个类型，一个类型有多本书
private BookType booktype;
@Id
@GeneratedValue
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getBookname() {
return bookname;
}
public void setBookname(String bookname) {
this.bookname = bookname;
}

@ManyToOne
@JoinColumn(name="typeId")
public BookType getBooktype() {
return booktype;
}
public void setBooktype(BookType booktype) {
this.booktype = booktype;
}

}

BookType ：多对一的双向即一对多

@Entity
public class BookType {

private int id;
private String typename;


@Id
@GeneratedValue
public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}
public String getTypename() {
return typename;
}
public void setTypename(String typename) {
this.typename = typename;
}

//多对一双向  一对多
private Set<Book> books;

@OneToMany(mappedBy="booktype")
public Set<Book> getBooks() {
return books;
}

public void setBooks(Set<Book> books) {
this.books = books;
}
}

XML版

Book.hbm.xml:

<class name="Book">
<id name="id" column="id">
<generator class="native"></generator>
</id>
<property name="bookname"></property>
<!-- many-to-one  -->
<many-to-one name="booktype" column="typeId" ></many-to-one>

</class>

BookType.hbm.xml:

<class name="BookType">
<id name="id" column="id">
<generator class="native"></generator>
</id>
<property name="typename"></property>

</class>

多对多

所谓多对多的关系，老师和学生，一个学生有多个老师，一个老师有多个学生

注解版:双向映射取消下面的注释

Student ：

@Entity
public class Student {

private int id;
private String sname;
/* //双向映射
private Set<Teacher> teachers;
//映射至   com.cl.hibernate.bean.Teacher.students
@ManyToMany(mappedBy="students")
public Set<Teacher> getTeachers() {
return teachers;
}
public void setTeachers(Set<Teacher> teachers) {
this.teachers = teachers;
}
*/
@Id
@GeneratedValue
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}

}

Teacher ：

@Entity
public class Teacher {


private int id;
private String tname;
private Set<Student> students;
@Id
@GeneratedValue
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return tname;
}
public void setName(String tname) {
this.tname = tname;
}

@ManyToMany
//如不写会指定默认值    加入第三张表        一个老师对应多个学生，一个学生对应多个老师
@JoinTable(name="t_s",joinColumns={@JoinColumn(name="teacher_id")},
inverseJoinColumns={@JoinColumn(name="student_id")})
public Set<Student> getStudent() {
return students;
}
public void setStudent(Set<Student> students) {
this.students = students;
}

}

看看建表语句：

create table Student (
        id integer not null auto_increment,
        sname varchar(255),
        primary key (id)
    )
    create table Teacher (
        id integer not null auto_increment,
        name varchar(255),
        primary key (id)
    )
    create table t_s (
        teacher_id integer not null,
        student_id integer not null,
        primary key (teacher_id, student_id)
    )
    alter table t_s 
        add index FK1BF68467CBB30 (teacher_id), 
        add constraint FK1BF68467CBB30 
        foreign key (teacher_id) 
        references Teacher (id)
    alter table t_s 
        add index FK1BF6835E17090 (student_id), 
        add constraint FK1BF6835E17090 
        foreign key (student_id) 
        references Student (id)

OK,看看XML 版的

Student.hbm.xml:

<class name="Student">
<id name="id" column="id">
<generator class="native"></generator>
</id>
<property name="sname"></property>

</class>

Teacher.hbm.xml:

<class name="Teacher">
<id name="id" column="id">
<generator class="native"></generator>
</id>
<property name="tname"></property>
<!-- many-to-many -->
<!-- 对应的哪一个属性   表名 -->
<set name="students" table="t_s">
<!-- 第一个列名 -->
<key column="teacher_id"></key>
<!-- 第二个列名   类+名 -->
<many-to-many class="com.cl.hibernate.bean.Student" 
column="student_id"></many-to-many>
</set>
</class>

OK,关系映射就全部完成了

看看hibernate的分页，不管什么数据库都是一样的，hibernate已经给我们实现好了：

下面是一个测试代码

Session session  = new AnnotationConfiguration().configure().buildSessionFactory().openSession();
Query query = session.createQuery("from Book ");
List<?> total = query.list();

//分页
int pageSize = 3;
int totalPage = total.size() / pageSize ;
if(total.size() % pageSize != 0){
totalPage++;
}
System.err.println(totalPage);

query.setMaxResults(pageSize);
int currentPage = 1;//当前页号
query.setFirstResult((currentPage - 1)*pageSize);

List<?> list = query.list();

可以写成方法，参数pageSize ，currentPage 就可以实现分页方法啦

如果查询时有参数呢，可以使用占位符 ?

比如：

Query query = session.createQuery("from Book b where b.id = ? ");
query.setString(0, "1");
List<?> list = query.list();
for(Object o : list){
Book b = (Book)o;
System.out.println(b);
}

也可以使用替换变量

如：

hql = "from Book b where b.id = :id";

Query query = session.createQuery(hql);
query.setParameter("id", 1) //.setParameter("id", 1);

这两种参数设置都是可以的

hibernate的功能很强大，学然后知不足。

所有的练习源码：http://download.csdn.net/detail/i_do_can/9372156

不过我好像忘了上传jar文件了，补上：http://download.csdn.net/detail/i_do_can/9372177

CL_slacking

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录