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