本笔记只介绍注解的方法

一、准备工作：

a、添加三个pojo类：

Product:

package pojo;import javax.persistence.*;import java.util.Set;@Entity@Table(name = "product_")public class Product {    int id;    String name;    float price;    Category category;    Set
      
        users;    @Id    @GeneratedValue(strategy = GenerationType.IDENTITY)    @Column(name = "id")    public int getId() {        return id;    }    public void setId(int id) {        this.id = id;    }    @ManyToMany(cascade=CascadeType.ALL,fetch=FetchType.EAGER)    @JoinTable(            name="user_product",            joinColumns=@JoinColumn(name="pid"),            inverseJoinColumns=@JoinColumn(name="uid")    )    public Set
       
         getUsers() {        return users;    }    public void setUsers(Set
        
          users) {        this.users = users;    }    @Column(name = "name")    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    @Column(name = "price")    public float getPrice() {        return price;    }    public void setPrice(float price) {        this.price = price;    }    @ManyToOne    @JoinColumn(name="cid")    public Category getCategory() {        return category;    }    public void setCategory(Category category) {        this.category = category;    }}
        
       
      

Category:

package pojo;import javax.persistence.*;import java.util.Set;@Entity@Table(name = "category_")public class Category {    int id;    String name;    Set
      
        products;    @OneToMany(fetch=FetchType.EAGER)    @JoinColumn(name="cid")    public Set
       
         getProducts() {        return products;    }    public void setProducts(Set
        
          products) {        this.products = products;    }    @Id    @GeneratedValue(strategy = GenerationType.IDENTITY)    @Column(name = "id")    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;    }}
        
       
      

User:

package pojo;import java.util.Set;import javax.persistence.CascadeType;import javax.persistence.Entity;import javax.persistence.FetchType;import javax.persistence.GeneratedValue;import javax.persistence.GenerationType;import javax.persistence.Id;import javax.persistence.JoinColumn;import javax.persistence.JoinTable;import javax.persistence.ManyToMany;import javax.persistence.Table;@Entity@Table(name="user_")public class User {    int id;    String name;    Set
      
        products;    @Id    @GeneratedValue(strategy = GenerationType.IDENTITY)    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;    }    @ManyToMany(cascade=CascadeType.ALL,fetch=FetchType.EAGER)    @JoinTable(            name="user_product",            joinColumns=@JoinColumn(name="uid"),            inverseJoinColumns=@JoinColumn(name="pid")    )    public Set
       
         getProducts() {        return products;    }    public void setProducts(Set
        
          products) {        this.products = products;    }}
        
       
      

b、添加hibernate.cfg.xml配置文件

在src目录下创建 hibernate.cfg.xml

配置访问数据库要用到的驱动，url，账号密码等等

      
          
               
                
        
         com.mysql.jdbc.Driver
                
        
         jdbc:mysql://192.168.80.128:3306/test?characterEncoding=UTF-8
                
        
         root
                
        
         111111
                
                
                
        
         org.hibernate.dialect.MySQLDialect
                
                
        
         thread
                
                
        
         true
                
                
        
         update
                
                
                
                
                
            
       
      

二、基本操作

a、插入数据到数据库

import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.cfg.Configuration; import com.how2java.pojo.Product; public class TestHibernate {    public static void main(String[] args) {         SessionFactory sf = new Configuration().configure().buildSessionFactory();         Session s = sf.openSession();        s.beginTransaction();         for (int i = 0; i < 10; i++) {            Product p = new Product();            p.setName("iphone"+i);            p.setPrice(i);            s.save(p);                 }         s.getTransaction().commit();        s.close();        sf.close();    } }

b、对象的三种状态 瞬时 持久 脱管

瞬时 指的是没有和hibernate发生任何关系，在数据库中也没有对应的记录，一旦JVM结束，这个对象也就消失了 

持久 指得是一个对象和hibernate发生联系，有对应的session,并且在数据库中有对应的一条记录 

脱管 指的是一个对象虽然在数据库中有对应的一条记录，但是它所对应的session已经关闭了 

SessionFactory sf = new Configuration().configure().buildSessionFactory();          Session s = sf.openSession();        s.beginTransaction();        Product p = new Product();        p.setName("p1");        System.out.println("此时p是瞬时状态");        s.save(p);        System.out.println("此时p是持久状态");        s.getTransaction().commit();        s.close();        System.out.println("此时p是脱管状态");        sf.close();

c、获取

调用Session的get方法，根据id获取对象。 除了id之外，还需要传递一个类对象，毕竟需要知道获取的是哪个对象。

除了使用get方法，还可以使用load获取对象。

SessionFactory sf = new Configuration().configure().buildSessionFactory();          Session s = sf.openSession();        s.beginTransaction();          Product p =(Product) s.get(Product.class, 6);                  System.out.println("id=6的产品名称是: "+p.getName());                  s.getTransaction().commit();        s.close();        sf.close();

d、删除

根据id把对象从表里删除掉 

注意:hibernate在删除一条数据之前，先要通过id把这条记录取出来

SessionFactory sf = new Configuration().configure().buildSessionFactory();         Session s = sf.openSession();        s.beginTransaction();         Product p =(Product) s.get(Product.class, 5);        s.delete(p);                 s.getTransaction().commit();        s.close();        sf.close();

e、修改

1. 根据id获取该对象

2. 修改该对象的属性

3. 通过Session的update方法把变化更新到数据库中

SessionFactory sf = new Configuration().configure().buildSessionFactory();         Session s = sf.openSession();        s.beginTransaction();         Product p =(Product) s.get(Product.class, 6);                 System.out.println(p.getName());                 p.setName("iphone-modified");                 s.update(p);                 s.getTransaction().commit();        s.close();        sf.close();

三、三种查询语言Hql Criteria sql

a、HQL（Hibernate Query Language）

是hibernate专门用于查询数据的语句，有别于SQL，HQL 更接近于面向对象的思维方式。 

比如使用的是类的名字Product,而非表格的名字product_

1. 首先根据hql创建一个Query对象

2. 设置参数

3. 通过Query对象的list()方法即返回查询的结果了。

注： 使用hql的时候，用的是类名Product,而不是表名product_

注： 使用hql的时候，不需要在前面加 select *

SessionFactory sf = new Configuration().configure().buildSessionFactory();         Session s = sf.openSession();        s.beginTransaction();         String name = "iphone";        Query q =s.createQuery("from Product p where p.name like ?");        q.setString(0, "%"+name+"%");        List
       
         ps= q.list();        for (Product p : ps) {            System.out.println(p.getName());        }                 s.getTransaction().commit();        s.close();        sf.close();
       

b、Criteria

与HQL和SQL的区别是Criteria 完全是 

面向对象的方式在进行数据查询，将不再看到有sql语句的痕迹

1. 通过session的createCriteria创建一个Criteria 对象

2. Criteria.add 增加约束。 在本例中增加一个对name的模糊查询(like)

3. 调用list()方法返回查询结果的集合

SessionFactory sf = new Configuration().configure().buildSessionFactory();          Session s = sf.openSession();        s.beginTransaction();         String name = "iphone";                  Criteria c= s.createCriteria(Product.class);        c.add(Restrictions.like("name", "%"+name+"%"));        List
       
         ps = c.list();        for (Product p : ps) {            System.out.println(p.getName());        }        s.getTransaction().commit();        s.close();        sf.close();
       

c、标准sql

Hibernate依然保留了对标准SQL语句的支持，在一些场合，比如多表联合查询，并且有分组统计函数的情况下，标准SQL语句依然是效率较高的一种选择

使用Session的createSQLQuery方法执行标准SQL语句

因为标准SQL语句有可能返回各种各样的结果，比如多表查询，分组统计结果等等。 不能保证其查询结果能够装进一个Product对象中，所以返回的集合里的每一个元素是一个对象数组。 然后再通过下标把这个对象数组中的数据取出来。

SessionFactory sf = new Configuration().configure().buildSessionFactory();         Session s = sf.openSession();        s.beginTransaction();         String name = "iphone";                 String sql = "select * from product_ p where p.name like '%"+name+"%'";                 Query q= s.createSQLQuery(sql);        List
       
         list= q.list();        for (Object[] os : list) {            for (Object filed: os) {                System.out.print(filed+"\t");            }            System.out.println();        }                 s.getTransaction().commit();        s.close();        sf.close();
       

 四、关系

a、多对一

一个Product对应一个Category 

一个Category对应多个Product 

所以Product和Category是多对一的关系

把Product的getCategory进行多对一映射

@ManyToOne    @JoinColumn(name="cid")    public Category getCategory() {        return category;    }    public void setCategory(Category category) {        this.category = category;    }

 

View Code

 

b、一对多

一个Product对应一个Category 

一个Category对应多个Product 

所以Category和Product是一对多的关系 

给getProducts方法加上一对多注解

@OneToMany(fetch=FetchType.EAGER)    @JoinColumn(name="cid")    public Set
       
         getProducts() {        return products;    }    public void setProducts(Set
        
          products) {        this.products = products;    }
        
       

 

SessionFactory sf = new Configuration().configure().buildSessionFactory();          Session s = sf.openSession();        s.beginTransaction();                 Category c = (Category) s.get(Category.class, 1);        Set
       
         ps = c.getProducts();        for (Product p : ps) {            System.out.println(p.getName());        }         s.getTransaction().commit();        s.close();        sf.close();
       

 

c、多对多

一种Product可以被多个User购买

一个User可以购买多种Product

所以Product和User之间的关系是多对多 many-to-many

要实现多对多关系，必须有一张中间表 user_product 用于维护 User和Product之间的关系

1. 加上多对一注解ManyToOne

2. 加上一对多注解OneToMany

3. ManyToMany

为Product的getUsers加上

@ManyToMany(cascade=CascadeType.ALL,fetch=FetchType.EAGER)    @JoinTable(            name="user_product",            joinColumns=@JoinColumn(name="uid"),            inverseJoinColumns=@JoinColumn(name="pid")    )    public Set
       
         getProducts() {        return products;    }    public void setProducts(Set
        
          products) {        this.products = products;    }
        
       

 

SessionFactory sf = new Configuration().configure().buildSessionFactory();           Session s = sf.openSession();        s.beginTransaction();                  //增加3个用户        Set
       
         users = new HashSet();        for (int i = 0; i < 3; i++) {            User u =new User();            u.setName("user"+i);            users.add(u);            s.save(u);        }                  //产品1被用户1,2,3购买        Product p1 = (Product) s.get(Product.class, 1);                  p1.setUsers(users);        s.save(p1);        s.getTransaction().commit();        s.close();        sf.close();
       

 

 五、注解手册

a、类相关注解

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

@Table —— 注解声明了该实体bean映射指定的表（table）,目录（catalog）和schema的名字

b、属性相关注解

@Id —— 注解声明了该实体bean的标识属性（对应表中的主键）。

@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）

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

  strategy 指定生成的策略（JPA定义的），这是一个GenerationType。默认是GenerationType. AUTO

  GenerationType.AUTO 主键由程序控制

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

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

  GenerationType.SEQUENCE 根据底层数据库的序列来生成主键，条件是数据库支持序列。（这个值要与generator一起使用）

  generator 指定生成主键使用的生成器（可能是orcale中的序列）。

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

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

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

  initialValue 表示主键初始值，默认为0.

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

c、关系相关注解

@ManyToOne 设置多对一关联 

方法一 

  @ManyToOne(cascade={CasCadeType.PERSIST,CascadeType.MERGE}) 

  @JoinColumn(name="外键") 

  public 主表类 get主表类(){return 主表对象} 

方法二 

  @ManyToOne(cascade={CascadeType.PERSIST,CascadeType.MERGE}) 

  @JoinTable(name="关联表名"， 

  joinColumns = @JoinColumn(name="主表外键"), 

  inverseJoinColumns = @JoinColumns(name="从表外键") 

  ) 

@OneToMany 设置一对多关联。

方法一 。 

“一端”配置 

  @OneToMany(mappedBy="“多端”的属性") 

  public List<“多端”类> get“多端”列表(){return “多端”列表} 

  “多端”配置参考@ManyToOne. 

方法二 

  “一端”配置 

  @OneToMany(mappedBy="“多端”的属性") 

  @MapKey(name="“多端”做为Key的属性") 

  public Map<“多端”做为Key的属性的类,主表类> get“多端”列表（）{return “多端”列表} 

  “多端”配置参考@ManyToOne. 

方法三 使用这种配置，在为“一端”添加“多端”时，可以修改“多端”的外键。 

  “一端”配置 

  @OneToMany 

  @JoinColumn(name="“多端”外键") 

  public List<“多端”类> get“多端”列表(){return “多端”列表} 

  “多端”配置参考@ManyToOne.

d、注解 vs XML

那么到底该用注解，还是xml文件配置方式呢？ 他们各自有各自的优缺点： 

XML配置方式： 

  优：容易编辑，配置比较集中，方便修改，在大业务量的系统里面，通过xml配置会方便后人理解整个系统的架构，修改之后直接重启应用即可 

  缺：比较繁琐，配置形态丑陋, 配置文件过多的时候难以管理 

注解方式： 

  优：方便，简洁，配置信息和 Java 代码放在一起，有助于增强程序的内聚性。 

  缺：分散到各个class文件中，所以不宜维护, 修改之后你需要重新打包，发布，重启应用。 

个人体会： 小项目，参与人数不多，不复杂的用注解，开发快速。 复杂项目，多人交互，配置量大，维护复杂度高的，用配置文件。

六、相关概念

a、事务

Hibernate的任何对数据有改动的操作，都应该被放在事务里面. 

在事务中的多个操作行为，要么都成功，要么都失败

SessionFactory sf = new Configuration().configure().buildSessionFactory();         Session s = sf.openSession();        s.beginTransaction();         Product p = (Product) s.get(Product.class, 1);        s.delete(p);         Product p2 = (Product) s.get(Product.class, 2);        p2.setName("长度超过30的字符串作为产品名称长度超过30的字符串作为产品名称长度超过30的字符串作为产品名称长度超过30的字符串作为产品名称");        s.update(p2);         s.getTransaction().commit();        s.close();        sf.close();

在Mysql中，只有当表的类型是INNODB的时候，才支持事务，所以需要把表的类型设置为INNODB,否则无法观察到事务.

b、属性延迟加载

属性的延迟加载: 

当使用load的方式来获取对象的时候，只有访问了这个对象的属性，hibernate才会到数据库中进行查询。否则不会访问数据库。

SessionFactory sf = new Configuration().configure().buildSessionFactory();          Session s = sf.openSession();        s.beginTransaction();             Product p = (Product)s.load(Product.class, 1);        System.out.println("log1");        System.out.println(p.getName());        System.out.println("log2");         s.getTransaction().commit();        s.close();        sf.close();

c、关系延迟加载

延迟加载又叫lazyload，在one-many many-many的时候都可以使用关系的延迟加载

SessionFactory sf = new Configuration().configure().buildSessionFactory();         Session s = sf.openSession();        s.beginTransaction();        Category c = (Category) s.get(Category.class, 1);         System.out.println("log1");        System.out.println(c.getProducts());        System.out.println("log1");         s.getTransaction().commit();        s.close();        sf.close();

System.out.println(c.getProducts());

只有在执行上面这行，通过category取products的时候，才会进行对product_表的查询

d、级联

什么是级联？ 简单的说，没有配置级联的时候，删除分类，其对应的产品不会被删除。 但是如果配置了恰当的级联，那么删除分类的时候，其对应的产品都会被删除掉。

包括上一步说的删除用得级联，级联有4种类型：

all：所有操作都执行级联操作；

none：所有操作都不执行级联操作；

delete：删除时执行级联操作； 

save-update：保存和更新时执行级联操作；

级联通常用在one-many和many-to-many上，几乎不用在many-one上。

为Category.hbm.xml 加上 

运行代码就会发现，删除分类的时候，会把分类下对应的产品都删除掉，否则只会把产品对应的cid设置为空

e、一级缓存

hibernate默认是开启一级缓存的，一级缓存存放在session上

SessionFactory sf = new Configuration().configure().buildSessionFactory();           Session s = sf.openSession();        s.beginTransaction();        System.out.println("log1");        Category c1 = (Category)s.get(Category.class, 1);        System.out.println("log2");        Category c2= (Category)s.get(Category.class, 1);        System.out.println("log3");                s.getTransaction().commit();        s.close();        sf.close();

第一次通过id=1获取对象的时候，session中是没有对应缓存对象的，所以会在"log1"后出现sql查询语句。

第二次通过id=1获取对象的时候，session中有对应的缓存对象，所以在"log2"后不会出现sql查询语句

所以总共会看到一次SQL语句出现

f、二级缓存

Hibernate的一级缓存是在Session上，二级缓存是在SessionFactory上

 

第一步:在hibernate.cfg.xml中开启二级缓存的配置

hibernate本身不提供二级缓存，都是使用第三方的二级缓存插件

这里使用的是 EhCache提供的二级缓存

       
        true
               
       
        org.hibernate.cache.EhCacheProvider
       

第二步：

在src目录下，创建一个ehcache.xml用于EHCache的缓存配置

第三步：

对于要进行二级缓存的实体类，进行配置，增加

<cache usage="read-only" />

测试：

使用不同的session,都去获取id=1的category,只会访问一次数据库。因为第二次获取虽然没有从第二个session中拿到缓存，但是从sessionfactory中拿到了Category缓存对象

SessionFactory sf = new Configuration().configure().buildSessionFactory();        Session s = sf.openSession();        s.beginTransaction();                 Category c1 = (Category)s.get(Category.class, 1);        System.out.println("log1");        Category c2= (Category)s.get(Category.class, 1);        System.out.println("log2");        s.getTransaction().commit();        s.close();        Session s2 = sf.openSession();        s2.beginTransaction();        Category c3 = (Category)s2.get(Category.class, 1);        System.out.println("log3");          s2.getTransaction().commit();        s2.close();        sf.close();

g、分页

使用Criteria进行分页查询 

无论你使用的是Oracle,Mysql,NoSQL还是DB2，分页查询的代码写法都是一样的

c.setFirstResult(2); 表示从第3条数据开始

c.setMaxResults(5); 表示一共查询5条数据

SessionFactory sf = new Configuration().configure().buildSessionFactory();          Session s = sf.openSession();        s.beginTransaction();          String name = "iphone";                  Criteria c= s.createCriteria(Product.class);        c.add(Restrictions.like("name", "%"+name+"%"));        c.setFirstResult(2);        c.setMaxResults(5);                 List
       
         ps = c.list();        for (Product p : ps) {            System.out.println(p.getName());                     }                  s.getTransaction().commit();        s.close();        sf.close();
       

h、两种获取方式，get和load

通过id获取Product对象有两种方式，分别是get和load 

他们的区别分别在于 

 延迟加载 

load方式是延迟加载，只有属性被访问的时候才会调用sql语句

get方式是非延迟加载，无论后面的代码是否会访问到属性，马上执行sql语句

对于id不存在的时候的处理

1. get方式会返回null 

2. load方式会抛出异常

i、两种session方式，openSession和getCurrentSession 

他们的区别在于 

1. 获取的是否是同一个session对象 

    openSession每次都会得到一个新的Session对象 

    getCurrentSession在同一个线程中，每次都是获取相同的Session对象，但是在不同的线程中获取的是不同的Session对象 

2. 事务提交的必要性 

    openSession只有在增加，删除，修改的时候需要事务，查询时不需要的 

    getCurrentSession是所有操作都必须放在事务中进行，并且提交事务后，session就自动关闭，不能够再进行关闭 

j、N+1

Hibernate有缓存机制，可以通过用id作为key把product对象保存在缓存中 

同时hibernate也提供Query的查询方式。假设数据库中有100条记录，其中有30条记录在缓存中，但是使用Query的list方法，就会所有的100条数据都从数据库中查询，而无视这30条缓存中的记录 

N+1是什么意思呢，首先执行一条sql语句，去查询这100条记录，但是，只返回这100条记录的ID 

然后再根据id,进行进一步查询。 

如果id在缓存中，就从缓存中获取product对象了，否则再从数据库中获取

k、查询总数

调用Query对象的uniqueResult()方法，返回一个long型的数据，即查询总数。

SessionFactory sf = new Configuration().configure().buildSessionFactory();        Session s = sf.openSession();        s.beginTransaction();          String name = "iphone";                 Query q =s.createQuery("select count(*) from Product p where p.name like ?");        q.setString(0, "%"+name+"%");        long total= (Long) q.uniqueResult();        System.out.println(total);        s.getTransaction().commit();        s.close();        sf.close();

l、乐观锁

Hibernate使用乐观锁来处理脏数据问题

第一步：修改配置文件 Product.hbm.xml

<version name="version" column="ver" type="int"></version>

 

增加一个version字段，用于版本信息控制。这就是乐观锁的核心机制。

比如session1获取product1的时候，version=1。 那么session1更新product1的时候，就需要确保version还是1才可以进行更新，并且更新结束后，把version改为2。

注意： version元素必须紧跟着id后面，否则会出错。

第二步：修改Product.java

增加version属性

第三步：运行下面的代码

做同样的业务就会抛出异常，提示该行已经被其他事务删除或者修改过了，本次修改无法生效。

这样就保证了数据的一致性。

SessionFactory sf = new Configuration().configure().buildSessionFactory();        Session s1 = sf.openSession();        Session s2 = sf.openSession();         s1.beginTransaction();        s2.beginTransaction();         Product p1 = (Product) s1.get(Product.class, 1);        System.out.println("产品原本价格是: " + p1.getPrice());         p1.setPrice(p1.getPrice() + 1000);         Product p2 = (Product) s2.get(Product.class, 1);        p2.setPrice(p2.getPrice() + 1000);         s1.update(p1);        s2.update(p2);         s1.getTransaction().commit();        s2.getTransaction().commit();         Product p = (Product) s1.get(Product.class, 1);         System.out.println("经过两次价格增加后，价格变为: " + p.getPrice());         s1.close();        s2.close();         sf.close();

原理：

1. 假设数据库中产品的价格是10000，version是10

2. session1,session2分别获取了该对象

3. 都修改了对象的价格

4. session1试图保存到数据库，检测version依旧=10，成功保存，并把version修改为11

5. session2试图保存到数据库，检测version=11，说明该数据已经被其他人动过了。 保存失败，抛出异常