Hibernate学习小结

忘是亡心i 2022-01-05 11:31 255阅读 0赞

## 1 Hibernate4.x 下获取SessionFactory ##

Configuration config = new Configuration().configure(); // 创建服务注册对象 ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry(); // 创建sessionFactory对象 SessionFactory sessionFactory = config.buildSessionFactory(serviceRegistry);

## 2 配置hibernate.cfg.xml文件 ##

<hibernate-configuration>
        <session-factory>
            
            <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
            <property name="connection.url">jdbc:mysql://localhost/hibernate?useUnicode=true&characterEncoding=utf-8</property>
            <property name="connection.username">root</property>
    
            <property name="connection.password">root</property>
    
            
            <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
            <property name="show_sql">true</property>
            <property name="format_sql">true</property>
    
            
            <property name="hbm2ddl.auto">update</property>
    
            
            <mapping resource="com/ma/hibernate/Student.hbm.xml"/>
            <mapping class="com.ma.hibernate.Teacher"/>
        </session-factory>
    </hibernate-configuration>

## 3 配置hibernate映射文件 .hbm.xml ##

<hibernate-mapping package="com.ma.entity">
         
        <class name="User" table="USER">
            
            <id name="id" column="id">
              
              <generator class="native"/>
            </id>
            
            <property name="username"/>
        </class>
    </hibernate-mapping>

## 4 openSession与getCurrentSession ##

*  open每次都获取一个新的session
 *  前者需手动关闭，后者自动关闭
 *  current获取当前上下文中的session对象，将 session 与本地线程绑定，提交事务时自动刷新session缓存并关闭session，需要配置hibernate.cfg.xml文件
 *  根据Id查询并修改对象信息时需要使用getCurrentSession()，在同一事务下

<property name="current_session_context_class">thread/jpa(全局的)</property>

## 5 get与load方法(装载对象)区别 ##

1.  get立即发出select语句，load在使用返回的对象时才发出
2.  对象不同：get得到的是实体类对象，load得到的是实体类的代理对象
3.  查询结果不同：get未查到数据时返回空，load并使用该对象时会报ObjectNotFoundException，查到结果后在使用之前关闭了session会抛异常：LazyInitializationException

## 6 hibernate对象的几种状态 ##

![1013480-20190201172800482-209961746.jpg][]

## 7 HQL ##

面向对象的sql语句，区分大小写

org.hibernate.query.Query query = session.createQuery("from Teacher t"); //from语句默认返回结果为一个List集合 List<Teacher> teachers = query.list(); query.uniqueResult(), 确保 HQL 语句只返回一个结果 // where： // is null // is [not] empty 在MySQL中会自动转换为 exists() // 删除数据：最好是先通过id获取对象并删除而不是拼接sql语句通过id删除（能够使用级联删除）

*  占位符？和 :param
    
     *  ?：query.setParameter(int index, Object obj); //index从0开始
     *  param：query.setParameter(Parameter param, Object obj)
 *  投影查询：select语句
    
     *  返回类型：默认为Object\[\], 只查询到一个数据时为Object
     *  返回相应的结果类型：new list(), new map(), new Constructor(..)
     *  去除重复值：使用distinct关键字，还可以通过将查到的List包装成一个HashSet(不允许重复)再包装成List
 *  迫切内连接：inner，不返回左侧不满足条件的结果
 *  多表连接查询：join

String hql = "select p from Product p join p.categorysecond cs join cs.category c where c.cid = ?";

*  左外连接：left join

from Teacher t LEFT JOIN t.students -- list()的 返回结果是个Object数组的集合，默认不会初始化右侧实体对象，使用distinct可以只查询到左侧对象

*  迫切左外连接：left join fetch，左外连接且把集合属性初始化

// from Teacher t LEFT JOIN FETCH t.students // list()的返回结果是存放着左侧实体对象的引用的集合，均被初始化（左侧所有和右侧满足条件的对象） // 关闭延迟加载后直接查询Orders即可查询到Orderiten信息 String hql = "from Orders o where o.user.uid = ?";

*  分页查询

//1. 使用query的两个方法 query.setFirstResult((pageNo - 1) * pageSize).setMaxResults(pageSize) //2. 使用HibernateTemplate + Criteria实现 DetachedCriteria criteria = DetachedCriteria.forClass(Product.class); criteria.add(Restrictions.eq("isHot", 1)).addOrder(Order.desc("pdate")); List<Product> products = (List<Product>) this.getHibernateTemplate().findByCriteria(criteria, 0, 10); //3. 使用HibernateTemplate分页的另一种写法 List<Product> list = this.getHibernateTemplate().execute(new PageHibernateCallback<>(hql, new Object[]{cid}, beginIndex, pageSize)); //PageHibernateCallback类 public class PageHibernateCallback<T> implements HibernateCallback<List<T>> { private String hql; private Object[] params; private int startIndex; private int pageSize; public PageHibernateCallback(String hql, Object[] params,int startIndex, int pageSize) { this.hql = hql; this.params = params; this.startIndex = startIndex; this.pageSize = pageSize; } public List<T> doInHibernate(Session session) throws HibernateException { //1 执行hql语句 Query query = session.createQuery(hql); //2 实际参数 if(params != null){ for(int i = 0 ; i < params.length ; i ++){ query.setParameter(i, params[i]); } } //3 分页 query.setFirstResult(startIndex); query.setMaxResults(pageSize); return query.list(); } }

*  自动生成字符串主键再添加对象到数据库

public String getNewSid() { Session session = sessionFactory.getCurrentSession(); String hql = "select max(sid) from Student"; String strid = (String) session.createQuery(hql).uniqueResult(); if(strid == null || strid.equals("")) { strid = "S0001"; } else { String temp = strid.substring(1); int id = Integer.parseInt(temp); temp = String.valueOf(++id); StringBuilder s = new StringBuilder(); s.append("S"); int length = temp.length(); for(int i=0; i<4-length; i++) { s.append("0"); } strid = s.append(temp).toString(); } return strid; }

## 8 QBC ##

public void testQBC() { Criteria c = session.createCriteria(User.class); //添加查询条件Criterion，使用Restrictions c.add(Restrictions.eq("id", 545)); // AND 使用Conjunction表示，实现了Criteria接口 Conjunction conjunction = Restrictions.conjunction(); conjunction.add(Restrictions.like("title", "tt", MatchMode.ANYWHERE)); // OR 使用Disjunction表示 Disjunction disjunction = Restrictions.disjunction(); c.add(conjunction).add(disjunction); System.out.println(conjunction + "\n" + disjunction); // 统计查询，使用Projection c.setProjection(Projections.max("id")); // 排序 c.addOrder(Order.asc("id")); //返回条件查询的结果集合 List list = c.list(); }

**调用本地SQL查询：（复杂SQL语句）**

String sql = "select * from user"; SQLQuery sqlQuery = session.createSQLQuery(sql); // 单表查询，指定结果类型 sqlQuery.addEntity(User.class); // 多表查询，将查询结果类型转换为UserVO sqlQuery.setResultTransformer(Transformers.aliasToBean(UserVO.class)); // 设置查询结果列的类型 addScalar("id",IntegerType.INSTANCE); List list = sqlQuery.list();

## 9 缓存策略： ##

一级缓存：Session级别的缓存，默认使用，不能关闭

*  flush()，检查缓存中的对象状态是否和数据库表记录一致，可能会发送sql语句以保证数据一致性，
    
     *  提交事务时会自动调用，也可显式调用。
     *  执行HQL或QBC查询时会先调用 flush() 方法，以获取最新数据
     *  当底层数据库使用自增方式生成主键时，会在执行 save()方法时先生成sql语句，但不会执行插入操作，因为必须保证主键的值是存在的
 *  refresh()，强制发送select语句，以保证缓存中的对象状态与数据库表中的记录一致，获取最新的对象信息。
    
     *  需要修改mysql的事务隔离级别，可在hibernate.cfg.xml中添加Connection.isolation值为2
 *  evict(obj)和clear()方法可以清除当前缓存

二级缓存（多个session可共同使用）：

1.  适用情形：不重要且很少被修改，允许出现偶尔的并发问题的数据
2.  query中的 list() 默认不使用缓存，iterate()使用二级缓存
3.  导入 hibernate 文档 lib 目录下 optional 目录下的 ehcache 的所有 jar 包
4.  导入 ehcache.xml 配置文件到当前WEB应用的src目录下
5.  使用注解：在使用二级缓存的实体类上加注解：@Cache(usage=CacheConcurrencyStrategy.*READ\_WRITE*)
6.  使用xml：配置 hibernate.cfg.xml

<property name="cache.use_second_level_cache">true</property>
     
     <property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>
     
     <property name="cache.provider_class">net.sf.ehcache.hibernate.EhCacheProvider</property>
     
     <mapping resource="com/ma/entity/Teacher.hbm.xml"/>
     
     <class-cache usage="read-only" class="com.ma.entity.Teacher"/>
     
     <cache usage="read-only"/>
     
     <class-cache usage="read-only" class="com.ma.entity.Teacher"/>
     <class-cache usage="read-only" class="com.ma.entity.Student"/>
     <collection-cache usage="read-only" collection="com.ma.entity.Teacher.students"/>
     
     
     <property name="cache.use_query_cache">true</property>

## 10 使用注解 ##

*  配置hibernate.cfg.xml：
 *  常用注解：
    
     *  @Entity：映射实体类，对应数据库的表
     *  @Table：配置对应表的信息
     *  @Embeddable：可嵌入式的类
     *  @Embedded：嵌入式类的对象（属性上的注解）
     *  @Id： 主键生成策略：
        
         *  @GeneratedValue(generator = "my")，使用hibernate的主键策略生成器
         *  @GenericGenerator(name = "my", strategy = "native")，name值要和generator的值一样
     *  @Column：数据库表字段注解
     *  @Enumerated：枚举类型的注解
     *  @Transient：映射时忽略此注解下的字段
     *  @Temporal(TemporalType.TIMESTAMP)：指定日期格式的类型
     *  联合主键（不常用）：
        
        1.  需要有个主键类，并实现序列化接口，重写equals和hashcode方法
        2.  @EmbeddedId，常用
        3.  @Id，@Embeddable，@IdClass(value=主键类)

## 11 **关联映射关系** ##

**双向原则：**

*  需指定控制方（通常为多方），inverse
 *  需在程序中设定双向关联（为引用赋值）

**XML：**

*  一对多（多对一）双向映射：
    
     *  保存时先保存一方，再保存多方，也可指定cascade属性
     *  保存时生成的语句：单向多对一直接保存多方的外键；单向一对多先保存各自的信息，在更新多方的外键
     *  获取到的对象：一方的引用是代理对象；多方的集合是hibernate内置的集合类型：具有延迟加载并存放代理对象的功能

<set name="students" table="student" inverse="true" order-by="gradeId" >
          
          <key column="gradeId"/>
          
          <one-to-many class="Student"/>
     </set>
     
     
     <many-to-one name="grade" class="Grade" column="gradeId" />

*  一对一双向外键：双方均持有对方的引用

<many-to-one name="cardId" class="CardId" column="caedid" unique="true" />
     
     <one-to-one name="student" class="Student" property-ref="grade"/>

*  一对一双向主键：双方均持有对方的引用

<id name="id" column="id">
       
       <generator class="foreign">
            
            <param name="property">grade</param>
       </generator>
     </id>
     
     <one-to-one name="grade" class="Grade" constrained="true"/>
     
     
     <one-to-one name="student" class="Student"/>

*  多对多双向映射：需要中间表，存放两张表的主键id，每个实体类的映射文件都需要进行如下配置，需要指定由谁控制(inverse)

*  继承映射
    
     *  subclass：只有一张表，父类配置如下：
        
         *  优点：只需要查询一张表
         *  缺点：1. 使用了辨别者列；2.子类特有字段不能添加非空约束；3.层次多时表字段数太多
    
        
         <discriminator column="TYPE" type="string" />
         
        
         <subclass name="Student" discriminator-value="STUDENT">
        
              <property name="age"/>
        
         </subclass>
    
     *  joined-subclass：每个子类一张表
        
         *  插入子类对象需要插入到两张表中
         *  优：没有辨别者列，可以添加约束，没有冗余字段
         *  缺：需要添加外键约束，查询总是需要多表连接
    
        <joined-subclass name="Student"table="STUDENT">
             <key column="SID" />
        
             <property name="age" />
        
         </joined-subclass>
    
     *  union-subclass：
        
         *  父类需要使用子查询
         *  存在冗余字段
         *  更新父类信息麻烦
    
        <union-subclass name="Student" table="STUDENT">
           <property name="age"></property>
         </union-subclass>
    
     *  联合主键（不常用）

<composite-id class="Order_User_PK" name="pk">
         <key-property name="oid" />
         <key-property name="uid" />
    
    </composite-id>

**Annotation：注解在属性或getter方法上**

1.  一对一单向外键：
    
     *  一方持有另一方的引用
     *  @OneToOne(cascade=CascadeType.*ALL*)
     *  @JoinColumn(name="card\_id", unique=**true**)
2.  一对一双向外键：
    
     *  两方都需要持有对方的引用
     *  一方参照一对一单向
     *  另一方：@OneToOne(mappedBy="card")，必须指定mappedBy属性（控制方）
3.  多对一单向外键：
    
     *  多方持有一方的引用(外键)
     *  @ManyToOne(cascade=\{CascadeType.*ALL*\}, fetch=FetchType.*EAGER*)
     *  @JoinColumn(name="sid") //name 为自定义为本表生成外键的列名称， referencedColumnName 为要关联表的列名称（可以不写，默认主键列）
4.  一对多单向外键：
    
     *  一方持有多方的Set集合（需初始化）
     *  @OneToMany(cascade=\{CascadeType.*ALL*\}, fetch=FetchType.*LAZY*)
     *  @JoinColumn(name="sid")，不写此项的话会生成中间表
5.  一对多（多对一）双向外键：
    
     *  多方：持有一方的引用
        
         *  @ManyToOne(cascade=\{CascadeType.*ALL*\}, fetch=FetchType.*EAGER*)
         *  @JoinColumn(name="user\_id")
     *  一方：持有多方的集合
        
         *  @OneToMany(mappedBy="user", cascade=\{CascadeType.*ALL*\}, fetch=FetchType.*LAZY*)，双向需要指定mappedBy属性，此时不能再使用@JoinColumn
6.  多对多单向外键
    
     *  需要一个中间表
     *  @ManyToMany
     *  @JoinTable(name="tea\_stu", joinColumns=\{@JoinColumn(name="stuid")\}, inverseJoinColumns=\{@JoinColumn(name="teaid")\})
7.  多对多双向外键
    
     *  @ManyToMany(mappedBy="teachers")
     *  另一方：参照多对多单向外键关联

## 12 检索策略 ##

*  类级别的检索策略
    
     *  立即检索：修改 hbm.xml 文件中的class节点，添加lazy属性为false，默认为true，仅对load方法有效
     *  延迟检索：load获取到的对象只保存OID属性，获取其他属性会发送SQL语句查询实例化实体对象
 *  一对多或多对多的检索策略：
    
     *  集合属性默认使用懒加载检索策略，修改set属性的lazy值（默认true/proxy），不建议改为false，可改为extra，增强的延迟检索(尽可能延迟集合初始化的时机)
     *  set中的batch-size：设置一次性初始化set集合的数量
     *  fetch：确定初始化集合的方式
        
         *  select：决定初始化集合的 sql 语句形式，subselect使用子查询方式初始化所有 set 集合，将忽略batch-size值
         *  join：决定初始化集合的时机，加载一方对象时使用迫切左外连接的方式检索n的一端的集合属性，将忽略lazy值
         *  使用Query.list()查询会忽略join，而使用默认的延迟检索

## **13 hibernate乐观锁（级联保存报错）** ##

转载于:https://www.cnblogs.com/mabaoqing/p/10346473.html

[1013480-20190201172800482-209961746.jpg]: /images/20211229/d5956de4b24a433fa51d6c341704137f.png