hibernate学习笔记之一（下）

    <!-- C3P0连接池设定 -->
    <!-- 使用 C3P0连接池配置连接池提供的供应商 -->
    <property name="connection.provider_class">
      org.hibernate.c3p0.internal.C3P0ConnectionProvider
    </property>
    <!--在连接池中可用的数据库连接的最少数目 -->
    <property name="c3p0.min_size">5 </property>
    <!--在连接池中所有数据库连接的最大数目 -->
    <property name="c3p0.max_sizen">20 </property>
    <!--设定数据库连接的过期时间，以ms为单位，如果连接池中的某个数据库连接空闲状态的时间 超过timeout时间，则会从连接池中清除 -->
    <property name="c3p0.timeout">120 </property>
    <!--每3000s检查所有连接池中的空闲连接以s为单位 -->
    <property name="c3p0.idle_test_period">3000 </property>
    <!-- 映射文件配置 -->
    <mapping resource="com/hibernate/User.hbm.xml"/>

Configuration config=new Configuration().configure(); 
或
Configuration config = new Configuration().configure("文件的位置");

public class HibernateUtils {
    // 声明一个私有的静态final类型的Configuration对象
    private static final Configuration config;
    // 声明一个私有的静态的final类型的SessionFactory对象
    private static final SessionFactory factory;
    // 通过静态代码块构建SessionFactory
    static {
        config = new Configuration().configure();
        factory = config.buildSessionFactory();
    }
    // 提供一个公有的静态方法供外部获取，并返回一个session对象
    public static Session getSession() {
        return factory.openSession();
    }
}

//采用openSession方法创建Session
Session session = sessionFactory.openSession();
//采用getCurrentSession()方法创建Session
Session session = sessionFactory.getCurrentSession();

try{
    transaction = session.beginTransaction();   //开启事务
    session.save(user); //执行操作
    transaction.commit();   //提交事务
}catch(Exception e) {
    transaction.rollback(); //回滚事务
}finally{
    session.close();    //关闭资源
}

@Test
public void testFindAll() {
    Configuration config = new Configuration().configure();
    SessionFactory sessionFactory = config.buildSessionFactory();
    // 1.得到一个Session
    Session session = sessionFactory.openSession();
    Transaction transaction = session.beginTransaction();
    // 2.编写 HQL，其中的User代表的是类
    String hql = "from User";
    // 3.创建Query查询对象
    Query query = session.createQuery(hql);
    // 4.使用query.list()方法查询数据，并放入list集合
    List<User> list = query.list();
    for (User u : list) {
        System.out.println(u);
    }
    transaction.commit();
    session.close();
    sessionFactory.close();
}

@Test
    public void testQBC() {
        Configuration config = new Configuration().configure();
        SessionFactory sessionFactory = config.buildSessionFactory();
        // 1.得到一个Session
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        // 2.通过session获得Criteria对象
        Criteria criteria = session.createCriteria(User.class);
        // 3.使用Restrictions的eq方法设定查询条件为name="zhangsan"
        // 4.向Criteria对象中添加查询条件
        criteria.add(Restrictions.eq("name", "zhangsan"));
        // 5.执行Criterita的list()方法获得结果
        List<User> list = criteria.list();
        for (User u : list) {
            System.out.println(u);
        }
        transaction.commit();
        session.close();
        sessionFactory.close();
    }

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.example</groupId>
  <artifactId>hibernatedemo02</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>
  <name>hibernatedemo02 Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.20</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
    </dependency>
    <dependency>
      <groupId>c3p0</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.1.2</version>
    </dependency>
    <!-- 添加Hibernate依赖 -->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-annotations</artifactId>
      <version>3.2.1.ga</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-entitymanager</artifactId>
      <version>3.2.1.ga</version>
    </dependency>
    <!--    SLF4J-->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>1.7.32</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-nop</artifactId>
      <version>1.7.2</version>
    </dependency>
    <!-- 添加javassist -->
    <dependency>
      <groupId>javassist</groupId>
      <artifactId>javassist</artifactId>
      <version>3.12.0.GA</version>
    </dependency>
    <!-- mysql数据库的驱动包 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.6</version>
    </dependency>
  </dependencies>
  <build>
    <!--配置Maven 对resource文件 过滤 -->
    <resources>
      <resource>
        <directory>src/main/resources</directory>
        <includes>
          <include>**/*.properties</include>
          <include>**/*.xml</include>
          <include>**/*.xls</include>
          <include>**/*.xlsx</include>
        </includes>
        <filtering>true</filtering>
      </resource>
      <resource>
        <directory>src/main/java</directory>
        <includes>
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <filtering>true</filtering>
      </resource>
    </resources>
  </build>
</project>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!-- 指定方言 -->
        <property name="dialect">
            org.hibernate.dialect.MySQL5Dialect
        </property>
        <!-- 链接数据库url -->
        <property name="connection.url">
            jdbc:mysql://localhost:3306/hibernatelearn?useUnicode=true&amp;characterEncoding=utf-8
        </property>
        <!-- 连接数据库的用户名 -->
        <property name="connection.username">
            root
        </property>
        <!-- 数据库的密码 -->
        <property name="connection.password">
            root
        </property>
        <!-- 数据库驱动 -->
        <property name="connection.driver_class">
            com.mysql.jdbc.Driver
        </property>
        <!-- 显示sql语句 -->
        <property name="show_sql">
            true
        </property>
        <!-- 格式化sql语句 -->
        <property name="format_sql">true</property>
        <!-- 自动建表 -->
        <property name="hbm2ddl.auto">update</property>
        <!-- 映射文件配置 -->
        <mapping resource="Goods.hbm.xml" />
    </session-factory>
</hibernate-configuration>

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
/**
 * TODO 类描述
 *
 * @author qijian.
 * @date 2021/8/23 19:35
 */
public class HibernateUtils {
    /***
     * 声明一个私有的静态final类型的Configuration对象
     */
    private static final Configuration config;
    /**
     * 声明一个私有的静态的final类型的SessionFactory对象
     */
    private static final SessionFactory factory;
    /**
     * 通过静态代码块构建SessionFactory
     */
    static {
        config = new Configuration().configure();
        factory = config.buildSessionFactory();
    }
    /**
     * 提供一个公有的静态方法供外部获取，并返回一个session对象
     * @return 返回session
     */
    public static Session getSession() {
        return factory.openSession();
    }
}

public class Goods {
    private Integer id; // 标识id
    private String name; // 商品名称
    private Double price; // 商品价格
    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 Double getPrice() {
        return price;
    }
    public void setPrice(Double price) {
        this.price = price;
    }
    // 重写toString()方法
    @Override
    public String toString() {
        return "Goods[id=" + id + ",name=" + name + ",price=" + price + "]";
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.mengma.domain.Goods" >
        <id name="id"   type="integer">
            <generator class="native" />
        </id>
        <property name="name"   />
        <property name="price"  />
    </class>
</hibernate-mapping>

// 演示持久化对象的三种状态
@Test
public void test1() {
    Session session = HibernateUtils.getSession(); // 得到session对象
    Transaction tx = session.beginTransaction();
    Goods goods = new Goods();
    goods.setName("铅笔");
    goods.setPrice(0.5);
    //此时goods处于Transient态
    session.save(goods);
    //此时对象已由Hibernate纳入管理容器，处于持久态
    tx.commit();
    //事务提交后，库表中已经插入一条Goods的记录
    Transaction tx1 = session.beginTransaction();
    goods.setPrice(1.0);
    tx1.commit;
    //虽然这个事务中我们没有显示的调用Session.save方法保存goods对象
    //但是由于处于Persistent状态的对象将自动被固华到数据库中，因此
    //对象的变化也会被同步到数据库中
    //也就是说数据库中goods的记录数据已被更新
    session.close();
    System.out.println(goods);
}

// 证明一级缓存的存在
@Test
public void test2() {
    Session session = HibernateUtils.getSession(); // 得到session对象
    session.beginTransaction();
    // 获取goods1对象时，由于一级缓存中没有数据，所以会发送SQL语句，查询数据库中的内容
    Goods goods1 = (Goods) session.get(Goods.class, 1);
    System.out.println(goods1);
    // 获取goods2对象时，不会发出SQL语句，会从Session缓存中获取数据
    Goods goods2 = (Goods) session.get(Goods.class, 1);
    System.out.println(goods2);
    session.getTransaction().commit();
    session.close();
}

// hibernate快照
@Test
public void test3() {
    Session session = HibernateUtils.getSession(); // 得到session对象
    session.beginTransaction();
    Goods goods = new Goods();
    goods.setName("钢笔");
    goods.setPrice(5.0);
    session.save(goods);    // 向一级缓存中存入session对象
    goods.setPrice(4.5);    // 提交价格
    session.getTransaction().commit();    //提交事务
    session.close();    //关闭资源
}

// 刷出
@Test
public void test4() {
    Session session = HibernateUtils.getSession(); // 得到session对象
    session.beginTransaction();
    Goods goods = (Goods) session.get(Goods.class, 12);
    goods.setPrice(5.5);
    session.flush(); // 执行刷出操作，此时会发送update语句
    session.getTransaction().commit();
    session.close();
}

    // 清除
    @Test
    public void test5() {
        Session session = HibernateUtils.getSession(); // 得到session对象
        session.beginTransaction();
        Goods goods = (Goods) session.get(Goods.class, 12);
        System.out.println(goods);
        goods.setPrice(6.5);
        session.clear(); // 清空一级缓存
        session.getTransaction().commit();
        session.close();
    }

// 刷新
@Test
public void test6() {
    Session session = HibernateUtils.getSession(); // 得到session对象
    session.beginTransaction();
    Goods goods = (Goods) session.get(Goods.class, 12);
    goods.setPrice(7.5);
    session.refresh(goods); // 查询数据库，恢复快照和一级缓存中的数据
    session.getTransaction().commit();
    session.close();
}