javaee之hibernate的缓存与注解

hibernate的注解：
在项目中，除了有xml的映射配置文件外，还可以在实体类中采用注解的方式来生成映射。
在比较大的项目，通常都是采用xml的映射配置文件，主要是因为在大项目中比较好维护；在小项目中，主要是要求是开发的速率快，大多数就是采用注解的方式来开发
常用的注解：
@Entity：声明一个类是一个映射类 类似：
@Table : 声明一个类映射到的表名 类似：
@Id : 声明一个类的主键类似：
@Column :声明一个类映射表的字段 类似：
@JoinColumn:用来设置外键 类似：
@JoinTable :设置中间表 类似：
@OneToMany :一对多的映射关系
@ManyToMany:多对多的映射关系
@OneToOne :一对一的映射关系
一对多：
User：
import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import org.hibernate.engine.internal.Cascade;
@Entity
@Table(name="t_user")
public class User {
//主键
@Id
@GeneratedValue //设置id的主键生成策略，generator的属性表示生成策略的类型
@Column(name="id") //生成的字段列，不写name，默认为属性名
private int id;
@Column(name="name")
private String name;
//一对多的关系
/**
* cascade:表示设置级联操作
* mappedBy：表示设置的是维护关联关系，参数值为多方的属性值
*/
@OneToMany(mappedBy="user",cascade={CascadeType.ALL})
//@JoinColumn(name="uid") //当设置了mappedBy的时候，就不能使用JoinColumn或者JoinTable注解
private Set addresses = new HashSet();
public Set getAddresses() {
return addresses;
}
public void setAddresses(Set addresses) {
this.addresses = addresses;
}
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;
}
}
Address：
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
@Entity
@Table(name="t_address")
public class Address {
@Id
@GeneratedValue
@Column(name="id")
private int id;
@Column(name="name")
private String name;
@Column(name="phone")
private String phone;
@Column(name="addre")
private String addre;
//表示的多对一
@ManyToOne
@JoinColumn(name="uid")
private User user ;
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;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public String getAddre() {
return addre;
}
public void setAddre(String addre) {
this.addre = addre;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
}
多对多：
Course：
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
/**
* @author Mao
*
*/
@Entity
@Table(name="t_course")
public class Course {
@Id
@GeneratedValue
@Column(name="id")
private int id;
@Column(name="name")
private String name;
@ManyToMany(mappedBy="course")
private Set student = new HashSet();
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;
}
public Set getStudent() {
return student;
}
public void setStudent(Set student) {
this.student = student;
}
}
Student：
import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
@Entity
@Table(name="t_student")
public class Student {
@Id
@GeneratedValue
@Column(name="id")
private int id;
@Column(name="name")
private String name;
//表示多对多关系
@ManyToMany(cascade={CascadeType.ALL})
//设置中间表
@JoinTable(name="student_course",joinColumns=@JoinColumn(name="sid"),inverseJoinColumns=@JoinColumn(name="cid"))
private Set course = new HashSet();
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;
}
public Set getCourse() {
return course;
}
public void setCourse(Set course) {
this.course = course;
}
}
一对一：
Person：
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;
@Entity
@Table(name="t_person")
public class Person {
@Id
@GeneratedValue
@Column(name="id")
private int id;
@Column(name="name")
private String name;
@OneToOne(mappedBy="person",cascade={CascadeType.ALL})
private IdCard idcard;
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;
}
public IdCard getIdcard() {
return idcard;
}
public void setIdcard(IdCard idcard) {
this.idcard = idcard;
}
}
IdCard：
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;
@Entity
@Table(name="t_idcard")
public class IdCard {
@Id
@GeneratedValue
@Column(name="id")
private int id;
@Column(name="cardno")
private String cardno;
@OneToOne
@JoinColumn(name="pid",unique=true)
private Person person;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getCardno() {
return cardno;
}
public void setCardno(String cardno) {
this.cardno = cardno;
}
public Person getPerson() {
return person;
}
public void setPerson(Person person) {
this.person = person;
}
}
测试类：
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;
import util.HibernateUtils;
public class text {
@Test
public void test01(){
Session session = HibernateUtils.getSession();
Transaction tx = session.getTransaction();
tx.begin();
User u = new User();
u.setName("狗剩");
Address a1 = new Address();
a1.setName("狗剩的老婆");
a1.setAddre("广州天河");
Address a2 = new Address();
a2.setName("狗剩的妈妈");
a2.setAddre("广州番禺");
u.getAddresses().add(a1);
u.getAddresses().add(a2);
a1.setUser(u);
a2.setUser(u);
session.save(u);
tx.commit();
HibernateUtils.close(session);
}
@Test
public void test02(){
Session session = HibernateUtils.getSession();
Transaction tx = session.getTransaction();
tx.begin();
Student s1 = new Student();
s1.setName("张三");
Student s2 = new Student();
s2.setName("李四");
Course c1 = new Course();
c1.setName("jsp开发");
Course c2 = new Course();
c2.setName("struts2框架");
s1.getCourse().add(c1);
s1.getCourse().add(c2);
c1.getStudent().add(s1);
c2.getStudent().add(s1);
s2.getCourse().add(c1);
c1.getStudent().add(s2);
session.save(s1);
session.save(s2);
tx.commit();
HibernateUtils.close(session);
}
@Test
public void test03(){
Session session = HibernateUtils.getSession();
Transaction tx = session.getTransaction();
tx.begin();
Person p = new Person();
p.setName("张三");
IdCard ic = new IdCard();
ic.setCardno("4422223333");
p.setIdcard(ic);
ic.setPerson(p);
session.save(p);
tx.commit();
HibernateUtils.close(session);
}
}
hibernate的懒加载：
当要查询数据的时候，hibernate会先去一级缓存和二级缓存中查询，如果没有查询到数据的时候，这个时候才会去数据库查询。
采用懒加载的机制后，查询到的数据不会一次性全部查询到，而是到了需要用到的数据才会去查询该数据
Address：
public class Address {
private int id;
private String name;
private String phone;
private String address;
private User user;
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;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
}
User：
import java.util.HashSet;
import java.util.Set;
public class User {
private int id;
private String name;
private Set addresses = new HashSet();
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;
}
public Set getAddresses() {
return addresses;
}
public void setAddresses(Set addresses) {
this.addresses = addresses;
}
}
Address.hbm.xml
User.hbm.xml
测试类：
/**
*
//延迟加载
/**
* 1) 类的延迟加载
* get(): 不支持类的延迟加载
* load()： 支持类的延迟加载
*
* 2) 类的关联关系延迟加载
* lazy="false"
* @author APPle
*/
public class App {
@Test
public void test01(){
Session session = HibernateUtils.getSession();
Transaction tx = session.beginTransaction();
/**
* 一个对象的延迟加载：get和load方法区别
* get方法都是立即加载的，没有延迟加载的效果
* load方法是支持延迟加载的
*
* 2、当在映射文件中设置lazy为false，则表示不懒加载，默认为true
*/
User u = (User)session.load(User.class, 1); //现在查询到只是User的对象地址，不包含其他属性
System.out.println(u.getName()); //这个时候需要得到user的name，所有才继续去查询，但是这是只有name这个属性，没有其他属性
System.out.println(u.getAddresses()); //这个时候又再去查询user的address属性
User u1 = (User)session.get(User.class, 1);//现在查询到User对象，包括User里面的全部属性
System.out.println(u.getName()); //这个时候可以直接取到来使用
System.out.println(u.getAddresses());
tx.commit();
HibernateUtils.close(session);
}
hibernate的缓存：
1、关于hibernate的缓存机制，是为了提供hibernate框架运行的性能，尽量减少和数据库的连接次数。其中包括hibernate的一级缓存、hibernate的二级缓存
hibernate一级缓存：
为Session级别的缓存，是属于事务缓存，所有缓存数据都放在session对象，当session关闭的时候就会丢失缓存数据
Student：
public class Student {
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(String name) {
this.name = name;
}
}
Student.hbm.xml
测试类：
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;
import util.HibernateUtils;
public class App {
//演示一级缓存
@Test
public void test01(){
Session session = HibernateUtils.getSession();
Transaction tx = session.beginTransaction();
//第一次查询过的数据会放在一级缓存中，并且使用id来标记
Student s1 =(Student) session.get(Student.class, 1);
Student s2 =(Student) session.get(Student.class, 1);
System.out.println(s1=s2); //true
tx.commit();
HibernateUtils.close(session);
}
//修改也是走一级缓存
@Test
public void test02(){
Session session = HibernateUtils.getSession();
Transaction tx = session.beginTransaction();
/*Student s = (Student)session.get(Student.class, 1); // s对已经放到了一级缓存
//修改
s.setName("李四");//修改一级缓存中的数据
*/
/*int i =1;
for(Student s: list){
if(i%1000==0){
//同步数据
session.flush();
//清空一级缓存的数据
session.clear();
}
session.save(s);
}*/
Student s1 = (Student)session.get(Student.class, 1);
Student s2 = (Student)session.get(Student.class, 1);
session.evict(s1);
//session.clear();
Student s3 = (Student)session.get(Student.class, 1);
tx.commit(); //commit()方法在提交事务之前，会调用session.flush()方法来同步一级缓存和数据库的数据
HibernateUtils.close(session);
}
//演示hibernate不同对象状态的转换
@Test
public void test03(){
Session session = HibernateUtils.getSession();
Transaction tx = session.beginTransaction();
Student s = new Student(); //s是处于临时状态
s.setName("xx"); //不会对数据库进行任何的操作
session.save(s); //s是处于持久化状态
session.evict(s); //s是处于游离态
session.delete(s); //s是处于删除态
tx.commit();
HibernateUtils.close(session);
}
}
hibernate二级缓存：
为SessionFactory级别的缓存，是属于进程缓存，所有缓存数据都放在SessionFactory，所有二级缓存的数据不会随着session对象的关闭而丢失

测试类：
//演示二级缓存,同时需要在cfg.xml中进行配置
@Test
public void test2(){
Session session1 = HibernateUtils.getSession();
Transaction tx = session1.getTransaction();
tx.begin();
Address a1 = (Address)session1.get(Address.class, 1);
tx.commit();
HibernateUtils.close(session1);
Session session2 = HibernateUtils.getSession();
Transaction tx2 = session2.getTransaction();
tx2.begin();
Address a2 = (Address)session2.get(Address.class, 1);
tx2.commit();
HibernateUtils.close(session2);
}
hibernate.cfg.xml
org.hibernate.c3p0.internal.C3P0ConnectionProvider20103000trueorg.hibernate.cache.ehcache.EhCacheRegionFactory
2、hibernate的对象状态
①临时态：
没有在数据库中有任何的记录，普通的为刚创建出来的对象数据
特点：
1、没有OID（对象的主键值）
2、数据库中没有对应的记录
3、任何的修改操作的不会反映到数据库
4、临时对象不在一级缓存
②持久态：
保存数据在数据库中，并且在一级缓存中
特点：
1、有OID（对象的主键值）
2、数据库中有对应的记录
3、任何的修改操作的会反映到数据库
4、持久化对象在一级缓存
③游离态：
把对象在一级缓存中清除
特点：
1、有OID（对象的主键值）
2、数据库中有对应的记录
3、任何的修改操作的不会反映到数据库
4、游离对象不在一级缓存
④删除态：
把对象进行删除，或者变成垃圾回收
特点：
1、有OID（对象的主键值）
2、数据库中没有对应的记录
3、任何的修改操作的不会反映到数据库

4、删除对象不在一级缓存