首页 > > 程序设计 > Java技术 >

HIbernate常用的三种查询

2019-08-16 12:07:41来源：博客园 阅读 ()

新老客户大回馈,云服务器低至5折

HIbernate常用的三种查询

Hibernate三种常用查询API：标准，HQL，SQL

使用工具：

    1. hibernate的核心jar包及配置文件和映射文件
    1. log4j打印日志文件及jar及配置文件
  • 3.eclipse开发，navicat数据库可视化工具，mysql
  • 4.连接数据库的jar包
  • 注：详细信息页面最下面（本篇只是初略起稿，不足之处，望帮忙指出，谢谢）

1.标准的查询：使用hibernate封装好的方法，完成查询所需：

1.1查询所有数据：
    public void SelectLike() {
     // 获取session
    Session session = HibernateUtil.openSession();
    // 查询主表信息：
    Criteria criteria = session.createCriteria(ZJ.class);
    //返回查询结果并返回给集合
    List list = criteria.list();
    //打印信息
    System.out.println(list);
}

1.2精准条件查询：

    @Test
    public void SelectLike() {
     // 获取session
    Session session = HibernateUtil.openSession();
    // 查询主表信息：
    Criteria criteria = session.createCriteria(ZJ.class);
    //设置查询条件:查询姓名中含有‘张’字的记录 
    criteria.add(Restrictions.eq("name" ,"赵小花"));
    //返回查询结果并返回给集合
    List list = criteria.list();
    //打印信息
    System.out.println(list);
}

注：criteria.add（）去添加一个标准查询的限制 ,Restrictions.eq(类的属性[从查询类的属性开始书写]，值)：精准查询{相当于 字段 = 值}；

1.2模糊条件查询：

     @Test
    public void SelectLike() {
     // 获取session
    Session session = HibernateUtil.openSession();
    // 查询主表信息：
    Criteria criteria = session.createCriteria(ZJ.class);
   //设置查询条件:查询姓名中含有‘张’字的记录 
    criteria.add(Restrictions.like("name" ,"%张%"));
    //返回查询结果并返回给集合
    List list = criteria.list();
    //打印信息
    System.out.println(list);
}

注：Restrictions.like(类的属性[从查询类的属性开始书写]，值)：模糊查询{相当于 字段 like 值}；

1.3分页查询：

     @Test
   public void SelectLimit() {
     // 获取session
    Session session = HibernateUtil.openSession();
    // 查询主表信息：
    Criteria criteria = session.createCriteria(ZJ.class);
    // 放置分页查询的起始坐标
    criteria.setFirstResult(0);
    // 放置每页查询记录记录数
    criteria.setMaxResults(3);
    // 返回查询结果并返回给集合
    List list = criteria.list();
}

注：hibernate 的分页 只能调用查询的setFirstResult（）和setMaxResults（）方法

1.4添加大于查询条件：

 @Test
public void SelectByLtId() {
     //获取session
    Session session = HibernateUtil.openSession();
    //查询主表信息：
    Criteria criteria = session.createCriteria(ZJ.class);
    //设置查询条件：id小于3的记录
    criteria.add(Restrictions.gt("id" ,3));
    //返回查询结果并返回给集合
    List list = criteria.list();
}

1.5添加大于查询条件：

   @Test
public void SelectByLtId() {
     //获取session
    Session session = HibernateUtil.openSession();
    //查询主表信息：
    Criteria criteria = session.createCriteria(ZJ.class);
    //设置查询条件：id小于3的记录
    criteria.add(Restrictions.lt("id" ,3));
    //返回查询结果并返回给集合
    List list = criteria.list();
}

1.6范围条件查询条件：

  @Test
public void SelectById() {
     //获取session
    Session session = HibernateUtil.openSession();
    //查询主表信息：
    Criteria criteria = session.createCriteria(ZJ.class);
    //设置查询条件：id在2-6的记录
    criteria.add(Restrictions.between("id" ,2,6));
    //返回查询结果并返回给集合
    List list = criteria.list();
}

1.7保存信息：

    @Test
    public void SelectLike() {
     // 获取session
    Session session = HibernateUtil.openSession();
  //开启事务
    Transaction transaction = session.beginTransaction();
 
    //实例一个存储的类
    ZJ zj = new ZJ();
    //设置属性
    zj.setName("赵小花");
   //保存
   session.save(zj);
    //提交事务
   transaction.commit();
}

注：如果调用的是sessionFactory.openSession()，操作增删改时需要开启事务和提交事务，如果需要持久状态的对象可以直接提交利用session的一级缓存完成修改操作

1.8:保存信息：

    public void SelectLike() {
     // 获取session
    Session session = HibernateUtil.openSession();
  //开启事务
    Transaction transaction = session.beginTransaction();
 
  //实例一个存储的类
    ZJ zj = new ZJ();
    //设置属性
    zj.setId(1);
    zj.setName("兰花指");
   //修改
    session.update(zj);
    //提交事务
   transaction.commit();
}

1.9：保存或修改操作：

    public void SelectLike() {
     // 获取session
    Session session = HibernateUtil.openSession();
  //开启事务
    Transaction transaction = session.beginTransaction();
 
  //实例一个存储的类
    ZJ zj = new ZJ();
    //设置属性
    zj.setId(1);
    zj.setName("兰花指");
   //修改
    session.saveOrUpdate(zj);
    //提交事务
   transaction.commit();
}

注：先判断时否存在id是否存在，如果在就修改，如果不一样就添加；

1.10:通过id获取对应信息：

       //方法1：通过get获取（立即加载）
      Session session = HibernateUtil.openSession();
      ZJ zj = (ZJ)session.get(ZJ.class,1);

      //方法2：通过load获取（延迟加载）
      Session session = HibernateUtil.openSession();
      ZJ zj = (ZJ)session.load(ZJ.class,1);

区别：

1.get是立即加载，查询结果不存在是返回的值为null。load是延迟加载，当查询结构不存在是会报错

2.get返回的是一个该类的实例，load返回的是一个代理对象。

1.11：删除记录：

     @Test
public void deleteAUser() {
    // 获取session
    Session session = HibernateUtil.openSession();
    //开启事务
    Transaction transaction = session.beginTransaction();
    //实例一个存储的类
    User user = new User();
    //设置属性
    user.setId(3);
    //执行删除
    session.delete(user);
    //提交事务并保存到数据库
    transaction.commit();
}

1.12:通过条件查询获取唯一结果：

      public void SelectLike() {
    // 获取session
    Session session = HibernateUtil.openSession();
    //查询主表信息：
    Criteria criteria = session.createCriteria(ZJ.class);
    //设置查询条件: 查询name为‘赵小花’的记录
    criteria.add(Restrictions.eq("name" ,"赵小花"));
    //获取唯一结果并强转为该类型的数据
    ZJ zj = （ZJ）criteria.uniqueResult();
}

注：查询结果不唯一会报错，小心使用

Hql语句心得：

概念介绍：

HQl： Hibernate Query Langurage(hibernate查询语句)。

注：是hibernate框架的一种查询AIP；主要分为两种1.hql语句拼接，2.hql占位符：

1.Hql操作单表：

1.1查询所有记录：

代码：
/**
* 简单查询所有的user数据
* */
public void findAllUser() {
//实用工具类获取session
Session session = HibernateUtil.openSession();
//描写hql语句
String hql = "FROM User";
//创建查询对象
Query createQuery = session.createQuery(hql);
//获取结果集
List list = createQuery.list();
//打印结果集
System.out.println(list);
}
结果显示：

1.2条件查询记录（字符串拼接）：

 @Test
/**
 * 条件查询之模糊查询1.字符串拼接
 * */
public void findUserByLikeName1() {
    //实用工具类获取session
    Session session = HibernateUtil.openSession();
    String name ="张";
    //描写hql语句
    String hql = "FROM User WHERE name like '%" + name + "%' ";
    //创建查询对象
    Query createQuery = session.createQuery(hql);
    //获取结果集
    List list = createQuery.list();
    //打印结果集
    System.out.println(list);
}

结果显示：

注：使用的时候尽量避免，因为拼接过长容易出错。希望你是大声一气呵成。

1.2条件查询记录（占位符方式）：

   @Test
/**
 * 条件查询之模糊查询2.占位符
 * */
public void findUserByLikeName2() {
    //实用工具类获取session
    Session session = HibernateUtil.openSession();
    //描写hql语句
    String hql = "FROM User WHERE name like ? ";
    //创建查询对象
    Query createQuery = session.createQuery(hql)
            .setString(0,"%张%");
    //获取结果集
    List list = createQuery.list();
    //打印结果集
    System.out.println(list);
}

结果显示：

注：

1.使用占位符，下标是从0开始，和底层jdbc查询对象从1开始进行区分

2.放置类型只有包装类型和String类型，不想底层的jdbc查询对象可直接放置object类型

1.3精准条件查询获取唯一结果：

@Test
/**
 *精准查询获取唯一结果：占位符
 * */
public void findUserGetOnlyClass() {
    //实用工具类获取session
    Session session = HibernateUtil.openSession();
    //描写hql语句
    String hql = "FROM User WHERE name = ? ";
    //创建查询对象
    Query createQuery = session.createQuery(hql)
            .setString(0,"张三");
    //获取唯一结果并进行强制转换
    User user = (User)createQuery.uniqueResult();
    //打印结果集
    System.out.println(user);
}

结果显示：

注:当查询的结果不唯一，而调用uniqueResult()方法会出现如下情况——方法终止，报错等

1.4：多表联查

@Test
/**
 *多表联查主表所有信息
 * */
public void findAllZJ() {
    //实用工具类获取session
    Session session = HibernateUtil.openSession();
    //描写hql语句
    String hql = "SELECT z FROM ZJ z,Singer s WHERE z.singer.id = s.id ";
    //创建查询对象
    Query createQuery = session.createQuery(hql);
    //获取唯一结果并进行强制转换
    List list = createQuery.list();
    //打印结果集
    System.out.println(list);
}

结果显示：

注：.多表查询时需要从select 开始，否则你有多少个表底层就会帮你查多少个表的信息，其次会将其信息转为地址：以为是集合嵌套集合的形式出现的不方便使用。图下表示FROM 书写的hql的结果：

1.5JOIN 连接查询:(案例left join)

@Test
/**
 *hql left join
 * */
public void findAllZJ() {
    //实用工具类获取session
    Session session = HibernateUtil.openSession();
    //描写hql语句
    String hql = " SELECT z FROM ZJ AS z LEFT JOIN z.singer ";
    //创建查询对象
    Query createQuery = session.createQuery(hql);
    //获取唯一结果并进行强制转换
    List list = createQuery.list();
    //打印结果集
    System.out.println(list);
}

注：

1.查询时不能使用 on 关键字， 因为HQL不能解析 on 关键字

2.使用时，从select 写起，否则会帮你查询的结果出现集合嵌套集合（即每个相关表的信息多会出现），打印信息也会变成地址，容易造成误解。

3.写入查询的主表，left join 应当书写 主表实例类中需要联合查询的对象

报错代码片段：

- unexpected token on：无法解析 on
- Path expected for join! ： 不认识left join

报错原因：无法解析 join 和 on

解决方法：规避删除 on ，检查项目，获将join换成Where条件查询

1.6删除：

代码

@Test
/**
 *hql删除
 * */
public void deleteUserByHql() {
    //实用工具类获取session
    Session session = HibernateUtil.openSession();
    //描写hql语句
    String hql = "delete  User WHERE id = ?";
    //创建查询对象
    Query createQuery = session.createQuery(hql);
    //放置信息
    createQuery.setInteger(0, 1);
    //执行hql
    createQuery.executeUpdate();
}

执行结果：

注：

1.删改使用的执行方式是executeUpdate();

2.hibernate是面向对象的因此hql不能使用insert进行添加操作

1.7修改：

代码

@Test
/**
 * hql修改
 * */
public void updateUserByHql() {
    //实用工具类获取session
    Session session = HibernateUtil.openSession();
    //描写hql语句
    String hql = "update  User set name = ? WHERE id = ?";
    //创建查询对象
    Query createQuery = session.createQuery(hql);
    //放置信息
    createQuery.setString(0, "赵六");
    createQuery.setInteger(1, 2);
    //执行hql
    createQuery.executeUpdate();
}

执行结果：

Sql:

1.1查询所有记录：

代码：

    @Test
   /**
   * 简单查询所有的user数据
   * */
public void findAllUserBySql() {
    //实用工具类获取session
    Session session = HibernateUtil.openSession();
    //描写sql语句
    String sql = "select * from t_users7 ";
    //创建查询对象
    SQLQuery createSQLQuery = session.createSQLQuery(sql);
    //获取唯一结果并进行强制转换
     List list = createSQLQuery.list();
    //打印结果集
    System.out.println(list);
}

结果显示：

注：
1.查询时需要注入查询对象的的映射，多表联查只需要注入主表关系，因为主表已经关联了其余表单

未加入实体类打印的信息为地址值；（如下所示）

2.和hql语句使用差不多；使用时也分为拼接和占位两种方法

1.2条件查询记录（占位符方式）：

@Test
   /**
   * 条件查询
   * */
public void findAllUserBySql1() {
    //实用工具类获取session
    Session session = HibernateUtil.openSession();
    //描写sql语句
    String sql = "select * from t_users7 WHERE user_name = ? ";
    //创建查询对象
    SQLQuery createSQLQuery = session.createSQLQuery(sql);
    //链式查询（将条件全部添加到一条语句上）
    createSQLQuery.addEntity(User.class)
                  .setString(0, "张三");
    
    //获取唯一结果并进行强制转换
     List list = createSQLQuery.list();
    //打印结果集
    System.out.println(list);
}

结果显示：

注：

1.和Hql 的区别是sqlQuery链式查询不能从获取查询对象开始时，即本案例的SQLQuery createSQLQuery = session.createSQLQuery(sql);；

1.3多表查询

@Test
public void findAllZJBySql1() {
    //实用工具类获取session
    Session session = HibernateUtil.openSession();
    //描写sql语句
    String sql = " select * from t_zjs7 z , t_singers7 s where z.zj_singer_id = s.singer_id ";
    //创建查询对象
    SQLQuery createSQLQuery = session.createSQLQuery(sql)
             .addEntity(ZJ.class);
    //获取唯一结果并进行强制转换
    List list = createSQLQuery.list();
    //打印结果集
    System.out.println(list);
}

结果显示：

1.4添加：

@Test
/**
 * sql添加
 * */
public void addUser() {
    //实用工具类获取session
    Session session = HibernateUtil.openSession();
    //描写sql语句
    String sql = "insert into t_users7  (user_id,user_name,user_age)values  (null,?,?)";
    //创建查询对象
    SQLQuery createSQLQuery = session.createSQLQuery(sql);
    
    //放置条件
    createSQLQuery.setInteger(1, 17)
         .setString(0, "皮卡丘");

    //执行添加语句
    createSQLQuery.executeUpdate();
}

结果显示：

注：

1.增删改的方法都是executeUpdate（）方法执行

2.使用占位符输出的格式信息都能很好的保密（即客户端也无法查看完整的语句）。

使用的类

1.实例类：

1.1：歌手类：
public class Singer {
    private Integer id;
    private String name;
    public Singer() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Singer(Integer id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    
    @Override
    public String toString() {
        return "Singer [id=" + id + ", name=" + name + "]";
    }
    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;
    }
}

歌手的配置信息：

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <!-- 建立类与表的映射 -->
    <class name="com.web.dto.Singer" table="t_singers7">
        <!-- 建立类中的属性与表中的主键对应 -->
        <id name="id" column="singer_id" >
            <generator class="native"/>
        </id>
        
        <!-- 建立类中的普通的属性和表的字段的对应 -->
        <property name="name" column="singer_name"/>
        
    </class>
</hibernate-mapping>
1.2：专辑类：
public class ZJ {
    private String name;
    private Integer id;
    private Date datea;
    private Double price;
    private Singer singer;
    @Override
    public String toString() {
        return "ZJ [name=" + name + ", id=" + id + ", datea=" + datea + ", price=" + price + ", singer=" + singer + "]";
    }
    public ZJ(String name, Integer id, Date datea, Double price, Singer singer) {
        super();
        this.name = name;
        this.id = id;
        this.datea = datea;
        this.price = price;
        this.singer = singer;
    }
    public ZJ() {
        super();
        // TODO Auto-generated constructor stub
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Date getDatea() {
        return datea;
    }
    public void setDatea(Date datea) {
        this.datea = datea;
    }
    public Double getPrice() {
        return price;
    }
    public void setPrice(Double price) {
        this.price = price;
    }
    public Singer getSinger() {
        return singer;
    }
    public void setSinger(Singer singer) {
        this.singer = singer;
    }
}

1.2：专辑类配置信息：

    <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <!-- 建立类与表的映射 -->
    <class name="com.web.dto.ZJ" table="t_zjs7">
        <!-- 建立类中的属性与表中的主键对应 -->
        <id name="id" column="zj_id" >
            <generator class="native"/>
        </id>
        
        <!-- 建立类中的普通的属性和表的字段的对应 -->
        <property name="datea" column="zj_datea"/>
        <property name="name" column="zj_name"/>
        <property name="price" column="zj_price"/>
        
        <many-to-one name="singer" column="zj_singer_id" lazy="false" class="com.web.dto.Singer"></many-to-one>
        
    </class>
</hibernate-mapping>

1.3用户类：

    public class User {
        private Integer id;
        private String name;
        private Integer age;
        public User() {
            super();
            // TODO Auto-generated constructor stub
        }
        public User(Integer id, String name, Integer age) {
            super();
            this.id = id;
            this.name = name;
            this.age = age;
        }
        @Override
        public String toString() {
            return "User [id=" + id + ", name=" + name + ", age=" + age + "]";
        }
        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 Integer getAge() {
            return age;
        }
        public void setAge(Integer age) {
            this.age = age;
        }
}

1.3：用户类配置信息：

   <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
    <hibernate-mapping>
    <!-- 建立类与表的映射 -->
    <class name="com.web.dto.User" table="t_users7">
        <!-- 建立类中的属性与表中的主键对应 -->
        <id name="id" column="user_id" >
            <generator class="native"/>
        </id>
        
        <!-- 建立类中的普通的属性和表的字段的对应 -->
        <property name="age" column="user_age"/>
        <property name="name" column="user_name"/>
        
    </class>
</hibernate-mapping>

hibernate配置：

<?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>
        <!-- 连接数据库的基本参数 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql:///hibernate</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">root</property>
        <!-- 配置Hibernate的方言 -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        
        <!-- 可选配置================ -->
        <!-- 打印SQL -->
        <property name="hibernate.show_sql">true</property>
        <!-- 格式化SQL -->
        <property name="hibernate.format_sql">true</property>
        <!-- 自动创建表 -->
        <property name="hibernate.hbm2ddl.auto">update</property>
        
        <!-- 映射文件 -->
        <mapping resource="com/web/dto/ZJ.hbm.xml"/>
        <mapping resource="com/web/dto/Singer.hbm.xml"/>
        <mapping resource="com/web/dto/User.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

使用jar包：

日志配置文件：log4j.properties>:

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c\:mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###
# error warn info debug trace
log4j.rootLogger= info, stdout

原文链接:https://www.cnblogs.com/yizhichenfen/p/11319681.html
如有疑问请与原作者联系

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：Tomcat解析XML和反射创建对象原理

下一篇：SpringMVC-简介和执行原理分析(一)

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签