Hibernate理解

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>
  1. 实体类和表关系的映射
    class 实体类的全限定名称
    table 数据库的表名
    id为数据库的默认主键
    type:该属性的java数据类型
    column:列名 对应的数据库的列名
    property:属性 实体类的属性
    generator:主键生成策略 主键的值是怎么产生的
    native:主键生成的自增长

  2. hibernate中关于对象的三种状态
    自由态:session空间中没有这个对象(该对象没有纳入了session的管理范围),数据库中也没有与之对应的数据
    持久态:session空间中有这个对象(该对象纳入了session的管理范围),数据库中有与之对应的数据
    持久态的数据 对象中的属性值与数据库中的数据保持一致 ,如果不一致会发生同步更新 发送修改语句
    游离态:session空间中没有这个对象(该对象没有纳入了session的管理范围),数据库中有与之对应的数据

少的一方级联 cascade
多的一方维护关系 inverse

  1. 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());
		}*/
		
  1. 一对一
    一个人和一张身份证
@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、符合面向对象思想

针对不同的逻辑对象抽取出来不同的类,封装本类中具有的独有方法实现。

  1. 一对多
    一个省份有多个城市
@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);
	}

一对多关系说白了就是咱们在一个类中定义一个数据集合,一个对应多个数据,就叫一对多。

  1. 多对多
@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);		
	}

多对多又怎么理解呢?
一个用户可以属于多个集体(家人,朋友,同学),当然一个集体也包含了多个用户

  1. 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());
		}*/
	}
  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值