Hibernate基础（一）

事务：

原子性：指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。
使用事务(用事务的sql语句(事务开始和事务提交) 包裹住 你要执行语句)
一致性：事务必须使数据库从一个一致性状态变换到另外一个一致性状态。
隔离性：事务的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离。
持久性：指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响

隔离级别：

赃读：指一个事务读取了另一个事务未提交的数据。

不可重复读：在一个事务内读取表中的某一行数据，多次读取结果不同。一个事务读取到了另一个事务提交后的数据。（update）

虚读（幻读）：是指在一个事务内读取到了别的事务插入的数据，导致前后读取不一致。(insert)

配置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>
    <!-- session-factory（会话工厂）相当于数据库连接池 -->
    <session-factory>
        <!-- 加载数据库的驱动类 基础设置 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/a_hibernate_01</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>
        <!-- hbm2ddl.auto 是否自动生成表结构 -->
        <property name="hibernate.hbm2ddl.auto">update</property>
        <!-- 注意：映射实体类 全文件名 从包名开始 -->
        <!-- 让配置文件知道有该实例类 -->
        <mapping resource="com/lanou3g/User.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

配置对象映射文件（对象名.hbm.xml）：

<!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>

增、删、改、查操作：

步骤：
1.加载配置文件
2.获取sessionFactory对象 相当于获取连接池对象
3.从工厂中获取一个session对象
4.开启session对象开启一个事物（返回一个事物对象）
5.关闭资源

添加对象到数据库：

@Test
public void fun() {
    //  直接调用configure()，系统会默认读取hibernate.cfg.xml文件
    Configuration configuration = new Configuration().configure();
    SessionFactory sessionFactory = configuration.buildSessionFactory();
    //  openSession()获取一个全新的session
    Session session = sessionFactory.openSession();
    //  向数据库插入对象
    User user = new User();
    user.setUsername("zhangsan");
    user.setPassword("123");
    Transaction transaction = session.beginTransaction();
    //  包裹要执行的任务
    session.save(user);
    //  提交事物
    transaction.commit();
    session.close();
    sessionFactory.close();
}

删除对象：

@Test
public void fun() {
    Configuration configuration = new Configuration().configure();
    SessionFactory sessionFactory = configuration.buildSessionFactory();
    Session session = sessionFactory.openSession();
    Transaction transaction = session.beginTransaction();
    //  删除对象
    //  1.先查对象，把该对象删除
    //  User user = session.get(User.class, 1);
    //  session.delete(user);
    //  2.创建一个对象，只赋值id，然后删除
    User user = new User();
    user.setId(2);
    session.delete(user);
    transaction.commit();
    session.close();
    sessionFactory.close();
}

修改对象：

@Test
public void fun() {
    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, 1);
    //  2.修改对象
    user.setUsername("wangwu");
    //  3.把对象更新一遍 
    //  注意：修改时就使用update
    session.update(user);
    transaction.commit();
    session.close();
    sessionFactory.close();
}

查询对象：

@Test
public void fun1() {
    Configuration configuration = new Configuration().configure();
    SessionFactory sessionFactory = configuration.buildSessionFactory();
    Session session = sessionFactory.openSession();
    Transaction transaction = session.beginTransaction();
    //  查询对象
    User user = session.get(User.class, 1);
    transaction.commit();
    session.close();
    sessionFactory.close();
    System.out.println(user);
}

@Test
public void fun2() {
    Configuration configuration = new Configuration().configure();
    SessionFactory sessionFactory = configuration.buildSessionFactory();
    Session session = sessionFactory.openSession();
    Transaction transaction = session.beginTransaction();
    //  查询
    User user = session.load(User.class, 1);
    transaction.commit();
    session.close();
    sessionFactory.close();
    //  这时代理对象才会使用session去查询数据库
    //  而session已经销毁了 报错
    System.out.println(user);
}

get和load方法区别：

相同：都可以进行对象查询
不同：load方法的查询方式是懒加载（延迟加载）
load方法被执行时，不会跟get方法一样，立即生成SQL语句和执行
而是生成一个代理对象，直接返回
只有当你访问了代理对象的属性时，才会去生成SQL语句查询数据库
利用延迟加载，提高了hibernate的执行效率

HQL查询：

@Test
public void fun6() {
    Configuration configuration = new Configuration().configure();
    SessionFactory sessionFactory = configuration.buildSessionFactory();
    Session session = sessionFactory.openSession();
    Transaction transaction = session.beginTransaction();
    //  查询方法
    //  返回的是保存查询结果的对象
    //  Query<User> query = session.createQuery("from com.lanou3g.User");
    Query<User> query = session.createQuery("from User", User.class);
    //  获取到查询结果的集合
    List<User> list = query.list();
    System.out.println(list);
    transaction.commit();
    session.close();
    sessionFactory.close();
}

SQL查询：

@Test
public void fun4() {
    Configuration configuration = new Configuration().configure();
    SessionFactory sessionFactory = configuration.buildSessionFactory();
    Session session = sessionFactory.openSession();
    Transaction transaction = session.beginTransaction();
    //  直接使用SQL语句查询
    NativeQuery nativeQuery = session.createNativeQuery("select * from user");
    //  list中保存了三个对象，每一个对象是一个Object[]
    //  三条数据对应三个Object[]
    List<Object[]> list = nativeQuery.list();
    for (Object[] objects : list) {
        System.out.println(Arrays.toString(objects));
    }
    transaction.commit();
    session.close();
    sessionFactory.close();
}