hibernate HQL的简单使用一

最新推荐文章于 2024-08-30 13:51:08 发布
最新推荐文章于 2024-08-30 13:51:08 发布
阅读量61 收藏
点赞数
分类专栏： Web后端 文章标签： hibernate sql mysql hql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chinrui/article/details/88303375
版权
Hibernate中的HQL使用
1、 建立相应的关系表
Category类： 
package com.edu.hpu;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class Category {

	private int id;
	private String name;

	@Id
	@GeneratedValue
	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;
	}
}

Topic类： 
package com.edu.hpu;

import java.util.Date;

import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;

@Entity
public class Topic {

	private int id;
	private String title;
	private Date date;
	private Category category;

	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	public Date getDate() {
		return date;
	}
	public void setDate(Date date) {
		this.date = date;
	}

	@ManyToOne(fetch=FetchType.LAZY)
	@JoinColumn(name="category_ID")
	public Category getCategory() {
		return category;
	}
	public void setCategory(Category category) {
		this.category = category;
	}
}

Msg类： 
package com.edu.hpu;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;

@Entity
public class Msg {

	private int id;
	private String cont;
	private Topic topic;

	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getCont() {
		return cont;
	}
	public void setCont(String cont) {
		this.cont = cont;
	}

	@ManyToOne
	@JoinColumn(name="topic_ID")
	public Topic getTopic() {
		return topic;
	}
	public void setTopic(Topic topic) {
		this.topic = topic;
	}
}

第12个查询用到的MsgInfo类： 
package com.edu.hpu;

public class MsgInfo {

	private int id;
	private String cont;
	private String topicName;
	private String categoryName;

	public MsgInfo(int id, String cont, String topicName, String categoryName) {
		super();
		this.id = id;
		this.cont = cont;
		this.topicName = topicName;
		this.categoryName = categoryName;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getCont() {
		return cont;
	}
	public void setCont(String cont) {
		this.cont = cont;
	}
	public String getTopicName() {
		return topicName;
	}
	public void setTopicName(String topicName) {
		this.topicName = topicName;
	}
	public String getCategoryName() {
		return categoryName;
	}
	public void setCategoryName(String categoryName) {
		this.categoryName = categoryName;
	}
}

Hibernate.cfg.xml配置信息： 
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

    <session-factory>

        <!-- Database connection settings -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/hibernate</property>
        <property name="connection.username">root</property>
        <property name="connection.password">r</property>

        <!-- JDBC connection pool (use the built-in) -->
        <property name="connection.pool_size">1</property>

        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>

        <!-- Enable Hibernate's automatic session context management -->
        <property name="current_session_context_class">thread</property>

        <!-- Disable the second-level cache  -->
        <property name="cache.provider_class">org.hibernate.cache.internal.NoCacheProvider</property>

        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>

        <property name="format_sql">true</property>

        <!-- Drop and re-create the database schema on startup -->
        <!--<property name="hbm2ddl.auto">update</property>-->

        <!--<mapping resource="org/hibernate/tutorial/domain/Event.hbm.xml"/>-->

        <!--<mapping resource="com/edu/hpu/Husband.hbm.xml" />-->
        <!--
        <mapping resource="com/edu/hpu/Teacher.hbm.xml" />
        <mapping resource="com/edu/hpu/Student.hbm.xml" />
        -->
        <mapping class="com.edu.hpu.Category" />
        <mapping class="com.edu.hpu.Topic" />
        <mapping class="com.edu.hpu.Msg" />


    </session-factory>

</hibernate-configuration>

简单的HQL测试类： 
package com.edu.hpu;

import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

public class TestClass {

	private static SessionFactory sf = null;

	@BeforeClass
	public static void beforeClass() {
		Configuration conf = new Configuration().configure();
		ServiceRegistry sr = new ServiceRegistryBuilder().applySettings(conf.getProperties()).buildServiceRegistry();
		sf = conf.buildSessionFactory(sr);
	}

	@Test
	public void testExport() {
		new SchemaExport(new Configuration().configure()).create(true ,true);
	}

	@Test
	public void testSave() {
		Session session = sf.openSession();
		session.beginTransaction();

		for(int i = 0; i < 10; i++) {
			Category c = new Category();
			c.setName("c" + i);
			session.save(c);
		}

		for(int i = 0; i < 10; i++) {
			Category c = new Category();
			c.setId(1);
			Topic t = new Topic();
			t.setTitle("t" + i);
			t.setCategory(c);
			session.save(t);
		}

		for(int i = 0; i < 10; i++) {
			Topic t = new Topic();
			t.setId(1);
			Msg m = new Msg();
			m.setTopic(t);
			m.setCont("m" + i);
			session.save(m);
		}

		session.getTransaction().commit();
		session.close();
	}

	@Test
	public void testHQL_1() {
		Session session = sf.getCurrentSession();
		session.beginTransaction();
		Query query = session.createQuery("from Category");
		List<Category> categories = (List<Category>)query.list();
		for(Category category : categories) {
			System.out.println(category.getName());
		}
		session.getTransaction().commit();
	}

	@Test
	public void testHQL_2() {
		Session session = sf.getCurrentSession();
		session.beginTransaction();
		Query query = session.createQuery("from Category c where c.name > 'c5'");
		List<Category> categories = (List<Category>)query.list();
		for(Category c : categories) {
			System.out.println(c.getName());
		}
		session.getTransaction().commit();
	}

	@Test
	public void testHQL_3() {
		Session s = sf.getCurrentSession();
		s.beginTransaction();
		Query query = s.createQuery("from Category c order by c.name desc");
		List<Category> cs = query.list();
		for(Category c : cs) {
			System.out.println(c.getName());
		}
		s.getTransaction().commit();
	}

	@Test
	public void testHQL_4() {
		Session session = sf.getCurrentSession();
		session.beginTransaction();
		Query q = session.createQuery("select distinct c from Category c order by c.name desc");
		List<Category> cs = (List<Category>)q.list();
		for(Category c : cs) {
			System.out.println(c.getName());
		}
		session.getTransaction().commit();
	}

	@Test
	public void testHQL_5() {
		Session session = sf.getCurrentSession();
		session.beginTransaction();
		Query q = session.createQuery("from Category c where c.id > :min and c.id < :max");
		/*q.setParameter("min", 2);
		q.setParameter("max", 8);*/
		q.setInteger("min", 2);
		q.setInteger("max", 8);
		List<Category> cs = (List<Category>)q.list();
		for(Category c : cs) {
			System.out.println(c.getId() + "-" + c.getName());
		}
		session.getTransaction().commit();
	}

	@Test
	public void testHQL_6() {
		Session s = sf.getCurrentSession();
		s.beginTransaction();
		Query q = s.createQuery("from Category c where c.id > ? and c.id < ?")
				   .setInteger(0, 2).setInteger(1, 8);
		List<Category> cs = (List<Category>)q.list();
		for(Category c : cs) {
			System.out.println(c.getId() + " - " + c.getName());
		}
		s.getTransaction().commit();
	}

	@Test
	public void testHQL_7() {
		Session s = sf.getCurrentSession();
		s.beginTransaction();
		Query q = s.createQuery("from Category c order by c.id desc");
		q.setMaxResults(4);
		q.setFirstResult(0);
		List<Category> cs = (List<Category>)q.list();
		for(Category c : cs) {
			System.out.println(c.getId() + " - " + c.getName());
		}
		s.getTransaction().commit();
	}

	@Test
	public void testHQL_8() {
		Session s = sf.getCurrentSession();
		s.beginTransaction();
		Query q = s.createQuery("select c.id , c.name from Category c order by c.id desc");
		List<Object[]> cs = (List<Object[]>)q.list();
		for(Object[] c : cs) {
			System.out.println(c[0] + " - " + c[1]);
		}
		s.getTransaction().commit();
	}

	//把Topic的FetchType调成LAZY的时候，没有有第二条查询语句
	@Test
	public void testHQL_9() {
		Session s = sf.getCurrentSession();
		s.beginTransaction();
		Query q = s.createQuery("from Topic t where t.category.id = 1");
		List<Topic> ts = (List<Topic>)q.list();
		for(Topic t : ts) {
			System.out.println(t.getId());
		}
		s.getTransaction().commit();
	}

	@Test
	public void testHQL_10() {
		Session s = sf.getCurrentSession();
		s.beginTransaction();
		Query q = s.createQuery("from Topic t where t.category.id = 1");
		List<Topic> ts = (List<Topic>)q.list();
		for(Topic t : ts) {
			System.out.println(t.getId() + " = " + t.getCategory().getName());
		}
		s.getTransaction().commit();
	}

	@Test
	public void testHQL_11() {
		Session s = sf.getCurrentSession();
		s.beginTransaction();
		Query q = s.createQuery("from Msg m where m.topic.category.id = 1");
		List<Msg> ms = (List<Msg>)q.list();
		for(Msg m : ms) {
			System.out.println(m.getCont());
		}
		s.getTransaction().commit();
	}

	//VO Value Object
	//DTO Data Transfer Object
	@Test
	public void testHQL_12() {
		Session s = sf.getCurrentSession();
		s.beginTransaction();
		Query q = s.createQuery("select new com.edu.hpu.MsgInfo(m.id , m.cont, m.topic.title , m.topic.category.name) from Msg m");
		List<MsgInfo> ms = (List<MsgInfo>)q.list();
		for(MsgInfo m : ms ) {
			System.out.println(m.getCont() + " = " + m.getTopicName() + " = " + m.getCategoryName());
		}
		s.getTransaction().commit();
	}

	//必须写成t.category,必须指定使用哪个变量做的连接
	@Test
	public void testHQL_13() {
		Session s = sf.getCurrentSession();
		s.beginTransaction();
		Query q = s.createQuery("select t.title , c.name from Topic t join t.category c");
		List<Object[]> cs = (List<Object[]>)q.list();
		for(Object[] c : cs) {
			System.out.println(c[0] + " = " + c[1]);
		}
		s.getTransaction().commit();
	}

	@Test
	public void testHQL_14() {
		Session s = sf.getCurrentSession();
		s.beginTransaction();
		Query q = s.createQuery("from Category c where c = :CInfo");
		Category c = new Category();
		c.setId(1);
		q.setParameter("CInfo", c);

		Category cs = (Category)q.uniqueResult();
		System.out.println(cs.getName());
		s.getTransaction().commit();
	}

	@Test
	public void testHQL_15() {
		Session s = sf.getCurrentSession();
		s.beginTransaction();
		Query q = s.createQuery("select count(*) from Category");
		long count = (Long)q.uniqueResult();
		System.out.println(count);
		s.getTransaction().commit();
	}

	@Test
	public void testHQL_16() {
		Session s = sf.getCurrentSession();
		s.beginTransaction();
		Query q = s.createQuery("from Category c where c.id between 3 and 5");
		List<Category> cs = (List<Category>)q.list();
		for(Category c : cs) {
			System.out.println(c.getId() + " - " + c.getName());
		}
		s.getTransaction().commit();
	}

	@Test
	public void testHQL_17() {
		Session s = sf.getCurrentSession();
		s.beginTransaction();
		Query q = s.createQuery("from Category c where c.id in (1,3,5)");
		List<Category> cs = (List<Category>)q.list();
		for(Category c : cs) {
			System.out.println(c.getId() + " - " + c.getName());
		}
		s.getTransaction().commit();
	}

	@Test
	public void testHQL_18() {
		Session s = sf.getCurrentSession();
		s.beginTransaction();
		Query q = s.createQuery("from Msg m where m.cont is not null");
		List<Msg> cs = (List<Msg>)q.list();
		for(Msg c : cs) {
			System.out.println(c.getId() + " - " + c.getCont());
		}
		s.getTransaction().commit();
	}

	@AfterClass
	public static void afterClass() {
		sf.close();
	}
}


qchery
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
编写简单的hql命令_hql 的执行方式
weixin_31857829的博客
12-24 620
注意脚本放的目录和权限hive -e "sql语句"hive -f file(sql.txt)crontab -e 里面的脚本命令要写绝对命令crontab -e //编辑crontab -l //查看crontab -r //删除hql脚本编写的注意点1、写好sh脚本 然后利用Crontab -e 进行部署，00 11 * * * /home/dir/baidu_update_data....
常用的Hql语句
weixin_30297281的博客
10-13 141
[java] view plaincopy //HQL:HibernateQueryLanguage. //特点： //>>1，与SQL相似，SQL中的语法基本上都可以直接使用。 //>>2，SQL查询的是表和表中的列；HQL查询的是对象与对象中的属性。 //>>3，HQL的关键字不...
Hive常用的SQL命令操作
热门推荐
wisgood的专栏
12-07 3万+
Hive常用的SQL命令操作
HQL 简单使用二
Q码记
04-26 83
tence.Id; @Entity public class Category { private int id; private String name; @Id @GeneratedValue public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; }
HQL 简单的几种带条件查询方法
JAVA
04-22 413
条件查询 * 可以采用拼字符串的方式传递参数 * 可以采用 ？来传递参数（索引从0开始） * 可以采用 :参数名 来传递参数 * 如果传递多个参数，可以采用setParamterList方法 * 在hql中可以使用数据库的函数，如：date_format 第一种：可以拼字符串 List students = session.createQuery("selec...
HibernateHQL基本使用
qq_37846865的博客
10-04 141
HQL简介 HQL全称是Hibernate Query Language，它提供了是十分强大的功能，它是针对持久化对象，直接取得对象，而不进行update,delete和insert等操作。而且HQL是面向对象的，具备继承，多态和关联等特性。 HQL的简单使用 注意：Hibernate是按照是实体类映射的，所以HQL语句都是实体类名和实体类字段 查询所有 public List&amp;lt;User&amp;g...
Hibernate-HQL.rar_HQL_hibernate hql
09-23
本篇文档将深入探讨Hibernate中的HQL（Hibernate Query Language），一种面向对象的查询语言，它提供了与SQL类似的语法，但更贴近于面向对象的思维模式，使得开发者可以更加便捷地进行数据查询。 一、HQL简介 HQL是...
Hibernate hql查询代码实例
08-28
HQL 是完全面向对象的查询语句，具有多态、关联等特性，且是 Hibernate 官方推荐使用的查询方法。 HQL 介绍 HQL 是 Hibernate 的查询语言，用于查询和操作数据库中的数据。HQL 支持多种查询方式，包括简单查询、...
Hibernate中使用HQLQuery查询全部数据和部分数据的方法实例
08-26
在 Hibernate 框架中，HQL（Hibernate Query Language）是一种强大的查询语言，允许开发者使用 SQL 风格的语句来查询和操作数据。HQL 提供了多种查询方式，包括检索全部数据和部分数据。在本文中，我们将介绍如何...
Hibernate HQL查询.docx
06-19
以上代码展示了如何使用 HQL 进行一个简单的查询，其结果为 User 实体的列表。 #### 四、HQL 查询类型 根据返回类型的不同，HQL 查询可以分为以下几种： 1. **单个对象** - 当查询结果预期为单个对象时，可以使用...
Hibernate HQL 结合 velocity
03-24
**Hibernate HQL（Hibernate Query Language）** 是Hibernate提供的一个面向对象的查询语言，类似于SQL，但它是针对对象模型设计的。HQL允许开发者使用类和属性的名字而不是表和列名进行查询，从而降低了对底层...
关于一些简单HQL语句的总结
weixin_41928342的博客
06-13 918
//创建一个普通表 , 并且用默认的分割字段 /001 在shell中ctrl+v然后ctrl+a create table tableName(id int,name string,age int);//建表语法create [external] table [if not exists] table_name(filed_name field_type,filed_name field_ty...
HQL练习_01简单的一些基础练习
zgm12的博客
02-01 1232
换座位 小美是一所中学的信息科技老师，她有一张 seat 座位表，平时用来储存学生名字和与他们相对应的座位 id。 其中纵列的 id 是连续递增的 小美想改变相邻俩学生的座位。 你能不能帮她写一个 SQL query 来输出小美想要的结果呢？ 示例： ±--------±--------+ | id | student | ±--------±--------+ | 1 | Abbot | | 2...
编写简单的hql命令_HQL操作日常使用命令总结
weixin_42520277的博客
12-24 237
建表create table mydb.userinfo(name string,addressi string)ROW FORMAT DELIMITEDFIELDS TERMINATED BY '\t'LINES TERMINATED BY '\n'STORED AS TEXTFILE;创建分区表CREATE TABLE mydb.userinfo --创建表(col1 string, c...
Web安全：SQL注入实战测试.（扫描 + 测试）
网络安全领域___专研者.
08-25 529
SQL注入就是 有些恶意用户在提交查询请求的过程中 将SQL语句插入到请求内容中，同时程序的本身对用户输入的内容过于相信，没有对用户插入的SQL语句进行任何的过滤，从而直接被SQL语句直接被服务端执行，导致数据库的原有信息泄露，篡改，甚至被删除等风险。
在Postgresql中计算工单的对应的GPS轨迹距离
最新发布
专注GIS软件开发。
08-30 201
在某个App开发中，要求记录用户的日常轨迹，在用户巡逻设备的时，将记录的轨迹点当做该设备巡逻时候的轨迹。由于业务逻辑上没有明确的指示人员巡逻工单-GPS位置之间的关系，所以通过时间关系进行轨迹划定。
PostgreSQL-物理备份工具PGbackrest使用教程
侯晓阳的博客
08-27 447
PGSQL非常强大的物理备份工具，pgbackrest，支持增量、压缩、从库备份远程备份、加密备份等。
SQL 注入新视角：堆查询、JSON 与头部 XFF 注入剖析及防范
2301_77160226的博客
08-27 2085
在 SQL 注入攻击的世界中，除了一些常见的注入方式外，还有堆查询注入、JSON 注入以及头部 XFF 注入等较为特殊的攻击手段。这些攻击方式利用不同的场景和漏洞，对数据库安全构成严重威胁。本文将详细介绍这三种 SQL 注入攻击方式的原理和特点。
PostgreSQL如何设置主键自增（序列、SERIAL）
西京刀客
08-26 1149
在使用Mysql时，创建表结构时可以通过关键字auto_increment来指定主键是否自增。但在Postgresql数据库中，虽然可以实现字段的自增，但从本质上来说却并不支持Mysql那样的自增。
Hibernate HQL查询语言详解
在默认情况下，Hibernate会启用`auto-import`，允许使用类的简单名，所以通常我们可以简写为 `from Cat`。为了在查询的其他部分引用这些对象，我们需要给它们分配别名，如 `from Cat as cat`。别名`as`关键字是可选...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值