Hibernate

1.简介

Hibernate (避免使用繁琐的sql语句去操作数据 梦想)
1.操作数据的 对象关系型数据库 
使用 面向对象 的思想 去增删改查 2.直接插入一个User对象
2.获取要修改的对象 sava
3.根据你使用方法的不同 自动给你生成sql语句
4.HQL Hibernate特有的sql语句

1.## auto schema export  自动导出表结构. 自动建表
2.#hibernate.hbm2ddl.auto create        自动建表.每次框架运行都会创建新的表.以前表将会被覆盖,表数据会丢失.(开发环境中测试使用)
3.#hibernate.hbm2ddl.auto create-drop 自动建表.每次框架运行结束都会将所有表删除.(开发环境中测试使用)
4.#hibernate.hbm2ddl.auto update(推荐使用) 自动生成表.如果已经存在不会再生成.如果表有变动.自动更新表(不会删除任何数据).
5.#hibernate.hbm2ddl.auto validate  校验.不自动生成表.每次启动会校验数据库中表是否正确.校验失败.

2.操作方法

增加
save()
获取对象 再改
get(,)
load()
删除(根据 id)
delete()
HQL 语句 hibernate特有的SQL语句
createQuery()
sql 语句
createNativeQuery()

1.创建一个实体类User

 * 实体类
 * 需要创建实体类 对应的 映射文件
 * 名字规范(User.hbm.xml)
 * 1.与实体类名字相同
 * 2.与实体类在同一个包下
 * 3.xml文件
 */
public class User {
    private int id;
    private String username;
    private String password;
    public User() {
        super();
        // TODO Auto-generated constructor stub
    }
    public User(int id, String username, String password) {
        super();
        this.id = id;
        this.username = username;
        this.password = password;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", 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;
    }
}

2.在包下创建一个User.hbm.xml配置文件

<?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">
<!-- 让实体类 与 数据中的表建立起关系(字段与属性建立关系) -->
<!-- package可以添加包名 添加后底下可以省略包名 -->
<hibernate-mapping package="com.lanou3g">
  <!--  全类名 -->
  <class name="User" table="user">
  <!-- 设置主键关联 注意:表中必须有主键 -->
  <id name="id" column="id">
     <!-- 主键生成策略 -->
     <generator class="native"></generator>
  </id>
  <!-- 配置非主键属性 -->
   <property name="username" column="username"></property>
   <property name="password" column="password"></property>
   <!-- 注意:写完映射文件后 需要 跟配置文件进行关联 -->
  </class>
</hibernate-mapping>

3.在src下创建一个Hibernate.cfg.xml文件

<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<!-- hibernate配置的跟标签 -->
<hibernate-configuration>
<!-- sessionfactory(会话工厂)相当于 数据库连接池 -->
    <session-factory>
    <!-- 加载数据库的驱动类 -->
       <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
       <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/a_hibernate</property>
       <property name="hibernate.connection.username">root</property>
       <property name="hibernate.connection.password">123456</property>
      <!--  hibernate方言 mysql方言 limit -->
      <!-- 配置使用哪个类 全类名-->
      <property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
     <!--  在控制台输出SQL语句 -->
     <property name="hibernate.show_sql">true</property>
     <!-- 美化SQL语句 -->
     <property name="hibernate.format_sql">true</property>
    <!-- hibernate.hbm2ddl.auto是否自动生成表结构 -->
    <property name="hibernate.hbm2ddl.auto">update</property>
    <!-- 注意:映射实体类 全文件名从包名开始-->
    <mapping resource="com/lanou3g/User.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

4.简单封装HibernateUtils工具类

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtils {

    //把sessionFactory写成成员变量
    private static SessionFactory sessionFactory = null;
   static {
       //加载配置文件
       Configuration configuration = new Configuration().configure();
       //创建session工厂
        sessionFactory = configuration.buildSessionFactory();
   }
   //返回session方法
   public static Session getSession() {
    return sessionFactory.openSession();
}
    //返回当前session方法
   public static Session getCurrentSession() {
    return sessionFactory.getCurrentSession();
}
}

5.创建测试类测试HQL语句

import java.util.Arrays;
import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.query.NativeQuery;
import org.hibernate.query.Query;
import org.junit.jupiter.api.Test;
/*
 * hibernate
 * 配置文件默认名字
 * hibernate.cfg.xml
 * 基本配置:数据库的连接驱动 用户 密码 连接地址
 */
public class Demo01 {
    @Test
    public void  fun1() {
             /*
              * 添加对象到数据库
              */
        //1.加载配置文件
        //直接调用configure 系统会默认读取 hibernate.cfg.xml这个文件
        Configuration configuration = new Configuration().configure();
        //2.获取sessionFactory对象 相当于获取连接池对象
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        //3.从工厂中获取一个session对象
        //openSession()获取的是一个全新的session
        Session session = sessionFactory.openSession();
//      sessionFactory.getCurrentSession();//获取当前session
        //4.执行数据库插入对象
        User user = new User();
        user.setUsername("wanglong");
        user.setPassword("123");
        //使用session对象开启一个事物(返回一个事物对象)
        Transaction transaction = session.beginTransaction();
        //包裹要执行的任务
        session.save(user);
        //5.提交事物
        transaction.commit();
        //6.关闭资源
        session.close();
        sessionFactory.close();
    }

    @Test
    public void fun2() {
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        //修改对象
        //1.获取对象(根据id获取)
        User user = session.get(User.class, 11);
        //2.修改对象
        user.setUsername("zp");
        //3.把对象更新一遍
        //注意:修改的时候就使用update
        //3.把对象再保存一遍
        session.update(user);

        transaction.commit();
        session.close();
        sessionFactory.close();
    }
    @Test
    public void fun3() {
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        //查
        User user = session.get(User.class, 11);

        transaction.commit();
        session.close();
        sessionFactory.close();
        System.out.println(user);
    }
    /*
     * get和load方法区别
     * 相同:都能执行对象的执行
     * 不同点:
     * load方法的查询方式是懒加载(延迟加载)
     * load方法被执行时 不会跟get方法一样 立即生成SQL语句
     * 和执行 而是生成一个代理对象的属性
     * 这时会生成SQL语句 查询数据
     * 利用延迟加载提高了hibernate的执行效率
     */
    @Test
    public void fun4() {
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        //查
        User user = session.load(User.class, 11);
        transaction.commit();
        session.close();
        sessionFactory.close();
        //这时代理对象才会使用session去查询数据库
        //而session已经销毁 此次打印报错12 报错
        //System.out.println(user);
    }
    @Test
    public void fun5() {
        Configuration configuration = new Configuration().configure();
        //sessionFactory是线程安全的
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        //删(按id删除)
        //1.先查对象 把该对象删除
//      User user = session.get(User.class, 11);
//      session.delete(user);
        //2.创建一个对象 只赋值id 然后删除
        User user = new User();
        user.setId(18);
        session.delete(user);

        transaction.commit();
        session.close();
        sessionFactory.close();
        //这时代理对象才会使用session去查询数据库
        //而session已经销毁 报错
        //System.out.println(user);
    }
    //使用HQL查询
    @Test
    public void fun6() {
        //获取session对象
        Session session = HibernateUtils.getSession();
        Transaction transaction = session.beginTransaction();
        //查询方法
        //返回的是 保存查询结果的对象
        //Query<User> query = session.createQuery("from com.lanou3g.User");
        Query<User> query2 = session.createQuery("from User",User.class);
        //获取到查询结果的集合
        List<User> list = query2.list();
        System.out.println(list);
        transaction.commit();
        session.close();
    }
    //SQL语句查询
    @Test
    public void fun7() {
        //获取session对象
        Session session = HibernateUtils.getSession();
        Transaction transaction = session.beginTransaction();
        //直接使用SQL语句查询
        NativeQuery nativeQuery = session.createNativeQuery("select * from user");
        List<Object[]> list = nativeQuery.list();
        //list中保存几个对象 每一个对象是一个Object[]
        for (Object[] object : list) {
            System.out.println(Arrays.toString(object));
        }
        System.out.println(list);
        transaction.commit();
        session.close();
    }
}