小言_互联网的博客

【学习笔记-SSH框架】Hibernate入门-笔记01-搭建Hibernate应用环境及实现增删查改功能、以及Query、Criteria查询

2020-04-01 15:16 360人阅读  评论(0)

Hibernate入门-笔记01-搭建Hibernate应用环境及实现增删查改功能、以及Query、Criteria查询

目录

  1. 使用Maven搭建Hibernate项目
  2. 自顶向下开发Hibernate应用步骤
  3. 封装Hibernate工具类
  4. 实现增删查改功能
  5. 使用Query进行HQL查询
  6. 使用Criteria进行条件查询
  7. POJO状态

1. 使用Maven搭建Hibernate项目

在IDE中创建maven项目，加入依赖

（这里我使用的Hibernate版本为5.4.2.Final，不同版本之间在配置hibernate的时候，方法可能有略微差别）

<!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-core -->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>5.4.2.Final</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.47</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/junit/junit -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter</artifactId>
      <version>RELEASE</version>
      <scope>compile</scope>
    </dependency>

2. 自顶向下开发Hibernate应用步骤

  1. 配置hibernate.cfg.xml：在src目录下(IDEA创建的maven项目则在resources目录下创建配置文件)创建配置文件hibernate.cfg.xml
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>

        <!--配置数据库信息-->
        <!--配置连接url： db_name 为数据库名-->
        <property name="connection.url">jdbc:mysql://localhost:3306/数据库名</property>
        <!--配置驱动：-->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <!--数据库用户名-->
        <property name="connection.username">root</property>
        <!--数据库密码-->
        <property name="connection.password">123456</property>
        <!--数据库方言-->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>

        <!-- 设置数据库创建表的策略 -->
        <property name="hbm2ddl.auto">update</property>

        <!--在输出sql语句-->
        <property name="show_sql">true</property>

        <!--映射文件-->
        <!--两种方式，选一种即可-->
<!--        <mapping class="com.chapter05.pojo.User"/>-->
        <mapping resource="User.hbm.xml"/>
        
        
    </session-factory>
</hibernate-configuration>
  1. 创建pojo类
package com.chapter05.pojo;

public class User {
    private int id;
    private String username;
    private String password;

    public User() {
    }

    public User(String username, String password) {

        this.username = username;
        this.password = password;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
    
    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }
    
    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}
  1. 创建pojo类的映射文件Xxx.bhm.xml：在pojo类同目录下xxx.hbm.xml映射文件(IDEA创建的maven项目则在resources目录下创建映射文件)
<?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>
    
    <!--数据库为course_s2sh， 数据表为t_user-->
    <class name="com.chapter05.pojo.User" table="t_user" schema="course_s2sh">
        <!--id字段-->
        <id name="id">
            <column name="id" sql-type="int(11)"/>
            <!--主键生成策略：自增-->
            <generator class="native"/>
        </id>
        
        <!--username字段-->
        <property name="username">
            <column name="username" sql-type="varchar(20)" length="20" not-null="true"/>
        </property>
        
        <!--password字段-->
        <property name="password">
            <column name="password" sql-type="varchar(32)" length="32" not-null="true"/>
        </property>
    </class>
</hibernate-mapping>

创建好映射文件后，需在hibernate.cfg.xml文件中加入映射

在<session-factory></session-factory>里面添加，而且要放在最后

        <!--映射文件-->
        <!--两种方式，选一种即可-->
<!--        <mapping class="com.chapter05.pojo.User"/>-->
        <mapping resource="User.hbm.xml"/>
  1. 创建Hibernate5.4.3应用步骤

  • 1.服务注册，创建StandardServiceRegistryBuilder对象，MetadataSources对象

  • 2.创建SessionFactory对象

  • 3.打开session

  • 4.开启事务

  • 5.持久化操作

  • 6.提交事务

  • 7.关闭

【示例】完成一个添加用户的功能

    /**
    * 测试添加用户方法
    */
    @Test
    public void testAddUser(){
        User user = new User("alan", "123456");

        //1.服务注册
        StandardServiceRegistry ssr = new StandardServiceRegistryBuilder().configure().build();
        Metadata metadata = new MetadataSources(ssr).getMetadataBuilder()
                .applyImplicitNamingStrategy(ImplicitNamingStrategyComponentPathImpl.INSTANCE).build();

        //2.创建SessionFactory对象
        SessionFactory sessionFactory = metadata.getSessionFactoryBuilder().build();

        //3.打开Session
        Session session = sessionFactory.openSession();

        //4.开启事务
        Transaction transaction = session.beginTransaction();

        //5.持久化操作（添加了一个用户）
        session.save(user);

        //6.提交事务
        transaction.commit();

        //7.关闭Session
        session.close();

    }

3. 封装Hibernate工具类

通常一个应用程序只有一个SessionFactory对象的实例，并且SessionFactory对象的实例是唯一的、不可更改的。
所以要用单例模式实现SessionFactory。

【示例】创建HibernateUtil类

package com.chapter05.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.Metadata;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.model.naming.ImplicitNamingStrategyComponentPathImpl;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;

public class HibernateUtil {
    private static SessionFactory sessionFactory = null;
    private static Session session;
    
    static {
        //注册服务
        StandardServiceRegistry ssr = new StandardServiceRegistryBuilder().configure().build();
        Metadata metadata = new MetadataSources(ssr).getMetadataBuilder()
                .applyImplicitNamingStrategy(ImplicitNamingStrategyComponentPathImpl.INSTANCE).build();
        sessionFactory = metadata.getSessionFactoryBuilder().build();
        //打开session
        session = sessionFactory.openSession();
    }

    public static Session getSession() {
        return session;
    }

    public static void closeSession(){
        getSession().close();
    }

    public static Session getCurrentSession(){
        return sessionFactory.getCurrentSession();
    }
}

现在可以把上面增加用户的示例简化了：

    /**
     * 使用HibernateUtil工具类，简化程序
     */
    @Test
    public void testAddUser2() throws Exception {
        //获取Session
        Session session = HibernateUtil.getSession();
        //创建User对象
        User user = new User("李四", "123");
        //开启事务
        Transaction transaction = session.beginTransaction();
        try {
            //将对象持久化（存到数据库）
            session.save(user);
            //提交事务
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            //提交事务失败，回滚事务
            transaction.rollback();
        }

        HibernateUtil.closeSession();
    }

4. 实现增删查改功能


/**
     * 增加
     */
    @Test
    public void add(){
//        User user = new User("alan", "123456");
        User user = new User("alan2", "123456");

        //3.打开Session
        Session session = HibernateUtil.getSession();

        //4.开启事务
        Transaction transaction = session.beginTransaction();

        //5.持久化操作
        session.save(user);

        //6.提交事务
        transaction.commit();

        //7.关闭Session
        session.close();

    }


    /**
     * 删除
     */
    @Test
    public void delete(){
        Session session = HibernateUtil.getSession();
        Transaction transaction = session.beginTransaction();

        User user = session.get(User.class, 3);
        session.delete(user);
        System.out.println("删除成功");
        
        transaction.commit();
        HibernateUtil.closeSession();
    }


    /**
     * 查询
     */
    @Test
    public void query(){
        Session session = HibernateUtil.getSession();
        Transaction transaction = session.beginTransaction();
        User user = session.get(User.class, 2);
        System.out.println("get -> user: " + user);

        User user2 = session.load(User.class, 2);
        System.out.println("load -> user: " + user2);
        transaction.commit();
        HibernateUtil.closeSession();
    }

    /**
     * 修改
     */
    @Test
    public void update(){
        Session session = HibernateUtil.getSession();
        Transaction transaction = session.beginTransaction();
        User user = session.get(User.class, 2);
        user.setPassword("4321");
        session.update(user);
        transaction.commit();
        HibernateUtil.closeSession();
    }

5. 使用Query进行HQL查询

使用Query进行HQL查询的步骤：

  1. 获取Hibernate Session对象
  2. 编写HQL语句
  3. 以HQL语句作为参数，调用createQuery()方法创建Query对象
  4. 如果HQL语句包含参数，则调用Query的setXxx()方法为参数赋值
  5. 调用Query对象的list等方法返回查询结果

【示例】

    @Test
    public void testHQL(){
        Session session = HibernateUtil.getSession();

        Transaction transaction = session.beginTransaction();

        //HQL
        Query query = session.createQuery("from User");

        List<User> userList = query.list();

        for (User u : userList) {
            System.out.println("id = " + u.getId() + ", name = " + u.getUsername() + ", password = " + u.getPassword());
        }

        transaction.commit();
        HibernateUtil.closeSession();
    }

6. 使用Criteria进行条件查询

更加面向对象的查询方式Criteria查询。

【示例】

/**
     * 使用Criteria查询所有用户信息
     */
    @Test
    public void testCriteria(){
        Session session = HibernateUtil.getSession();
        Transaction transaction = session.beginTransaction();

        //Criteria查询
        Criteria criteria = session.createCriteria(User.class); //方法已过时
        //输出结果
        List<User> userList = criteria.list();
        for (User u : userList) {
            System.out.println(u);
        }

        transaction.commit();
        HibernateUtil.closeSession();
    }

7. POJO状态

  • 瞬时状态（Transient）
  • 持久化状态 (Persistent)
  • 脱管状态 (Detached)


转载：https://blog.csdn.net/qq1445654576/article/details/102151263
查看评论
* 以上用户言论只代表其个人观点，不代表本网站的观点或立场