Hibernate基础（二）

Hibernate中的实体规则

　　创建实体类注意事项：

　　　　1.持久化类提供无参构造函数

　　　　2.成员变量私有 提供共有get set 方法

　　　　3.属性应尽量使用包装类 Integer、Float、Double等（如果用int 不赋值会默认0 如果Integer 不赋值默认null）

　　　　4.持久化类需要提供oid，与数据库中的主键列对应

　　　　5.不要用finall修饰类

　　主键类型：

　　　　1.自然主键（少见） 如果业务需要 某列必须有，且不重复，可以作为主键使用

　　　　2.代理主键（常见） 如果没有业务逻辑只需要一个数字 可以用这个

　　主键生成策略：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping SYSTEM "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd" >
<hibernate-mapping package="com.hibernate.domain">
    <class name="User" table="User">
        <!--id:主键，name:属性名称，column：字段名称  -->
        <id name="UserId" column="UserId">
            <!--generator:主键生成策略 class:标记主键如何生成 取值：
            1、native：自动增长，会根据当前的数据库自动切换
            2、identity：mySQL自己维护主键，录入时不需要指定主键
            3、sequence：Oracle的自增标记
            4、uuid:32位字符串
            5、assigned:自定义字符串
            6、foreign：外键
            7、increment：hibernate自己查询最大id+1进行插入-->
            <generator class="native"/>
        </id>

    </class>
</hibernate-mapping>

Hibernate中的对象状态

　　瞬时状态

　　　　没有id，没有与session关联

　　持久化状态

　　　　有id，与session关联

　　游离|托管状态

　　　　有id，没有与session关联

public class Main {
    public static void main(String[] args) {
        Session session = HibernateUtils.openSession();
        User user = new User(); //瞬时状态 没有id 没有与session关联
        user.setUserName("哈哈");
        session.save(user); //持久化状态 有id 有关联session
        session.close(); //游离|托管状态 有id，没有关联session
    }
}

Hibernate中的一级缓存

　　为了提高数据库中的操作效率

public class Main {
    public static void main(String[] args) {
        Session session = HibernateUtils.openSession();
        User u1= session.get(User.class,1);
        User u2= session.get(User.class,1);
        User u3= session.get(User.class,1);
        User u4= session.get(User.class,1);
        User u5= session.get(User.class,1);
        System.out.println(u3==u4); //true
        session.close();
    }
}

　　第一次执行步骤：

　　　　1.调用get查询

　　　　2.发送sql语句

　　　　3.resultSet返回

　　　　4.将resultset中的内容组装成User对象

　　　　5.存入session缓存

　　　　6.对象返回

　　第二次执行步骤：

　　　　1.先从缓存中查看是否存在id为1的user对象

　　　　2.如果有直接返回缓存中的

　　　　

Hibernate中的事务

　　事务特性：ACID（原子性、一致性、隔离性、持久性）

　　事务并发问题：

　　　　脏读：读到了正在操作还没提交的数据。

　　　　不可重复读：两次连续读取，数据不一致。（中间可能有人修改了）

　　　　幻|虚读：把user表整表删掉，结果有个人加了一条进去。

　　事务的隔离级别：

　　　　读未提交：会出现脏读、不可重复读、幻读

　　　　读已提交：可以解决脏读，不可解决不可重复读，幻读

　　　　可重复读：可以解决脏读，不可重复读，不可解决幻读 （mysql默认级别）

　　　　串行化：都可以解决，降低效率

　　在hibernate中指定数据库的隔离级别：

　　　　在hibernate.cfg.xml全局配置中

<!--
         0001 1: 读未提交
         0010 2: 读已提交
         0100 4: 可重复读
         1000 8: 串行化 -->
        <property name="hibernate.connection.isolation">4</property>

　　在项目中管理事务：

　　　　业务开始前打开事务，业务执行之后提交事务，执行过程中出现异常，回滚事务。

　　　　为了保证事务session对象的一致性，需要使用getCurrentSession(); 需要配置全局配置文件

<!--开启currentSession -->
        <property name="hibernate.current_session_context_class">thread</property>

        Session session1 = HibernateUtils.getCurrentSession();
        Session session2 = HibernateUtils.getCurrentSession();
        System.out.println(session1==session2); //true

返回同一个与线程绑定的session。

通过getCurrentSession()方法获得的session对象 提交事务时，自动会关闭session，不需要我们手动session.close()关闭。

public class Main {
    public static void main(String[] args) {
        Session session = HibernateUtils.getCurrentSession();
        Transaction trans = session.beginTransaction();
        try{
            session.save(new User("haha","hh",18,"男"));
        }catch (Exception e){
            trans.rollback();
        }
        trans.commit();
    }
}

Hibernate中的批量查询

　　HQL查询（Hibernate Query Language）主要用法

public class Main {
    public static void main(String[] args) {
        Session session = HibernateUtils.openSession();

        //查询userList
        String hql = "from User";
        Query query = session.createQuery(hql);
        List<User> users = query.list();
        System.out.println(users);

        //条件查询一个user
        String hql1 = "from User where UserId = 5";
        Query query1 = session.createQuery(hql1);
        User user = (User)query1.uniqueResult();
        System.out.println(user.getUserName());

        //占位符
        String hql2 = "from User where UserName = :UserName and Age = :Age";
        Query query2 = session.createQuery(hql2);
        query2.setParameter("UserName","武大郎");
        query2.setParameter("Age",18);
        User user2 = (User)query2.uniqueResult();
        System.out.println(user2.getUserName());

        //分页查询
        String hql3 = "from User";
        Query query3 = session.createQuery(hql3);
        query3.setFirstResult(0);
        query3.setMaxResults(10);
        List<User> list3 = query3.list();
        System.out.println(list3);
    }
}

　　Criteria查询(单表查询)

public class Main {
    public static void main(String[] args) {
        Session session = HibernateUtils.openSession();

        //查询列表
        Criteria criteria = session.createCriteria(User.class);
        List<User> list = criteria.list();
        System.out.println(list);

        //查询一条
        Criteria criteria1 = session.createCriteria(User.class);
        criteria1.add(Restrictions.eq("UserId", 1));
        User user1 = (User) criteria1.uniqueResult();
        System.out.println(user1.getUserName());

        //分页列表
        Criteria criteria2 = session.createCriteria(User.class);
        criteria2.setFirstResult(0);
        criteria2.setMaxResults(10);
        List<User> list2 = criteria2.list();
        System.out.println(list2);

    }
}

　　原生SQL查询

public class Main {
    public static void main(String[] args) {
        Session session = HibernateUtils.openSession();

        String sql = "select * from user";
        SQLQuery query = session.createSQLQuery(sql);
        List<User> list = query.list();
        System.out.println(list);

        SQLQuery query1 = session.createSQLQuery("select * from user where userId = :userId");
        query1.setParameter("userId",1);
        query1.addEntity(User.class);
        User user = (User) query1.uniqueResult();
        System.out.println(user.getUserName());

    }
}