(15)hql初始化及常用的查询

最新推荐文章于 2022-04-07 19:52:08 发布
原创 最新推荐文章于 2022-04-07 19:52:08 发布 · 206 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Hibernate #hql初始化 #hql基本查询

本文详细介绍了使用Java ORM框架Hibernate进行数据库操作的具体实践，包括实体类定义、数据初始化、对象查询等多个方面，深入探讨了Hibernate的特性与用法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

@Entity
public class Classroom {
	private int id;
	private String name;
	private int grade;
	private Set<Student> stus;
	private Special special;
	
	public Classroom() {
	}
	public Classroom(int id) {
		// TODO 自动生成的构造函数存根
		this.id=id;
	}
	
	public Classroom(String name, int grade, Special special) {
		// TODO 自动生成的构造函数存根
		this.grade=grade;
		this.special=special;
		this.name=name;
	}
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	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 getGrade() {
		return grade;
	}
	public void setGrade(int grade) {
		this.grade = grade;
	}
	@OneToMany(mappedBy="classroom")
	@LazyCollection(LazyCollectionOption.EXTRA)
	public Set<Student> getStus() {
		return stus;
	}
	public void setStus(Set<Student> stus) {
		this.stus = stus;
	}
	@ManyToOne
	@JoinColumn(name="spe_id")
	public Special getSpecial() {
		return special;
	}
	public void setSpecial(Special special) {
		this.special = special;
	}
	
	
}
@Entity
public class Special {
private int id;
private String name;
private String type;
private Set<Classroom> clas;



public Special() {
}
public Special(String name, String type) {
	this.name=name;
	this.type=type;
}
public Special(int id) {
	// TODO 自动生成的构造函数存根
	this.id=id;
}
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
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 getType() {
	return type;
}
public void setType(String type) {
	this.type = type;
}
@OneToMany(mappedBy="special")
@LazyCollection(LazyCollectionOption.EXTRA)
public Set<Classroom> getClas() {
	return clas;
}
public void setClas(Set<Classroom> clas) {
	this.clas = clas;
}


}

@Entity
public class Student {
	private int id;//属性
	private String name;
	private String sex;
	private Classroom classroom;
	
	public Student() {}
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	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 getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	@ManyToOne
	@JoinColumn(name="c_id")
	public Classroom getClassroom() {
		return classroom;
	}
	public void setClassroom(Classroom classroom) {
		this.classroom = classroom;
	}
	public Student(String name, String sex, Classroom classroom) {
		this.name = name;
		this.sex = sex;
		this.classroom = classroom;
	}
	
	
}

1.@GeneratedValue(strategy = GenerationType.IDENTITY)，这样hibernate就不会创建hibernate_sequence

数据初始化:

class TestAdd {
	Random ran=new Random();
	@Test
	public void testAddSpecial() {
		Session session = null;
		session = util.HibernateUtil.getSession();
		try {
			session.beginTransaction();
			
			session.save(new Special("计算机教育","教育类"));
			session.save(new Special("计算机应用技术","高职类"));
			session.save(new Special("计算机网络技术","高职类"));
			session.save(new Special("计算机信息管理","高职类"));
			session.save(new Special("数学教育","教育类"));
			session.save(new Special("物理教育","教育类"));
			session.save(new Special("化学教育","教育类"));
			session.save(new Special("会计","高职类"));
			session.save(new Special("英语教育","教育类"));
			
			session.getTransaction().commit();
		} catch (HibernateException e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			if(session!=null) session.close();
		}
	}
	
	@Test
	public void testAddClassroom() {
		Session session = null;
		session =HibernateUtil.getSession();
		try {
			session.beginTransaction();
			
			session.save(new Classroom("计算机教育1班",2009,new Special(1)));
			session.save(new Classroom("计算机教育2班",2009,new Special(1)));
			session.save(new Classroom("计算机教育班",2010,new Special(1)));
			session.save(new Classroom("计算机教育班",2011,new Special(1)));
			session.save(new Classroom("计算机应用技术",2009,new Special(2)));
			session.save(new Classroom("计算机应用技术",2010,new Special(2)));
			session.save(new Classroom("计算机应用技术",2011,new Special(2)));
			session.save(new Classroom("计算机网络技术",2009,new Special(3)));
			session.save(new Classroom("计算机网络技术",2010,new Special(3)));
			session.save(new Classroom("计算机网络技术",2011,new Special(3)));
			session.save(new Classroom("计算机信息管理",2009,new Special(4)));
			session.save(new Classroom("计算机信息管理",2010,new Special(4)));
			session.save(new Classroom("计算机信息管理",2011,new Special(4)));
			session.save(new Classroom("数学教育1班",2009,new Special(5)));
			session.save(new Classroom("数学教育2班",2009,new Special(5)));
			session.save(new Classroom("数学教育3班",2009,new Special(5)));
			session.save(new Classroom("数学教育1班",2010,new Special(5)));
			session.save(new Classroom("数学教育2班",2010,new Special(5)));
			session.save(new Classroom("数学教育1班",2011,new Special(5)));
			session.save(new Classroom("数学教育2班",2011,new Special(5)));
			session.save(new Classroom("物理教育",2009,new Special(6)));
			session.save(new Classroom("物理教育",2010,new Special(6)));
			session.save(new Classroom("物理教育",2011,new Special(6)));
			session.save(new Special("化学教育","教育类"));
			session.save(new Classroom("化学教育",2009,new Special(7)));
			session.save(new Classroom("化学教育",2010,new Special(7)));
			session.save(new Classroom("化学教育",2011,new Special(7)));
			session.save(new Classroom("会计",2009,new Special(8)));
			session.save(new Classroom("会计",2010,new Special(8)));
			session.save(new Classroom("会计",2011,new Special(8)));
			session.save(new Classroom("英语教育A班",2009,new Special(9)));
			session.save(new Classroom("英语教育B班",2009,new Special(9)));
			session.save(new Classroom("英语教育A班",2010,new Special(9)));
			session.save(new Classroom("英语教育B班",2010,new Special(9)));
			session.save(new Classroom("英语教育A班",2011,new Special(9)));
			session.save(new Classroom("英语教育B班",2011,new Special(9)));
			session.save(new Classroom("选修课班A",2011,null));
			session.save(new Classroom("选修课班B",2011,null));
			session.getTransaction().commit();
		} catch (HibernateException e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			if(session!=null) session.close();
		}
	}
	
	@Test
	public void testgetNames() {
		for(int i=0;i<100;i++) {
			System.out.println(testGetName());
		}
	}
	
	
	
	@Test
	public String testGetName() {
		String[] name1 = new String[]{"孔","张","叶","李","叶","孔",
				"张","陈","刘","牛","夏","侯","令","令","赵","母","穆","倪",
				"称","程","王","刘","冬","吴","马","沈"};
		
		String[] name2 = new String[]{"凡","课","颖","页","源","都",
				"浩","皓","西","东","北","南","冲","昊","力","量","妮",
				"敏","捷","杰","坚","名","生","华","鸣","蓝","春","虎","刚","诚"};
		
		String[] name3 = new String[]{"吞","明","敦","刀","备","伟",
				"唯","楚","勇","诠","佺","河","正","震","点","贝","侠",
				"伟","大","凡","琴","青","林","星","集","财"};
		boolean three;
		if(ran.nextInt(50)<=45) {
			three=true;
		}else {
			three=false;
		}
		if(three) {
			String n1=name1[ran.nextInt(name1.length)];
			String n2=name2[ran.nextInt(name2.length)];
			String n3=name3[ran.nextInt(name3.length)];
			return n1+n2+n3;
		}else {
			String n1=name1[ran.nextInt(name1.length)];
			int n=ran.nextInt(10);
			String n2;
			if(n>=5) {
				n2=name2[ran.nextInt(name2.length)];
			}else {
				n2=name3[ran.nextInt(name3.length)];
			}
			return n1+n2;
		}
	}
	@Test
	public void testAddStu() {
		Session session = null;
		session = util.HibernateUtil.getSession();
		try {
			session.beginTransaction();
			String[] sexs= new String[]{"男","女"};
			for(int i=1;i<=32;i++) {
				for(int j=1;j<=40;j++) {
					session.save(new Student(testGetName(), sexs[ran.nextInt(2)], new Classroom(i)));
				}
			}
			session.getTransaction().commit();
		} catch (HibernateException e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			if(session!=null) session.close();
		}
	}
	
	@Test
	public void testAddStuNoCla() {
		Session session = null;
		session = util.HibernateUtil.getSession();
		try {
			session.beginTransaction();
			String[] sexs= new String[]{"男","女"};
			
				for(int j=1;j<=100;j++) {
					session.save(new Student(testGetName(), sexs[ran.nextInt(2)], null));
				}
				
			session.getTransaction().commit();
		} catch (HibernateException e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			if(session!=null) session.close();
		}
	}
}

数据初始化，有时只需要一个对象具有id即可，比如为cla设置spe_id，只需要传入一个special对象，里面有id值即可

test01：

@Test
	void test01() {
		Session s=null;
		try {
			s=HibernateUtil.getSession();
		    
			Query query=s.createQuery("from Special");
			List<Special> spes=query.list();
			for(Special spe:spes) {
				System.out.println(spe.getName());
			}
		} catch (Exception e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
			s.getTransaction().rollback();
		}finally {
			HibernateUtil.closeSession(s);
		}
	}

hql是基于对象查询的 

test02：

void test02() {
		Session s=null;
		try {
			s=HibernateUtil.getSession();
		    
			Query query=s.createQuery("select spe from Special spe");
			List<Special> spes=query.list();
			for(Special spe:spes) {
				System.out.println(spe.getName());
			}
		} catch (Exception e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
			s.getTransaction().rollback();
		}finally {
			HibernateUtil.closeSession(s);
		}
	}

select spe from Special spe，注意语句都要在对象Special后加一个别名spe，然后select xx，要去什么对象使用别名即可

test03：

void test03() {
		Session s=null;
		try {
			s=HibernateUtil.getSession();
		    
			Query query=s.createQuery("select stu from Student stu where name like '%张%'");
			List<Student> stus=query.list();
			for(Student stu:stus) {
				System.out.println(stu.getName());
			}
		} catch (Exception e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
			s.getTransaction().rollback();
		}finally {
			HibernateUtil.closeSession(s);
		}
	}

test04:

void test04() {
		Session s=null;
		try {
			s=HibernateUtil.getSession();
		    
			Query query=s.createQuery("select stu from Student stu where name like ?0").setParameter(0, "%李%");
			List<Student> stus=query.list();
			for(Student stu:stus) {
				System.out.println(stu.getName()+","+stu.getSex());
			}
		} catch (Exception e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
			s.getTransaction().rollback();
		}finally {
			HibernateUtil.closeSession(s);
		}
	}

注意:（1）.避免sql注入攻击

（2）.新版的hibernate like ？0，然后在setParameter(0,xx),记得在？后面加索引，什么数都可以，前后对应即可

test05:

	void test05() {
   		Session s=null;
   		try {
   			s=HibernateUtil.getSession();
   		    
   			Query query=s.createQuery("select stu from Student stu where name like ?0 and sex=:sex").setParameter(0, "%李%").setParameter("sex", "男");
   			List<Student> stus=query.list();
   			for(Student stu:stus) {
   				System.out.println(stu.getName()+","+stu.getSex());
   			}
   		} catch (Exception e) {
   			// TODO 自动生成的 catch 块
   			e.printStackTrace();
   			s.getTransaction().rollback();
   		}finally {
   			HibernateUtil.closeSession(s);
   		}
   	}

注意:（1）.基于别名查询

test06：

 	void test06() {
   		Session s=null;
   		try {
   			s=HibernateUtil.getSession();
   		    
   			long count=(long) s.createQuery("select count(*) from Student where name like ?0").setParameter(0, "%李%").uniqueResult();
   			System.out.println(count);
   		} catch (Exception e) {
   			// TODO 自动生成的 catch 块
   			e.printStackTrace();
   			s.getTransaction().rollback();
   		}finally {
   			HibernateUtil.closeSession(s);
   		}
   	}

注意:（1）.返回的count是long对象

test07：

void test07() {
   		Session s=null;
   		try {
   			s=HibernateUtil.getSession();
   		    
   			Student student=(Student) s.createQuery("select stu from Student stu where id=:id").setParameter("id", 1).uniqueResult();
   			System.out.println(student.getName());
   		} catch (Exception e) {
   			// TODO 自动生成的 catch 块
   			e.printStackTrace();
   			s.getTransaction().rollback();
   		}finally {
   			HibernateUtil.closeSession(s);
   		}
   	}

注意：(1).使用uniqueResult();就是仅仅只返回一个对象，使用list返回的就是list数组

test08：

 	void test08() {
   		Session s=null;
   		try {
   			s=HibernateUtil.getSession();
   		    
   			List<Object[]> objs=s.createQuery("select stu.sex,count(*) from Student stu group by stu.sex").list();
   			for(Object[] obj:objs) {
   				System.out.println(obj[0]+":"+obj[1]);
   			}
   		} catch (Exception e) {
   			// TODO 自动生成的 catch 块
   			e.printStackTrace();
   			s.getTransaction().rollback();
   		}finally {
   			HibernateUtil.closeSession(s);
   		}
   	}

 注意：(1).该sql语句返回的是List<Object[]>

test09:

	void test09() {
   		Session s=null;
   		try {
   			s=HibernateUtil.getSession();
   		    
   			List<Student> objs=s.createQuery("select stu from Student stu where stu.classroom.id = :cla_id").setParameter("cla_id", 1).list();
   			for(Student obj:objs) {
   				System.out.println(obj.getId()+":"+obj.getName());
   			}
   		} catch (Exception e) {
   			// TODO 自动生成的 catch 块
   			e.printStackTrace();
   			s.getTransaction().rollback();
   		}finally {
   			HibernateUtil.closeSession(s);
   		}
   	}

 注意：(1).where stu.classroom.id=xx，此时会自动完成连接，不过该连接效率较低

test10:

void test10() {
   		Session s=null;
   		try {
   			s=HibernateUtil.getSession();
   		    
   			List<Student> objs=s.createQuery("select stu from Student stu where stu.classroom.id in (:cla_id) and stu.name like ?0").setParameter(0, "%张%").setParameterList("cla_id", new Integer[] {1,2}).list();
   			for(Student obj:objs) {
   				System.out.println(obj.getId()+":"+obj.getName());
   			}
   		} catch (Exception e) {
   			// TODO 自动生成的 catch 块
   			e.printStackTrace();
   			s.getTransaction().rollback();
   		}finally {
   			HibernateUtil.closeSession(s);
   		}
   	}

注意:（1）：先setParameter再setParameterList，然后使用in必须基于别名，即in （：cla_id），然后再setParameterList("cla_id",new integer[]{1,2})

test11:

	void test11() {
   		Session s=null;
   		try {
   			s=HibernateUtil.getSession();
   		    
   			List<Student> objs=s.createQuery("select stu from Student stu where stu.classroom.id in (:cla_id)").setParameterList("cla_id", new Integer[] {1,2}).setFirstResult(0).setMaxResults(20).list();
   			for(Student obj:objs) {
   				System.out.println(obj.getId()+":"+obj.getName());
   			}
   		} catch (Exception e) {
   			// TODO 自动生成的 catch 块
   			e.printStackTrace();
   			s.getTransaction().rollback();
   		}finally {
   			HibernateUtil.closeSession(s);
   		}
   	}

注意:（1）：分页可以设置setFirstResult（0）及setMaxResults(20),前者表示取索引0开始的数据，MaxResult表示一页最大容量

test12：

  @Test
   	void test12() {
   		Session s=null;
   		try {
   			s=HibernateUtil.getSession();
   		    
   			List<Student> objs=s.createQuery("select stu from Student stu where stu.classroom is null").list();
   			for(Student obj:objs) {
   				System.out.println(obj.getId()+":"+obj.getName());
   			}
   		} catch (Exception e) {
   			// TODO 自动生成的 catch 块
   			e.printStackTrace();
   			s.getTransaction().rollback();
   		}finally {
   			HibernateUtil.closeSession(s);
   		}
   	}

注意:（1）：可以使用stu.classroom is null，不能使用stu.classroom = null。

 

常用的hql语句用法解析
10-10
`fetch`连接允许在查询中初始化相关联的对象，例如`from Cat as cat inner join fetch cat.mate`，这在处理集合时特别有用，它可以替代映射文件中的外联接和延迟加载设置。但`fetch`连接不应在使用`scroll()`或`...
HQL Hibernate查询语言
12-02
此外，还有一个"fetch"连接允许仅仅使用一个选择语句就将相关联的对象或一组值的集合随着他们的父对象的初始化而被初始化，这种方法在使用到集合的情况下尤其有用，对于关联和集合来说，它有效的代替了映射文件中的...
HQL 随机抽取数据，无重复
客人的博客
04-06 1028
几天晚上在做那个在线教学，要随机抽取选择题和判断题，实现了，代码贴出来备用 [code="java"] public HashSet querySelectQues(){ try { //set放结果，无重复 HashSet result = new HashSet(); //查询出所有选择题（因为所有的题在一起放着）...
Hibernate HQL基础 限定查询条件
weixin_34309435的博客
10-10 292
在HQL中可以使用表达式完成指定的运算或者作为限制查询结果的条件。如下表所示|-----------------------------------------------------------|| 类别 | 运算符 ||---------------------------|-----...
数组里随机取出一个值
hql1024的博客
12-28 1837
var arr = ["被表白","好运连连","遍地桃花","升职","加薪","健康","出名","暴富","瘦成闪电"]; var sar = Math.floor((Math.random()*arr.length)); console.log(arr[sar]); ...
Hibernate 随机获取100条记录
哈哈__哈哈的专栏
11-04 375
Hibernate执行的话效率太低，我数据库才3000条左右，就用了5秒时间。 建议用jdbc执行 [code="java"]finder = new Finder("") .append(" FROM Event21 ORDER BY RAND() "); int size = find(finder).size(); Random r = new Random(); ...
HibernateUtil分装完整版HQL查询
07-06
本教程将详细讲解如何使用HibernateUtil工具类封装HQL查询，从初始化配置到执行查询、管理事务，再到对象的持久化操作，旨在帮助开发者更高效地使用Hibernate进行数据库操作。通过学习这些内容，你可以更好地理解...
Hibernate HQL查询语言大全：完整实例与注释分享
HQL能够处理集合的初始化和过滤。 ####5. 内置函数和操作符 HQL支持SQL中常见的函数和操作符，例如：like、between、in、is null等。同时，它还提供了一些面向对象的内置函数，比如size()、avg()、max()、min()等。...
Hibernate操作实践：示例及数据库初始化指南
- **查询操作**：Hibernate提供HQL、Criteria以及原生SQL等多种查询方式，使用这些方式可以实现复杂的查询需求。 ### 描述知识点 **数据库初始化文件** 意味着在Hibernate操作中，需要有数据库表的初始结构，通常...
sql初始化文件的写法
Simpson_wu的博客
08-26 1042
sqlplus sys/tiger as sysdba @init.sql@声明变量，表示引用自己定义的一个变量，或文件 @@表示在引用系统函数init.sql文件：drop user 账号 cascade;//级联删除create user 账号 identified by 密码;grant connect,resource to 账号;//赋予权限conn 账号/密码;//引用其他sql语句
HQL查询对象实战详解
oLengYueHun的博客
04-02 517
1.项目结构及目标数据库： 2.hql配置文件： <?xml version='1.0' encoding='utf-8'?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate...
hql如何使用count
hello
10-01 1万+
//第一种方法：   String hql = "select count(*) from User as user";   Integer count = (Integer)getHibernateTemplate().find(hql).listIterator().next();   return count.intValue(); //第二种方法：  String hql =
HQL语句 使用new 关键字出错的原因
super005的专栏
11-06 563
  1. 映射类里没有构造方法.  select new Wenzhang(id,biaoti) from Wenzhang  Wenzhang这个映射类要有  public Wenzhang(Integer id,String biaoti)这个构造方法
Hive中对array类型字段的处理
热门推荐
止鱼
01-23 8万+
现在有一张表，2个字段，字段A：id, 字段B：array类型： col_name data_type gameid int businesstype array select gameid, businesstype from kua.tablea where date=20190122 limit 5; +-----------+-------------------...
hibernate hql new对象时如果包含Timestamp字段
nonobabaya的博客
11-20 248
我在编写hql语句时，报了一个错误org.hibernate.hql.internal.ast.QuerySyntaxException：: Unable to locate appropriate constructor on class ，但是的定位的大致原因是因为我写了一个Student类，对应的数据库的student表，表中有五个字段，id,name,gender,age,createTi...
HIVE hql 中的count 高级使用方法
04-07 1679
count(*)和count(1)：对表中行数进行统计计算，包含null值。 count(某字段)：对表中该字段的行数进行统计，不包含null值。如果出现空字符串，同样会进行统计。 SELECT type , count(*) , count(DISTINCT u) , count(CASE WHEN plat=1 THEN u ELSE NULL END) , count(DISTINCT CASE WHEN plat=1 THEN u ELSE NULL END) , cou
HQL查询
ZhangGuozhong's Blog
08-09 2995
HQL查询：Criteria查询对查询条件进行了面向对象封装，符合编程人员的思维方式，不过HQL(Hibernate Query Lanaguage)查询提供了更加丰富的和灵活的查询特性，因此Hibernate将HQL查询方式立为官方推荐的标准查询方式，HQL查询在涵盖Criteria查询的所有功能的前提下，提供了类似标准SQL语句的查询方式，同时也提供了更加面向对象的封装。完整的HQL语
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值