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-简介和执行原理分析(一)