• Hibernate框架知识要点总结


    1.常见映射:

    • 复合主键映射
    //首先要把多个主键字段封装成一个类,并实现Serializable接口
    public class Composite implements Serializable{
         private String id;//key1
         private String name;//key2
    }
    //要映射的类
    public class stu{
        private Composite keys;
        private String dept;
    }
    //写配置(要点)
    <composite-id name="keys">
       <key-property name="id" column=""></key-property>
       <key-property name="name" column=""></key-property>
    </composite-id>
    
    
    • 集合映射(list,set,map)
    //set
    <set name="" table="">
      <key column=""></key>
      <element column="" type=""></element>
    </set>
    
    //list
    <list name="" table="">
      <key column=""></key>
      <index column=""></index>
      <element column="" type=""></element>
    </list>
    
    //map
    <map name="" table="">
      <key column=""></key>
      <map-key column="" type=""></map-key>
      <element column="" type=""></element>
    </map>
    • 一对多,多对一
    //1的一方
    public class  Dept{
      private int id;
      private String deptName;
      private Set<Employee>employees;
    }
    //多的一方
    public class Employee{
      private int empId;
      private String empName;
      private Dept dept;
    }
    
    //写配置(要点)
    //一的一方的配置
    <set name="" >
      <key column=""></key>
      <one-to-many class=""/>
    </set>
    //多的一方
    <many-to-one name="" column="" class=""></many-to-one>
    • 多对多
    //Project
    public class Project{
     private int Pid;
     private String PName;
     private Set<Developer>developers;
    }
    //Developer
    public class Developer{
     private int Did;
     private String DName;
     private Set<Project>projects;
    }
    
    //写配置(要点项)
    多对多(中间表实现)
    <set name="集合属性的名字" table="中间表的名字">
      <key column="中间表引用的字段名(外键,对应当前配置表的主键)"></key>
      <many-to-many column="中间表外键对应的字段" class="集合属性的类型s"></many-to-many>
    </set>
    • 一对一
    1. 添加外键的方式
      //Person
      public class Person{
        private int Pid;
        private String name;
        private IdCard idcard;
      }
      
      //IdCard
      public class IdCard{
        private int id;//身份证号
      }
      
      //写配置(要点)
      //无外键的一方
       <one-to-one name="" class=""></one-to-one>
      //有外键的一方
      <many-to-one name="" column="" class="" unique="true 多对一并且外键为唯一值实现一对一" ></many-to-one>

    2. 添加主键的方式
      //Person
      public class Person{
        private int Pid;
        private String name;
        private IdCard idcard;
      }
      
      //IdCard
      public class IdCard{
        private int personId;IdCard主键。引用Person的主键
        private int id;//身份证号
      }
      //写配置(要点)
      <id name="">
            <generator class="foreign">
      				<param name="property">和下面的name要一样</param>
      			</generator>
          </id>
          <one-to-one name="" class="" constrained="true 添加外键约束"></one-to-one>
    • 组合映射
               
    //汽车
    public class Car {
    	private int id;
    	private String name;
    	private double price;
    	// 汽车的,轮子
    	private Wheel wheel; // 映射: 叫组件映射!
    	}
    //轮子
    public class Wheel {
    	private double size;
    	private int count;
    }
    
    //写配置
    //组合映射(类中包含类,映射到同一张表)
    <component name="" class="">
      <property name="" type=""></property>
    </component>
    

    • 继承映射(简单继承映射,复杂继承映射)
    1. 简单继承映射:就是每个子类都写一个配置 
    	父类子类字段都通过<property></property>配置,
    	只在子类中写配置,父类不用写
    
    
    
    
    
    
              2.复杂继承映射又分为3类,映射为一个表,2个表,多个表
                   复杂映射的配置文件都写在父类中。
                   1、父类,子类都映射到同一张表
                    
    //首先要定义一个鉴别器。鉴别器是用来区别鉴别表的每一条记录是来哪个子类的。注意:这个定义一定要写在主键<key></key>后面
    <discriminator column="" type=""></discriminator>
    //然后每个子类都要写
    <subclass name="子类名" class="" discriminator-value="鉴别器的值,要根据鉴别器的类型写">
           <property name="" type=""></property>
    </subclass>
    2.父类单独映射为一张表。所有子类也各映射一张表,这张表的主键是引用父类表的主键
            
    <joined-subclass name="" table="">
              <key column=""/>
             <property name="" type=""></property>
        <joined-subclass>
    3.每个子类都映射一张表,父类不映射
     <id name="">
          <generator class="不能为自增长主键生成器"></generator> 
        </id>
        <union-subclass name="" table="">
           <property name="" type=""></property>
        </union-subclass>


    2.lazy,inverse,cascade

    • lazy:懒加载
    • inverse:控制权限反转
    • cascade:级联

    3.对象状态

    • 临时状态
    • 持久化状态
    • 游离状态

    4.查询方式

    • 主键查询、对象查询
    • hql查询
    • criter查询
    •  

    4.一级缓存

    5.二级缓存

    1.集合缓存

    2.开启hql查询缓存

    首先要配置,表示开启hql查询缓存
    <!-- 二级查询缓存开启 -->
    <property name="hibernate.cache.use_query_cache">true</property>
    
    然后在createQuery(" ")后再加一个setCacheable()方法
    session.createQuery("from Dept").setCacheable(true);//表示查询数据放入二级缓存/从二级缓存取



    6.C3P0连接池

    7.session创建的2种方式



        

  • 相关阅读:
    opentsdb安装部署
    python发送邮件(html)例子
    python查库写库例子
    获取rds的cpu和内存使用情况
    数据库损坏的情况下如何获取到dbid
    grafana安装升级部署
    Specified key was too long
    mysql动态执行sql批量删除数据
    kafka删除topics
    cratedb导入json文件
  • 原文地址:https://www.cnblogs.com/chenny3/p/10226219.html
Copyright © 2020-2023  润新知