Hibernate（六）
三套查询之HQL查询
hql语句(面向)：类 对象 属性
package com.rong.entity.hql;
public class User {
public User(int id, String name) {
super();
this.id = id;
this.name = name;
}
public User() {
super();
}
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;
}
}
package com.rong.entity.hql; import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id; @Entity
public class Student {
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
private int id;
private String name;
private int age;
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 int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package com.rong.entity.hql; import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set; import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
//hql语句(面向)：类 对象 属性
public class TestHQL {
SessionFactory sessionFactory;
Session session;
Transaction transaction;
@Before
public void init() {
Configuration configuration = new Configuration().configure();
ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder()
.applySettings(configuration.getProperties()).build();
sessionFactory=configuration.buildSessionFactory(serviceRegistry);
session = sessionFactory.openSession();
transaction = session.beginTransaction(); }
//插入数据
@Test
public void addData(){
Student student=null;
for(int i=1;i<=100;i++){
student=new Student();
student.setAge(i);
student.setName("先生"+i);
session.save(student);
}
}
//查询所有的学生 (所有列)
@Test
public void test1(){
Query query = session.createQuery("from Student");//Student是类名
List<Student> list = query.list();
System.out.println(list.size());
for (Student student : list) {
System.out.println(student.getAge()+student.getName());
}
}
//查询所有的学生当中的某一列
@Test
public void test2(){
//Student是类名，name是Student类的成员变量名
Query query = session.createQuery("select s.name from Student s");
List<Student> list = query.list();
System.out.println(list);
}
//查询所有学生中的多列
@Test
public void test3(){
Query query = session.createQuery("select s.name,s.age from Student s");
//Query query = session.createQuery("select name,age from Student s");
List<Object[]> list = query.list();
//list集合的每一个元素都是数组，而每一个数组都是由name和age构成
for (Object[] objects : list) {
for (Object object : objects) {
System.out.print(object);
}
System.out.println();
}
}
//分页查询
@Test
public void test4(){
//Query query = session.createQuery("select s from Student s");
Query query = session.createQuery("from Student");
query.setFirstResult(0);//设置从哪里开始
query.setMaxResults(3);//分页的条目
List<Student> list = query.list();
for (Student student : list) {
System.out.println(student.getAge()+student.getName());
}
}
//查询所有的学生的某些字段 返回值是map类型,即获取List<Map<String,Object>>结果
@Test
public void test5(){
//这个是没有别名的
//Query query = session.createQuery("select new map(s.name,s.age) from Student s");
//这个有别名的(修改key的值 就需要增加别名)
Query query = session.createQuery("select new map(s.name as name,s.age as age) from Student s");
List<Map<String,Object>> list = query.list();
//结果 key是 从0 开始的
//System.out.println(list);//[{0=先生1, 1=1}, {0=先生2, 1=2}, {0=先生3, 1=3}......]
System.out.println(list);//[{name=先生1, age=1}, {name=先生2, age=2}......]
for (Map<String, Object> map : list) {
Set<Entry<String, Object>> set = map.entrySet();
Iterator<Entry<String, Object>> iterator = set.iterator();
while(iterator.hasNext()){
Entry<String, Object> entry = iterator.next();
System.out.println(entry.getKey()+entry.getValue());
}
}
}
//查询所有的学生的某些字段，返回值是list类型,即获取List<List<Object>>结果
@Test
public void test6(){
Query query = session.createQuery("select new list(s.name,s.age) from Student s");
List<List<Object>> list = query.list();
for (List<Object> li : list) {
for (Object object : li) {
System.out.print(object);
}
System.out.println();
}
}
//查询student表，返回值是User,User类必须要有public User(int id, String name)的构造方法！！！
@Test
public void test7(){
Query query = session.createQuery("select new com.rong.entity.hql.User(s.id,s.name) from Student s");
List<User> list = query.list();
for (User user : list) {
System.out.println(user.getId()+user.getName());
}
} @After
public void destroy(){
transaction.commit();
session.close();
sessionFactory.close();
}
}
关联(持久化类)与连接(数据库表)
package com.rong.entity.myhql; import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne; @Entity
public class Teacher {
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
private int tid;
private String tname;
@OneToOne(targetEntity=Student.class,fetch=FetchType.LAZY,mappedBy="teacher")
private Student student;
public int getTid() {
return tid;
}
public void setTid(int tid) {
this.tid = tid;
}
public String getTname() {
return tname;
}
public void setTname(String tname) {
this.tname = tname;
}
}
package com.rong.entity.myhql; 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.OneToOne; @Entity
public class Student {
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
private int id;
private String name;
private int age;
@OneToOne(targetEntity=Teacher.class,fetch=FetchType.LAZY)
@JoinColumn(name="t_id",referencedColumnName="tid",unique=true)
private Teacher teacher;
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 int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Teacher getTeacher() {
return teacher;
}
public void setTeacher(Teacher teacher) {
this.teacher = teacher;
}
}
package com.rong.entity.myhql; import java.util.List; import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
//hql语句(面向)：类 对象 属性
public class TestHQL {
SessionFactory sessionFactory;
Session session;
Transaction transaction;
@Before
public void init() {
Configuration configuration = new Configuration().configure();
ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder()
.applySettings(configuration.getProperties()).build();
sessionFactory=configuration.buildSessionFactory(serviceRegistry);
session = sessionFactory.openSession();
transaction = session.beginTransaction(); }
//插入数据
@Test
public void addData(){
Student student=null;
Teacher teacher=null;
for(int i=1;i<=20;i++){
teacher=new Teacher();
teacher.setTname("老师"+i);
student=new Student();
student.setAge(i);
student.setName("学生"+i);
student.setTeacher(teacher);
session.save(teacher);
session.save(student);
}
}
//1.隐式关联(不需要写join语句)
//查询时，关联的属性是一个持久化类. @ManyToOne、@OneToOne
@Test
public void test1(){
Query query = session.createQuery("select s from Student s where s.teacher.tid=?");
query.setParameter(0, 3);
List<Student> list = query.list();
for(int i=0;i<list.size();i++){
Student student = list.get(i);
//3学生333老师3
System.out.println(student.getId()+student.getName()+student.getAge()
+student.getTeacher().getTid()+student.getTeacher().getTname());
} }
//2.显示关联(需要写join语句)
//注意：若使用@OneToMany、@ManyToMany查询时，关联的属性是一个Set集合. 这里使用@OneToOne
@Test
public void test2(){
//注意： inner join 后边的类 要写 属性 inner join s.teacher
Query query = session.createQuery("select s from Student s inner join s.teacher t where t.tid=?");
query.setParameter(0, 18);
Object uniqueResult = query.uniqueResult();
Student student=(Student)uniqueResult;
//18学生1818老师18
System.out.println(student.getId()+student.getName()+student.getAge()
+student.getTeacher().getTname());
}
//3.抓取连接(查询延迟的属性)
//查询时，关联的属性配置了延迟加载的，但本次查询要查询出来.join fetch 关联的属性
@Test
public void test3(){
//查两次，要配置延迟加载
//这里肯定是把Student查出来了。但是Student中的teacher属性还没有查数据库
//因为Student的teacher属性配置了懒加载fetch=FetchType.LAZY
Query query = session.createQuery("select s from Student s");
List<Student> list = query.list();
Student student = list.get(0);
//要真正使用Teacher了。所以要去查数据库。
System.out.println(student.getTeacher().getTname()); System.out.println("=======================================");
//查一次，要配置延迟加载
//就是teacher属性虽然是懒加载的，但是我们通过join fetch直接把懒加载的属性全部查出来。
Query query2 = session.createQuery("select s from Student s join fetch s.teacher");
List<Student> list2 = query2.list();
Student student2 = list.get(0);
System.out.println(student2.getTeacher().getTname());//这里不会再发sql了。
}
@After
public void destroy(){
transaction.commit();
session.close();
sessionFactory.close();
}
}
排序order by
分组group by
package com.rong.entity.group; import java.util.HashSet;
import java.util.Set; import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany; @Entity
public class Teacher {
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
private int tid;
private String tname;
@OneToMany(targetEntity=Student.class,fetch=FetchType.LAZY,mappedBy="teacher")
private Set<Student> students=new HashSet<Student>();
public int getTid() {
return tid;
}
public void setTid(int tid) {
this.tid = tid;
}
public String getTname() {
return tname;
}
public void setTname(String tname) {
this.tname = tname;
}
public Set<Student> getStudents() {
return students;
}
public void setStudents(Set<Student> students) {
this.students = students;
}
}
package com.rong.entity.group; 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.ManyToOne; @Entity
public class Student {
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
private int id;
private String name;
private int math;
private int java;
@ManyToOne(targetEntity=Teacher.class,fetch=FetchType.LAZY)
@JoinColumn(name="t_id",referencedColumnName="tid")
private Teacher teacher;
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 int getMath() {
return math;
}
public void setMath(int math) {
this.math = math;
}
public int getJava() {
return java;
}
public void setJava(int java) {
this.java = java;
}
public Teacher getTeacher() {
return teacher;
}
public void setTeacher(Teacher teacher) {
this.teacher = teacher;
}
}
package com.rong.entity.group; import java.util.List;
import java.util.Random; import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
//hql语句(面向)：类 对象 属性
public class TestHQL {
SessionFactory sessionFactory;
Session session;
Transaction transaction;
@Before
public void init() {
Configuration configuration = new Configuration().configure();
ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder()
.applySettings(configuration.getProperties()).build();
sessionFactory=configuration.buildSessionFactory(serviceRegistry);
session = sessionFactory.openSession();
transaction = session.beginTransaction();
}
//随机生成名字
public String randomName(){
String string="abcdefghijklmnopqrstuvwxyz";
StringBuilder stringBuilder=new StringBuilder();
Random random=new Random();
for(int i=0;i<4;i++){
int index = random.nextInt(string.length());
char charAt = string.charAt(index);
stringBuilder.append(charAt);
}
return stringBuilder.toString();
}
//插入数据
@Test
public void addData(){
Teacher teacher1=new Teacher();
teacher1.setTname("龙老师");
session.save(teacher1);
Teacher teacher2=new Teacher();
teacher2.setTname("高老师");
session.save(teacher2);
Random random=new Random();
for(int i=1;i<=100;i++){
Student student=new Student();
student.setName(randomName());
student.setJava(random.nextInt(100)+1);
student.setMath(random.nextInt(100)+1);
if(random.nextInt(2)==0){
student.setTeacher(teacher1);
}else{
student.setTeacher(teacher2);
}
session.save(student);
}
}
//1.根据老师分组统计学生数量(统计每位老师的学生数量)
@Test
public void test1(){
Query query = session.createQuery("select count(s),s.teacher.tname from Student s group by s.teacher.tname");
List<Object[]> list = query.list();
//46高老师
//54龙老师
for (Object[] objects : list) {
for (Object object : objects) {
System.out.print(object);
}
System.out.println();
}
}
//2.根据老师分组统计学生平均分,总分数
@Test
public void test2(){
Query query = session.createQuery("select sum(s.java+s.math),avg(s.java+s.math),s.teacher.tname from Student s group by s.teacher.tname");
List<Object[]> list = query.list();
//4659 101.2826 高老师
//5256 97.3333 龙老师
for (Object[] objects : list) {
for (Object object : objects) {
System.out.print(object+" ");
}
System.out.println();
}
} @After
public void destroy(){
transaction.commit();
session.close();
sessionFactory.close();
}
}
分组过滤having
//根据老师分组统计学生平均分,总分数，并且把老师为1的过滤出来
@Test
public void test3(){
Query query = session.createQuery("select avg(s.java+s.math),sum(s.java+s.math),s.teacher.tname,s.teacher.tid from Student s group by s.teacher.tname having s.teacher.tid=?");
query.setParameter(0, 1);
List<Object[]> list = query.list();
//97.3333 5256 龙老师 1
for (Object[] objects : list) {
for (Object object : objects) {
System.out.print(object+" ");
}
System.out.println();
}
}
聚集函数(统计函数)
//聚集函数(统计函数) count max min avg sum
@Test
public void test4(){
Long count=(Long) session.createQuery("select count(*) from Student").uniqueResult();
System.out.println("学生总人数："+count);
int max=(int) session.createQuery("select max(s.java) from Student s").uniqueResult();
System.out.println("java最高成绩："+max);
int min=(int) session.createQuery("select min(s.math) from Student s").uniqueResult();
System.out.println("math最低成绩："+min);
double avg = (double) session.createQuery("select avg(s.java+s.math) from Student s").uniqueResult();
System.out.println("每位学生的平均总成绩："+avg);
Long sum = (Long) session.createQuery("select sum(s.java+s.math) from Student s").uniqueResult();
System.out.println("所有学生的总成绩之和："+sum);
}
Hibernate（六）的更多相关文章
- Hibernate(六)一对多映射(多对一)
一.Hinbernate中持久化类的关联关系 在数据库中,表表之间是通过外键关联的,在程序中是要转化为持久化类也就是(JAVA Bean)来实例的. 但在Hibernater中持久化的之间的映射关系, ...
- hibernate(六) cascade(级联)和inverse关系详解
序言 写这篇文章之前,自己也查了很多的资料来搞清楚这两者的关系和各自所做的事情,但是百度一搜,大多数博文感觉说的云里雾里,可能博主自己清楚是怎么一回事,但是给一个不懂的人或者一知半解的人看的话,别人也 ...
- Hibernate(六)__对象的三种状态
瞬时(transient):数据库中没有数据与之对应,超过作用域会被JVM垃圾回收器回收,一般是new出来且与session没有关联的对象. 持久(persistent):数据库中有数据与之对应,当前 ...
- Hibernate(六)
================================缓存============================定义:介于应用程序和永久性数据存储源之间,可以复制数据存储源中的数据. 工作 ...
- Hibernate(六)--缓存策略
缓存: 缓存就是数据库数据在内存中的临时容器,包括数据库数据在内存中的临时拷贝,它位于数据库与数据库访问中间层,ORM在查询数据时,首先会根据自身的缓存管理策略,在缓存中查找相关数据,如果发现所需的数 ...
- Hibernate常用接口
Hibernate的接口类型 在了解了Hibernate的基本配置,映射文件后,道路已经铺平了.我们继续往前走.接下来,我们应该做的是了解Hibernate常用的接口,对Hibernate的工作方式进 ...
- 22Java之JDBCTemplate总结
写在前面:这里总结4种方式来操作数据库(SE阶段) 一.JDBC JDBC有关的类:都在java.sql 和 javax.sql 包下. 1.数据准备 ...
- 攻城狮在路上（壹） Hibernate（十六）--- Hibernate声明数据库事务
一.数据库事务的概念: 数据库的ACID特征:Atomic.Consistency.Isolation.Durability.原子性.一致性.隔离性.持久性.不同的隔离级别引发的不同问题. 事务的AC ...
- 攻城狮在路上（壹） Hibernate（六）--- 通过Hibernate操纵对象（上）
一.Hibernate缓存简介: Session接口是Hibernate向应用程序提供的操纵数据接口的最主要接口,它提供了基本的保存.更新.删除和加载Java对象的方法. Session具有一个缓存, ...
- HIbernate学习笔记（六） 关系映射之多对多
六.多对多 - 单向 Ø 一般的设计中,多对多关联映射,需要一个中间表 Ø Hibernate会自动生成中间表 Ø Hibernate使用many-to-ma ...
随机推荐
- Oracle之plsql及游标
--1.赋值 --:= 赋值 declare var_name ) :='&请输入名字';--&是一个提示输入的特殊符号,会打开一个输入框 var_age ) :='&请输入年 ...
- TCP交互流程
前言:在FPGA上实现TCP协议实际是一个不太好的计划,因为FPGA最擅长的是流水线处理方式,而TCP存在交互,导致FPGA需要进行反馈式的处理.但是由于项目新增的附加要求而又只能在FPGA上去实现T ...
- STM32串口一直进中断
调试过程中遇到了使用串口什么都没接却一直进中断,接串口线到电脑上测试又正常的问题. 网上有人说需要将USART的RX模式从输入浮空改成输入上拉,改后测试正常,问题解决. 分析可能是什么都不接时浮空模式 ...
- linux编程实现pwd命令
linux编程实现pwd命令 在linux中,一切皆文件.目录其实也是一种文件,只不过这种文件比较特殊,它里面存储的是一张对应表,即文件名和i节点的对应关系表,而i节点才是记录此文件详细信息的结构,如 ...
- 20155222 2016-2017-2 《Java程序设计》第9周学习总结
20155222 2016-2017-2 <Java程序设计>第9周学习总结 教材学习内容总结 JDBC是用于执行SQL的解决方案,开发人员使用JDBC的标准接口,开发人员使用JDBC的标 ...
- 20155334 2016-2017-2《Java程序设计》课程总结
20155334 2016-2017-2<Java程序设计>课程总结 1. 每周作业链接汇总 题目 主要内容 二维码 预备作业1 不知道所以然的第一次博客 预备作业2 有关之前的C语言的调 ...
- 对PostgreSQL数据库的hstore类型建立GisT索引的实验
磨砺技术珠矶,践行数据之道,追求卓越价值回到上一级页面:PostgreSQL基础知识与基本操作索引页 回到顶级页面:PostgreSQL索引页[作者 高健@博客园 luckyjackgao@g ...
- [arc082E]ConvexScore-[凸包]
Description 传送门 Solution em又是神仙题. 考虑到目前的一个凸包,顶点点集为S. 现在在它内部或边缘上的点集为T,则贡献为2|T|−|S|,设从T中去掉S的点后得到了集合A.则 ...
- 【LG5021】[NOIP2018]赛道修建
[LG5021][NOIP2018]赛道修建 题面 洛谷 题解 NOIP之前做过增强版还没做出来\(QAQ\) 一看到题目中的最大值最小,就很容易想到二分答案 重点是考虑如何\(check\) 设\( ...
- Mysql：存储过程游标不进循环的原因详解
------------吾亦无他,唯手熟尔,谦卑若愚,好学若饥------------- 本篇博客给刚接触存储过程的朋友做个引导作用,目的是解决游标不走循环 很多人发现他的游标,无论是嵌套循环还是单层 ...