`

Hibernateday06 HQL(Hibernate Query Language)

 
阅读更多

HQL(hibernate query language)   SQL(stander query language)
Hibernate的标准开发:O-->R--->M--->调用Hibernate的API
  核心API: Configuration-->SessionFactory-->Session-->Transaction
                                              |-->Query
   Session内部封装Connection,提供的CRUD依赖于主键
   进行非主键的查询:Query
     Query query=session.createQuery(HQL);
查询employee中的所有数据
SQL:  select * from employee(表名);
HQL:  from Employee(类名);
      根据面向对象的思想,一张表就是一个类,表和类在映射文件中对应,所以from后面是类名而不是表名。因为通过映射文件,表当中的一行数据hibernate会自动封装成对应的对象,所以HQL无须select *

查询employee表中名字叫calm的员工
SQL: select * from employee where ename='calm';
HQL: from Employee as e where e.ename='calm'
     建议:在使用HQL执行条件查询时,要为类提供别名

HQL特点
   1.类似于SQL
   2.from 类名
   3.可以有也可以没有select
   4.在进行条件查询的时候要为类取别名  别名.属性名

  查询集合: query.list();
  单独对象:query.uninqueResult()

HQL 的基础开发
  1.查询工资为300到600的员工
     SQL:关键字between ....and /not between ...and
     SQL: select * from t_employee where t_salary between 300 and 600;
     HQL: from Employee as e where e.salary between 300 and 600;
  2.查询工资为100,300,600的员工
     SQL:关键字 in /not in
  3.查询工资为200并且名字叫bobs
     SQL:关键字 and/ or not
  4.查询以xiao开头的名字
     sql:关键字 like 'xiao%'
  5.查询没有工资的员工
     SQL:关键字 is null/ is not null
     select * from t_employee where t_salary is null;
     sql不能写等于null 但是hibernate可以写等于null


HQL的投射(投影)查询 Project查询,在HQL中加入了select关键字的查询
   HQL from Employee --》每一行封装成一个Employee对象(通过映射文件)
       List<Employee> emps=query.list()
   HQL hql=select e.name,e.salary from Employee as e;
       Query query=session.createQuery(hql);
         没有返回一整行的数据无法封装成Employee,hibernate会将需要获得的数据用Object[]封装
        List<Object[]> emps=query.list();
        如果查询的是一个结果,hibernate通过query.list()封装成一个List<Object>对象。
 聚合函数  sum(),max(),min(),avg(),count()
 HQL 也可以使用聚合函数
    sql:select max(t_salary),min(t_salary) from employee;
    Hql:select e.dept.id, max(e.salary),min(e.salary),avg(e.salary)
        from Employee as e group by e.dept.id;

平均工资大于300的部门的平均工资和最大工资
    select e.dept.id, max(e.salary),avg(e.salary)
    from Employee as e group by e.dept.id having avg(e.salary)>300;

隐式多表连接:通过关系属性的多表连接
    缺点:可能有多表连接,发送多条sql语句从而降低了系统效率
 查询bobs所在的部门
  from Dept as d where d.emps.name='bobs'; hibernate3.2版本之前可以使用
  from Dept as d join fetch d.emps as e where e.name='bobs'; hibernate3.2版本之后
   如果hql中加入了join关键字,hibernate不能自动将一行数据封装成一个对象,必须加入关键字fetch
 
  使用隐士对表连接的时候注意关系属性的类型。
    没有雇员的部门 在hql当中判断集合是否为null可以使用is empty
     from Dept as d where d.emps is empty

显示多表连接:通过join关键字实现多表查询,通过一条sql语句就能完成多表查询、
 等值连接 inner join(Oracle9i可以省略)
   SQL:select e.*,d.* from g_employee e,g_dept d where e.d_id=d.t_id;
        select e.*,d.* from g_employee e inner join g_dept d on e.d_id=d.t_id;
   HQL:from Employee as e inner join e.dept
      因为加入了join关键词,不能封装成对象,每一行数据由Employee和Dept对象组成
        List<Object[]> emps=query.list();
     from Dept as d inner join fetch d.emps;
        List<Dept> depts=query.list();
  结果会有重复数据
    Set:去重,不能保留插入数据的顺序
    List:保留数据的顺序,不能去重
    LinkedSet:可以保留顺序,同时可以过滤重复
    List <Dept> depts=query.list();
    LinkedHashSet<Dept> deptsList=new LinkedHashSet<Dept>(depts);

驱动表 left outer join 匹配表 (左外连接,保留左边表的完整性)
    from Employee as e left outer join fetch e.dept

匹配表 right outer join 驱动表(右外连接,保留右边表的完整性)
   注意:右外连接hibernate不提供fetch关键词

全连接 full join  hibernate不支持full join

hibernate的分页
  Oracle:rownum
  Mysql:limit
  Query query=session.createQuery("from Employee");
    query.setFirstResult(0);//开始显示的记录,从0开始
    query.setMaxResult(3);//设置每页的记录数
    query.list();

Bulk update HQL提供的修改和删除的方法
   Query 对象实现对数据的 修改和删除
   SQL:update g_employee set name=xxx  where xxx;
   String hql="update Employee as e set e.name='xxxx' where e.id=1 ";//修改
   SLQ :delete from g_employee where t_id=1;
   HQL hql="delete Employee as e where e.id=1 ";//删除
 query对象的修改和删除与Session提供的delete(),和update()的区别
   1.Bulk update效率高
   2.Bulk update不会涉及缓存
   3.Bulk update不会涉及级联
   4.Bulk update不更新乐观锁

 

1.提供实体类Dept.java和Employee.java

package com.jsu.hb.pojo;

import java.util.HashSet;
import java.util.Set;

public class Dept {
	private Integer id;
	private String dname;
	private String dno;
	private Set<Employee> emps = new HashSet<Employee>();
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getDname() {
		return dname;
	}
	public void setDname(String dname) {
		this.dname = dname;
	}
	public String getDno() {
		return dno;
	}
	public void setDno(String dno) {
		this.dno = dno;
	}
	public Set<Employee> getEmps() {
		return emps;
	}
	public void setEmps(Set<Employee> emps) {
		this.emps = emps;
	}
	
}

 Employee.java

package com.jsu.hb.pojo;

import java.util.Date;

public class Employee {
	private Integer id;
	private String name;
	private Date birthday;
	private String email;
	private double salary;
	private Dept dept;
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Date getBirthday() {
		return birthday;
	}
	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}
	
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
	public Dept getDept() {
		return dept;
	}
	public void setDept(Dept dept) {
		this.dept = dept;
	}
	
}

 2.建表

create  table g_dept(
	t_id integer primary key,
	t_dname varchar2(20),
	t_dno varchar2(20)
)

create table g_employee(
	t_id integer primary key,
	t_name varchar2(25),
	t_birthday date,
	t_salary number(12,2),
	t_email varchar2(50),
	d_id integer references g_dept(t_id)
)

insert into g_dept(t_id,t_dname,t_dno) values (1,'dev','001');
insert into g_dept(t_id,t_dname,t_dno) values (2,'train','002');
insert into g_dept(t_id,t_dname,t_dno) values (3,'market','003');
insert into g_dept(t_id,t_dname,t_dno) values (4,'game','004');

insert into g_employee(t_id,t_name,t_birthday,t_email,t_salary,d_id) 
values (1,'bobs',to_date('2012-1-11','yyyy-mm-dd'),'bobs@b',100.0,1);
insert into g_employee(t_id,t_name,t_birthday,t_email,t_salary,d_id)
values (2,'scott',to_date('2010-10-11','yyyy-mm-dd'),'scott@b',300.0,1);
insert into g_employee(t_id,t_name,t_birthday,t_email,t_salary,d_id)
values (3,'tiger',to_date('2008-2-11','yyyy-mm-dd'),'tiger@b',400.0,2);
insert into g_employee(t_id,t_name,t_birthday,t_email,t_salary,d_id)
values (4,'lucy',to_date('2009-3-11','yyyy-mm-dd'),'lucy@b',600.0,2);
insert into g_employee(t_id,t_name,t_birthday,t_email,t_salary,d_id)
values (5,'lily',to_date('2012-4-11','yyyy-mm-dd'),'lily@b',1000.0,3);
insert into g_employee(t_id,t_name,t_birthday,t_email,t_salary,d_id)
values (6,'tom',to_date('2001-10-11','yyyy-mm-dd'),'tom@b',700.0,3);
insert into g_employee(t_id,t_name,t_birthday,t_email,t_salary,d_id)
values (7,'black',to_date('2001-10-11','yyyy-mm-dd'),'black@b',200.0,null);

commit

 3.提供映射文件query.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping  package="com.jsu.hb.pojo">
	<class name="Dept" table="g_dept">
		<id name="id" column="t_id">
			<generator class="increment"></generator>
		</id>
		<property name="dname" column="t_dname"></property>
		<property name="dno" column="t_dno"></property>
		<!-- 关系属性 -->
		<set name="emps" cascade="all" inverse="true">
			<key column="d_id"></key>
			<one-to-many class="Employee"></one-to-many>
		</set>
	</class>
	<class name="Employee" table="g_employee">
		<id name="id" column="t_id">
			<generator class="increment"></generator>
		</id>
		<property name="name" column="t_name"></property>
		<property name="birthday" column="t_birthday" type="java.util.Date"></property>
		<property name="email" column="t_email"></property>
		<property name="salary" column="t_salary"></property>
		<!-- 双向关系是添加关系属性 -->
	   <many-to-one name="dept" class="Dept" cascade="save-update" column="d_id"></many-to-one>
	</class>
</hibernate-mapping>

 4.在hibernate.cfg.xml中对映射文件进行注册

<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
	<session-factory> 
		<!-- show_sql:是否显示hibernate执行的SQL语句,默认为false -->
		<property name="show_sql">true</property>
		<!-- show_sql:是否显示hibernate执行格式化输出的SQL语句,默认为false -->
		<property name="format_sql">true</property>
		<!-- 配置与数据库连接的参数 -->
		<property name="connection.driver_class">oracle.jdbc.OracleDriver</property>
		<property name="connection.url">jdbc:oracle:thin:@127.0.0.1:1521:oracle</property>
		<property name="connection.username">scott</property>
		<property name="connection.password">tiger</property>
		<!-- 2.自身属性相关的配置
			dialect:方言
			hibernate根据dialect的配置进行特定数据性能方面的调优
		 -->
		<property name="dialect">org.hibernate.dialect.Oracle9iDialect</property>
		<mapping resource="com/jsu/hb/pojo/query.hbm.xml"></mapping>
	</session-factory>
</hibernate-configuration>

 5.提供工具类HibernateUtil.java

 

package com.jsu.hb.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {
	private static SessionFactory sf;
	private static ThreadLocal<Session> tl= new ThreadLocal<Session>();
	static{
		try{
				Configuration cfg = new Configuration();
				cfg.configure();
				sf=cfg.buildSessionFactory();
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	public static Session openSession(){
		return sf.openSession();
	}
	public static Session getCurrentSession(){
		Session session = tl.get();//先从储存的线程中查找
		if(session==null){
			session=openSession();
			tl.set(session);
			return session;
		}
		return session;
	}
}

 6.提供测试类TestQuery.java

package com.jsu.hb.test;

import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import com.jsu.hb.pojo.Dept;
import com.jsu.hb.pojo.Employee;
import com.jsu.hb.util.HibernateUtil;

public class TestQuery {
	//hql查找所有
	@Test
	public void queryAll(){
		Session session = HibernateUtil.getCurrentSession();
		Transaction tx = session.getTransaction();
		tx.begin();
		String hql = "from Employee";
		Query query = session.createQuery(hql);
		List<Employee> emps = query.list();
		for(Employee e: emps){
			System.out.println(e.getName());
		}
		tx.commit();
	}
	@Test
	public void queryByName(){
		String name="tom";
		Session session = HibernateUtil.getCurrentSession();
		Transaction tx = session.getTransaction();
		tx.begin();
		String hql = "from Employee as e where e.name=?";
		Query query = session.createQuery(hql);
		query.setString(0, "tom");// 为占位符赋值,从0开始
		Employee e =(Employee)query.uniqueResult();// 返回单个对象
		System.out.println(e.getName()+" : "+e.getEmail()+" : "+e.getBirthday()+" : "+e.getSalary());
		tx.commit();
	}
	@Test
	public void testNull(){
		Session session = HibernateUtil.getCurrentSession();
		Transaction tx = session.getTransaction();
		tx.begin();
		String hql = "from Employee as e where e.dept.id=null";
		Query query = session.createQuery(hql);
		Employee e =(Employee)query.uniqueResult();
		System.out.println(e.getName());
		tx.commit();
	}
	@Test
	public void testLike(){
		Session session = HibernateUtil.getCurrentSession();
		Transaction tx = session.getTransaction();
		tx.begin();
		String hql = "from Employee as e where e.name like'xiao%'";
		Query query = session.createQuery(hql);
		Employee e =(Employee)query.uniqueResult();
		System.out.println(e.getName());
		tx.commit();
	}
	@Test
	public void testAggregation(){
		Session session = HibernateUtil.getCurrentSession();
		Transaction tx = session.getTransaction();
		tx.begin();
		String hql = "select e.dept.id,max(e.salary),avg(e.salary),min(salary) "+
				"from Employee as e group by e.dept.id having avg(e.salary)>300";
		Query query = session.createQuery(hql);
		List<Object[]> emps = query.list();
		for(Object[] obj:emps){
			System.out.println(" 最大工资为:"+obj[0]+" 平均工资为: "+obj[1]+" 最小工资为: "+obj[2]);
		}
	}
	@Test
	public void testHiddenMT(){
		Session session = HibernateUtil.getCurrentSession();
		Transaction tx = session.getTransaction();
		tx.begin();
		String hql = "from Dept as d join fetch d.emps as e where e.name='bobs'";
		Query query = session.createQuery(hql);
		Dept d = (Dept)query.uniqueResult();
		System.out.println("部门名称:"+d.getDname());
		tx.commit();
	}
	@Test
	public void testEqualsValueLinked(){
		Session session = HibernateUtil.getCurrentSession();
		Transaction tx = session.getTransaction();
		tx.begin();
		String hql = "from Dept as d inner join fetch d.emps";
		Query query = session.createQuery(hql);
		List<Dept> depts = query.list();
		LinkedHashSet<Dept> deptSet = new LinkedHashSet<Dept>(depts);
		for(Dept d:deptSet){
			System.out.println(d.getDname());
		}
	}
	@Test
	public void testLinked(){
		Session session = HibernateUtil.getCurrentSession();
		Transaction tx = session.getTransaction();
		tx.begin();
		String hql = "from Employee as e left outer join fetch e.dept";
		Query query = session.createQuery(hql);
		List<Employee> emps = query.list();
		LinkedHashSet<Employee> deptSet = new LinkedHashSet<Employee>(emps);
		for(Employee e :deptSet){
			System.out.println(e.getName());
		}
	}
	
	public void testQuery() {
		Session session = HibernateUtil.getCurrentSession();
		Transaction tx = session.getTransaction();
		tx.begin();
		// 开发dev部门的所有员工
		String hql = "from Employee as e where e.dept.dname='dev'";
		Query query = session.createQuery(hql);
		/* 每个员工的部门名称 */

		List<Employee> emps = query.list();
		for (Employee e : emps) {
			System.out.println(e.getName() + " : " + e.getDept().getDname());
		}
		tx.commit();

	}

	public void testC() {
		Session session = HibernateUtil.getCurrentSession();
		Transaction tx = session.getTransaction();
		tx.begin();
		String hql = "from Dept as d where d.emps.name='bobs' ";
		String hql1 = "from Dept as d join fetch d.emps as e where e.name='bobs'";
		String hql2 = "from Dept as d where d.emps is empty";// 不用迭代集合
		Query query = session.createQuery(hql2);
		Dept d = (Dept) query.uniqueResult();
		System.out.println(d.getDname());
		tx.commit();
	}


	public void queryDept() {
		Session session = HibernateUtil.getCurrentSession();
		Transaction tx = session.getTransaction();
		tx.begin();
		String hql1 = "from Dept as d inner join fetch d.emps";
		Query query = session.createQuery(hql1);
		List<Dept> depts = query.list();
		LinkedHashSet<Dept> depts1=new LinkedHashSet<Dept>(depts);
		for (Dept d : depts1) {
			Set<Employee> emps = d.getEmps();
			for (Employee e : emps) {
				System.out.println(d.getDname() + "  " + e.getName());
			}
		}
		tx.commit();
	}
	
	//hibernate分页
	@Test
	public void testPage(){
		Session session = HibernateUtil.getCurrentSession();
		Transaction tx = session.getTransaction();
		tx.begin();
		String hql = "from Employee";
		Query query = session.createQuery(hql);
		query.setFirstResult(0);
		query.setMaxResults(3);
		List<Employee> emps =query.list();
		System.out.println(emps.size());
		tx.commit();
	}
	//修改
	@Test
	public void testUpdate(){
		Session session = HibernateUtil.getCurrentSession();
		Transaction tx = session.getTransaction();
		tx.begin();
		String hql = "update Employee as e set e.name='haoren' where e.id=1";
		Query query = session.createQuery(hql);
		query.executeUpdate();
		tx.commit();
	}
	//删除
	@Test
	public void testBulk(){
		Session session = HibernateUtil.getCurrentSession();
		Transaction tx = session.getTransaction();
		tx.begin();
		String hql = "delete Employee as e where t_id=8";
		Query query = session.createQuery(hql);
		query.executeUpdate();
		tx.commit();
	}
}
 

 

分享到:
评论

相关推荐

    HQL(Hibernate Query Language):

    Hibernate Query Language(HQL)是Hibernate框架中用于操作对象关系映射(ORM)的一种查询语言。它是面向对象的,设计目的是让开发人员可以使用对象而不是数据库表进行查询,从而简化了与数据库交互的过程。HQL的...

    Hibernate Query Language

    Hibernate Query Language,简称HQL,是Hibernate框架中用于执行数据库查询的一种面向对象的查询语言。它与传统的SQL语言非常相似,但更简洁,更重要的是,HQL理解面向对象的概念,如继承、多态、关联、聚合和组合。...

    Hibernate Query Language基础使用详解

    Hibernate Query Language(HQL)是Hibernate官方推荐的查询语言,它是面向对象的,与SQL类似,但更加符合Java编程的思维。HQL使得开发者能够更方便地处理对象关系映射,而无需直接编写SQL语句。在使用HQL时,我们...

    Hibernate Tutorial 09 Hibernate Query Language

    # Hibernate Query Language (HQL): An Object-Oriented Variant of SQL ## 一、引言 Hibernate 是一款流行的 Java 持久层框架,它极大地简化了对象与关系数据库之间的映射过程。Hibernate Query Language(简称 ...

    HQL Hibernate查询语言

    HQL(Hibernate Query Language)是 Hibernate 中的一种强大的查询语言,它看起来很像 SQL,但是不要被语法结构上的相似所迷惑,HQL 是非常有意识的被设计为完全面向对象的查询,它可以理解如继承、多态和关联之类的...

    Hibernate-HQL-查询-Query资料

    在Hibernate中,HQL(Hibernate Query Language)是专为ORM设计的一种面向对象的查询语言,它允许开发者以类和对象的方式进行数据查询,而不是直接使用SQL。本资料主要涵盖了Hibernate HQL查询的基本概念、语法以及...

    Hibernate-HQL.rar_HQL_hibernate hql

    本篇文档将深入探讨Hibernate中的HQL(Hibernate Query Language),一种面向对象的查询语言,它提供了与SQL类似的语法,但更贴近于面向对象的思维模式,使得开发者可以更加便捷地进行数据查询。 一、HQL简介 HQL是...

    Hibernate hql查询语法总结

    其内置的HQL(Hibernate Query Language)是一种面向对象的查询语言,它允许开发者以类和对象的方式进行数据查询。本文将对Hibernate HQL查询语法进行总结,涵盖基础查询、属性查询、实例化查询以及查询链接等多个...

    Hibernate 课件_HQL

    - **定义**: HQL(Hibernate Query Language)是一种面向对象的查询语言,它的语法类似于SQL,但不同于直接操作数据库表,HQL操作的是持久化的Java对象。这意味着在编写查询时,可以使用Java对象模型中的类名和属性...

    HQL是hibernate自己的一套查询

    根据提供的标题、描述以及部分代码内容,我们可以了解到这段材料主要涉及的是Hibernate框架中的HQL(Hibernate Query Language)查询语言的使用。接下来将详细介绍HQL的相关知识点。 ### HQL概述 HQL是Hibernate...

    \Hibernate_query条件查询

    1. **HQL(Hibernate Query Language)** HQL是Hibernate提供的面向对象的查询语言,类似于SQL,但操作的对象是对象而非表。例如,要获取所有用户,可以使用以下HQL语句: ```java Query query = session....

    Hibernate_Query_Language基础认识.rar

    **Hibernate Query Language(HQL)基础认识** Hibernate Query Language(HQL)是Hibernate框架中用于操作对象关系映射(ORM)的一种查询语言。它类似于SQL,但专为面向对象编程设计,使得开发者能够以类和对象的...

    Hibernate HQL命名参数和Query接口的分页

    在Java的持久化框架Hibernate中,HQL(Hibernate Query Language)是用于操作对象关系映射(ORM)的SQL方言,提供了更加面向对象的查询方式。本篇将详细讲解HQL中的命名参数以及如何通过Query接口实现分页查询,这...

    hibernateHQL关联查询

    其中,HQL(Hibernate Query Language)作为Hibernate提供的查询语言之一,允许开发者以接近面向对象的方式编写查询语句。本文将重点介绍Hibernate中的关联查询,并深入探讨HQL关联查询的实现原理及应用场景。 ####...

    Hibernate中的查询:HQL、Criteria、原生SQl

    本篇文章将深入探讨Hibernate中的三种主要查询方式:HQL(Hibernate Query Language)、Criteria API以及原生SQL。 一、HQL(Hibernate Query Language) HQL是Hibernate提供的一种面向对象的查询语言,它类似于SQL...

    Hibernate注解方式、HQL查询

    本篇将详细探讨Hibernate的注解方式以及HQL(Hibernate Query Language)查询。 一、Hibernate注解方式 1. **实体类注解**:在Hibernate中,我们可以使用注解来定义一个Java类为数据库中的表。例如,使用`@Entity`...

    Hibernate数据检索(HQL)笔记

    本文档基于魔乐科技李兴华老师的 Hibernate 教程笔记进行整理与扩展,主要介绍了 Hibernate 的数据检索方法,特别是 HQL(Hibernate Query Language)的使用技巧。 #### 二、HQL 基础 HQL 是一种面向对象的查询语言...

    Hibernate-HQL-QBC-QBE

    标题中的“Hibernate-HQL-QBC-QBE”涵盖了四个重要的Java持久化框架Hibernate中的概念,分别是Hibernate Query Language(HQL)、Query By Criteria(QBC)、Query By Example(QBE)以及相关的库文件。以下是对这些...

    Hibernate HQL查询 分页查询 模糊查询.docx

    #### 一、HQL(Hibernate Query Language)简介 HQL(Hibernate Query Language)是一种面向对象的查询语言,它允许开发者使用类及其属性来编写查询语句,而不是传统的SQL语句。这使得开发人员能够更加专注于业务...

    hibernate hql where语句拼接工具类

    HQL(Hibernate Query Language)是Hibernate提供的一个SQL的面向对象的查询语言,它使得开发者可以避免直接编写SQL语句,从而更好地进行数据库操作。本文将深入探讨“hibernate hql where语句拼接工具类”,并结合...

Global site tag (gtag.js) - Google Analytics