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 ...
随机推荐
- Flume(4)-监控模型
一. 监控端口数据 首先启动Flume任务,监控本机44444端口,服务端: 然后通过netcat工具向本机44444端口发送消息,客户端: 最后Flume将监听的数据实时显示在控制台. 1. 安装n ...
- centos 安装 telnet
(转)centos7安装telnet服务 场景:在进行Telnet测试时候,发现无法连接,所以还得把这个软件也安装了 1 CentOS7.0 telnet-server 启动的问题 解决方法: 先 ...
- Python使用代理的方法
我们在做爬虫的过程中经常会遇到这样的情况:最初爬虫正常运行,正常抓取数据,一切看起来都是那么的美好,然而一杯茶的功夫可能就会出现错误,比如403 Forbidden:出现这样的原因往往是网站采取了一些 ...
- 使用xadmin更新数据时，报错expected string or bytes-like object
expected string or bytes-like object 期望的字符串或类似字节的对象,一般为数据类型不匹配造成 本人在实际项目里发现的问题是: 数据库里的字段类型与django里mo ...
- Java学习笔记三十:Java小项目之租车系统
Java小项目之租车系统 一:项目背景介绍: 根据所学知识,编写一个控制台版的“呱呱租车系统” 功能: 1.展示所有可租车辆: 2.选择车型.租车量: 3.展示租车清单,包含:总金额.总载货量以及其车 ...
- 20155212 实验一《Java开发环境的熟悉》实验报告
20155212 实验一<Java开发环境的熟悉>实验报告 命令行下Java程序开发 命令创建实验目录 输入mkdir 2051212创建以自己学号命名的文件夹,通过cd 20155212 ...
- 实验楼学习linux第一章第三节用户及文件权限管理
用户及文件权限管理 常用命令 查看用户 whoami 创建用户 sudo adduser 用户名 切换账户 su 用户名 删除账户 sudo deluser 用户名 --remove-home 查看用 ...
- 20155317 2016-2017-2 《Java程序设计》第十学习总结
20155317 2016-2017-2 <Java程序设计>第十学习总结 教材学习内容总结 1.网络编程的概念: 网络编程就是在两个或两个以上的设备(例如计算机)之间传输数据.程序员所作 ...
- WPF DataGridTable
由于项目要显示表头合并,而数据源列随时变更,又不想重复的画表格,就实现动态数据(dynamic)绑定和配置数据列模板的方式 编辑DataGridColumnHeader样式实现表头合并:效果如下 实现 ...
- 搜索引擎ElasticSearch系列（二）： ElasticSearch2.4.4 Head插件安装
一:ElasticSearch Head插件简介 elasticsearch-head is a web front end for browsing and interacting with an ...