Hibernate ----->通用Dao
ORM:Object对象 Relation关系（表） Mapping映射
优点:开发效率极高
缺点:数据库操作性能低（慢）
Mybatis:ORM 的框架
jdbc: java database connection java的数据库连接 sql语句操作数据库 直连
优点:数据操作性能高
缺点:开发效率低
<!--hibernate的核心依赖 -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>5.3.10.Final</version>
</dependency>
-
实体类和表关系的映射
class 实体类的全限定名称
table 数据库的表名
id为数据库的默认主键
type:该属性的java数据类型
column:列名 对应的数据库的列名
property:属性 实体类的属性
generator:主键生成策略 主键的值是怎么产生的
native:主键生成的自增长 -
hibernate中关于对象的三种状态
自由态:session空间中没有这个对象（该对象没有纳入了session的管理范围），数据库中也没有与之对应的数据
持久态:session空间中有这个对象（该对象纳入了session的管理范围），数据库中有与之对应的数据
持久态的数据 对象中的属性值与数据库中的数据保持一致 ,如果不一致会发生同步更新 发送修改语句
游离态:session空间中没有这个对象（该对象没有纳入了session的管理范围），数据库中有与之对应的数据
少的一方级联 cascade
多的一方维护关系 inverse
- hibernate的缓存机制
一级缓存 默认开启 session级缓存 作用范围只在一个session对象的生命周期中有效 一级缓存缓存对象 不能缓存集合
二级缓存 hibernate没有默认开启 SessionFactory级缓存 要手动打开 二级缓存hibernate默认没有提供缓存组件
需要自己配置 需要Ehcache （后期工作使用redis）
二级缓存缓存对象 不能缓存集合
<!-- 二级缓存组件 -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-ehcache</artifactId>
<version>5.3.10.Final</version>
</dependency>
//查询缓存 缓存的是当前创建的查询对象的查询
//查询缓存测试
/*Query query=session.createQuery("from Author a where a.aid=7");
//手动开启查询缓存
query.setCacheable(true);
Author a=(Author) query.uniqueResult();
System.out.println(a.getAname());
System.out.println("-------------------------------");
Query query1=session.createQuery("from Author a where a.aid=7");
//手动开启查询缓存
query1.setCacheable(true);
Author aa=(Author) query1.uniqueResult();
System.out.println(aa.getAname());*/
/*Query query1=session.createQuery("from Author");
query1.setCacheable(true);
List<Author> list=query1.list();
for (Author a : list) {
System.out.println(a.getAname());
}
Query query2=session.createQuery("from Author");
//query2.setCacheable(true);
List<Author> list1=query2.list();
for (Author a : list1) {
System.out.println(a.getAname());
}*/
- 一对一
一个人和一张身份证
@Test
public void test() {
Users u=session.get(Users.class,1);
System.out.println(u.getCard().getCnumber());*/
添加数据 用户信息和卡的信息 添加之后一一对应
Users u=new Users("admin1");
Card c=new Card("431111111111111");
相互设置 互设
u.setCard(c);
c.setUsers(u);
session.save(u);//级联操作
session.save(c);
找到一个人同时找到这个人的卡
Users u=session.get(Users.class, 1);
System.out.println(u.getCard());
查询一张卡的同时查询该卡的用户
Card c=session.get(Card.class, 1);
System.out.println(c.getUsers().getUname());
删除一个用户同时删除用户的卡
Users u=session.get(Users.class, 1);
session.delete(u);//级联操作 删除卡
删除一张卡
Card c=session.get(Card.class, 4);
断绝关系
c.getUsers().setCard(null);
将级联的对象踢出session的管理范围
Users u=c.getUsers();
session.evict(u);
session.delete(c);
给用户添加一张新的卡
Users u=session.get(Users.class, 2);
Card c=new Card("11111111111111");
u.setCard(c);
c.setUsers(u);
session.save(c);
给老卡添加一个新人 no
Card c=session.get(Card.class, 8);
Users u=new Users("aaa");
u.setCard(c);
c.setUsers(u);
session.save(u);
Card c=session.get(Card.class, 5);
c.getUsers().setUname("小强");
session.update(c);
删除一个用户不删除卡
Users u=session.get(Users.class, 5);
u.setCard(null);
session.delete(u);
}
那么为什么会有对象的一对一关系的建立，我们从几点来进行剖析：
1、低耦合
每个业务对象单独建立，避免了产生过多依赖，不利于维护
2、逻辑独立，任务分配明确
每个逻辑对象单独处理本类的业务逻辑，符合实际生活中的真实理念
3、符合面向对象思想
针对不同的逻辑对象抽取出来不同的类，封装本类中具有的独有方法实现。
- 一对多
一个省份有多个城市
@Test
public void test() {
//添加省份同时添加省份的城市
Province p=new Province("湖南省");
City c=new City("长沙市");
City c1=new City("株洲市");
City c2=new City("湘潭市");
//互设
//省份集合添加城市
p.getCities().add(c);
p.getCities().add(c1);
p.getCities().add(c2);
//给城市设置省份
c.setProvince(p);
c1.setProvince(p);
c2.setProvince(p);
//添加到数据库
session.save(p);
//查询一个省份同时查询这个省份对应的城市
Province p=session.get(Province.class, 1);
System.out.println(p.getPname());
Set<City> cities=p.getCities();
for (City c : cities) {
System.out.println(c.getCname()+"\t"+c.getCid());
}
//查询一个城市同时查询这个城市对应的省份
City c=session.get(City.class, 1);
System.out.println(c.getCname()+c.getProvince().getPname()+c.getProvince().getPid());
//删除一个省份同时删除省份对应的城市
Province p=session.get(Province.class, 2);
p.setCities(null);
session.delete(p);
//删除一个城市 删除它的省份
City c=session.get(City.class, 7);
session.delete(c);
//给一个省份添加一个新的城市
Province p=session.get(Province.class, 3);
City c=new City("张家界市");
p.getCities().add(c);
c.setProvince(p);
session.save(c);
//给一个城市重新设置省份
Province p=session.get(Province.class, 3);
City c=session.get(City.class, 4);
p.getCities().add(c);
c.setProvince(p);
}
一对多关系说白了就是咱们在一个类中定义一个数据集合，一个对应多个数据，就叫一对多。
- 多对多
@Test
public void test() {
//添加学生 添加老师
Teacher t = new Teacher("谢超");
Teacher t1 = new Teacher("黄玲");
Student s = new Student("张三");
Student s1=new Student("李四") ;
//互设
t.getStudents().add(s);
t.getStudents().add(s1);
t1.getStudents().add(s);
t1.getStudents().add(s1);
s.getTeachers().add(t);
s.getTeachers().add(t1);
s1.getTeachers().add(t);
s1.getTeachers().add(t1);
//保存
session.save(t);
session.save(t1);
//找到所有的老师 同时找到所有老师的学生
List<Teacher> list=session.createQuery("from Teacher").list();
for (Teacher t : list) {
System.out.println(t.getTname());
Set<Student> teachers=t.getStudents();
for (Student s : teachers) {
System.out.println(s.getSname());
}
}
//找到一个老师找到他所有的学生
Teacher t=session.get(Teacher.class, 5);
System.out.println(t.getTname());*/
Set<Student> students=t.getStudents();
for (Student s : students) {
System.out.println(s.getSname());
}
//找到一个老师删除一个学生
Teacher t=session.get(Teacher.class, 5);
Student s=session.get(Student.class, 6);
t.getStudents().remove(s);
session.delete(s);
//找到一个老师添加一个学生
Teacher t=session.get(Teacher.class, 5);
Student s=new Student("小强");
t.getStudents().add(s);
s.getTeachers().add(t);
session.save(s);
//找到一个学生找到一个老师 给这个学生
Teacher t=session.get(Teacher.class, 6);
Student s=session.get(Student.class, 7);
t.getStudents().add(s);
s.getTeachers().add(t);
Student s=session.get(Student.class, 7);
s.setSname("王二");
session.update(s);
}
多对多又怎么理解呢？
一个用户可以属于多个集体（家人，朋友，同学），当然一个集体也包含了多个用户
- hql
@Test
public void test() {
/*Author a=new Author("新睿");
Book b=new Book("谢超狗东西");
Book b1=new Book("向荣狗东西");
a.getBooks().add(b);
a.getBooks().add(b1);
b.setAuthor(a);
b1.setAuthor(a);
session.save(a);*/
//查询持久化的数据
/*Author a=session.get(Author.class, 2);
System.out.println(a.getAname());
*/
//hql语句 hibernate query languange 操作的是实体类（对象）
/*String hql="select a from Author a";
//创建一个查询对象
Query query=session.createQuery(hql);
//获取结果
List<Author> list=query.list();
for (Author a : list) {
System.out.println(a.getAname());
}*/
//查询非持久态的数据
/*String hql="select a.aid,a.aname from Author a";
Query query=session.createQuery(hql);
List<Object[]> list=query.list();
for (Object[] obj : list) {
System.out.println(obj[0]+"\t"+obj[1]);
}*/
//使用hql查询持久态的数据 需要有对应的构造方法
/*String hql="select new Author(a.aid,a.aname) from Author a";
Query query=session.createQuery(hql);
List<Author> list=query.list();
for (Author a : list) {
System.out.println(a.getAname()+"\t"+a.getAid());
}*/
//批量修改
/*String hql="update Author a set a.aname='吴承恩'";
Query query=session.createQuery(hql);
int i=query.executeUpdate();
System.out.println(i);*/
//删除
/*String hql="delete from Author a where a.aname like '%承%'";
Query query=session.createQuery(hql);
int i=query.executeUpdate();
System.out.println(i);*/
//统计函数
/*String hql="select max(b.bid) from Book b";
Query query=session.createQuery(hql);
int max=(Integer) query.uniqueResult();//唯一的结果
System.out.println(max);*/
//统计表中数据的总行数
/*String hql="select count(b.bid) from Book b";
Query query=session.createQuery(hql);
long max=(Long) query.uniqueResult();//唯一的结果
System.out.println(max);*/
//占位符使用 ?
/*String hql="select a from Author a where a.aname like ?0 and a.aid >?1";
Query query=session.createQuery(hql)
.setParameter(0, "%新%")
.setParameter(1, 2);
List<Author> list=query.list();
for (Author a : list) {
System.out.println(a.getAname()+"\t"+a.getAid());
}*/
//指定占位符名称的方式
/*String hql="select a from Author a where a.aname like :aname and a.aid >:aid";
Query query=session.createQuery(hql).setParameter("aid", 2).setParameter("aname", "%新%");
List<Author> list=query.list();
for (Author a : list) {
System.out.println(a.getAname()+"\t"+a.getAid());
}*/
//集合的方式
/*String hql="delete from Author a where a.aid in :ids";
List<Integer> list=new ArrayList<Integer>();
list.add(5);
list.add(6);
Query query=session.createQuery(hql).setParameterList("ids",list);
int i=query.executeUpdate();
System.out.println(i);*/
//分页查询
/*String hql="select b from Book b";
//页数 当前页数
int pages=2;
//每页显示的行数
int pageSize=3;
//setMaxResults(arg0) 每一页显示的行数
Query query=session.createQuery(hql)
.setMaxResults(pageSize)
.setFirstResult((pages-1)*pageSize);
List<Book> list=query.list();
for (Book b : list) {
System.out.println(b.getBname()+"\t"+b.getBid());
}*/
}
12万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
