Hibernate一些_方法_@注解_代码示例_html/css_WEB-ITnose-html教學-PHP中文網

首頁

web前端

html教學

Hibernate一些_方法_@注解_代码示例_html/css_WEB-ITnose

PHP中文网

Jun 24, 2016 am 11:34 AM

操作数据库7步骤 :
        1 创建一个SessionFactory对象
        2 创建Session对象
        3 开启事务Transaction　:　hibernate中,然后数据库操作,都必须是事务的,哪怕是查询
        4 执行数据保存操作(必须提交,才会执行对应的操作方法)
        5 提交事务
        6 关闭Session
                session.close();
                getCurrentSession();不需要手动关闭,opensession需要手动关闭
        7 关闭SessionFactory对象

//第一步
SessionFactory :

1 创建一个SessionFactory对象

    Configuration :

 //创建Configuration对象
    Configuration configuration = new Configuration().configuer();
    // 4.0之后为了分布式,用了这种设计  链接hibernate框架
        ServiceRegistry serviceRegistry = new ServiceRegistryBuilder()
                .applySettings(configuration.getProperties())
                .buildServiceRegistry();

登入後複製

SessionFactory :

        //创建一个SessionFactor对象
         SessionFactory sessionFactiony = null;
         给SessionFactory对象赋值
            sessionFactory = configuration.buildSessionFactory(serviceRegistry);
 //或  SessionFactory sessionFactiony  = configuration.buildSessionFactory(serviceRegistry);//也行,一样

登入後複製

//第二步
Session :

    2 创建 Session对象
        //用上面创建好的SessionFactory对象,调用方法,创建一个session对象
    (1) Session session = sessionFactory.getCurrentSession();
    (2) Session session = sessionFactory.opensession();

    getCurrentSession :

        创建session对象如果有,就不创建,如果没有就创建
        Session session = sessionFactory.getCurrentSession();
        并且,自动关闭资源不用写 session.close();

    opensession :

        创建session对象,别管有没有,都创建
        Session session = sessionFactory.opensession();

        并且,用手动关闭资源,
            session.close();

//第三步
Transaction :

    3 开启事务:hibernate中,然后数据库操作,都必须是事务的,哪怕是查询
       Transaction transaction = session.beginTransaction();

//第四步

    4 执行数据保存操作

    //增
    Save :

     Save();//添加语句方法,生成insert into 表名(列,列)values(?,?)

    //删
    Delete :

        Delete();//删除语句方法,生成delete from 表 where id=?;

    //改
    Update :

        Update();//修改语句,
            //如果表里面有对应的语句,就生成修改语句update 表名 set (列名,列名)=(列值,列值) where id = ?;

    //查
    Load :

        Load();//查询语句方法,生成查询语句,select * from 表 where id=?
        //如果不访问里面的属性,就只是查询一下,并不会执行到数据库,除非用里面每行对应的对象,去调用一个属性,才会真正的到数据库
        //如果只是提交了,没有访问里面的属性,不会生成查询语句,就是没有对数据库进行操作

    Get :

        Get();//查询语句方法,生成查询语句,select * from 表 where id=?
        //只要提交,就会生成查询语句,

//Get()和Load()的区别   Load()和Get()的区别

        Get() : 只要调用Get()方法并提交,就直接生成查询语句去访问数据库
        Load() : 要调用Load()方法并提交,且,如果没有访问对象里面的属性,不会生成查询语句,也不会操作数据库,一定要获取一下属性,获取对象引用,也算获取属性

//第五步
commit :
     5 提交事务
       transaction.commit();// 提交事务
        transaction是第三步,开启事务的对象

//第六步
Session_close :
    6 关闭Session
       // session.close();//getCurrentSession();不需要手动关闭,opensession需要手动关闭

//第七步
    SessionFactory_close :
    7 关闭SessionFactory对象
       sessionFactory.close();

//强注解,强注释

!!!对表来说,只有多的一方保存少的一方的引用,那些设置都是给程序看的,和数据库没有任何关系!!!

@ :
    @Entity 在类名上面加的,用于创建表默认是类名
        创建实体类和数据标的映射,指定表名
        将一个类声明为一个实体bean（即一个持久化POJO类）。
        @Entity(name="表名") 这样也行,就规定了表名

        @Table :
            @Table(name="表名");也行
     //1 必须得加:

    @IdClass 让两个类关联起来后面是类名
        在类上面写
        联合主键,就是把主键都写在后面指定的类中
        @IdClass(value=StudentPK.class)


    @Column 设置当前列在修改的时候,是否可以被修改
        在实体类的get**()方法上写 , 就是对于的列
        @Column(updatable=false) false就是修改的时候,这个列不能被修改
        里面对应的值 :

            name 指定列名(默认是属性名)

            unique 设置该列是否设置唯一约束默认值是false

            nullable 设置该列的值是否可以为空,默认值是false

            insertable 该列是否作为生成insert语句中的一个列,默认值是true 就是添加的时候,不在此列添加值

            updatetable 该列是否作为生成updatetable语句中的一个列,默认是true 就是修改的时候,不修改此列

            columnDefinition   为这个特定列覆盖sql ddl片段(这可能导致无法在不同数据库间移植)

            table 定义对应的表默认为主表

            length 列长度, 默认值255

            precision 列十进制精度(decimal precision) 默认值0   此列最大值为N位位数

            scale 如果列十进制数值范围(decimal scale)可用,在此设置,默认值0

从数据库查询出来的数据,我都保存在这里
    DTO : 叫Date Traction Object
    VO : 值对象 Value Object

    @SequenceGenerator :
        序列生成器
           @SequenceGenerator(name="sequenceGenerator",sequenceName="Msg_SEQ",initialValue=0,allocationSize=1)//生成器名字,序列的名字,起始值为0,步长为1

    @TableGenerator   生成器写在类上面
    //用来存放实体类对应的表,下一次要用的id(存放id的表)
    //为主键单独创建一个表,可以跨数据库平台,MySQL主键自增是自己指定,不是外界指定,可能相同

    //有什么好处,能够解决数据跨平台保存的问题,因为不同的数据库平台生成数据的方式不一样,比如primary key(pk),如何还能保证呢?自己写个类库,兼容不同平台
//这里的方式是新建一张表,专门用于保存ID,表名:GENERATOR_TABLE,表里面有两列
//第一列,保存pkColumnName="key", 主键所在列的名字
//第二列,保存Id值 valueColumnName="studentId"
//第三列和第四列保存的是值:第三列是key的值,就是要保存id的表名,第四列要保存的步进值,初始值默认是一
//这就意味着,该表可以为无数的表保存Id值,只要对应的表来去一次值,id默认就会加一.有点像一个序列的集合

    @TableGenerator( //生成器
       name = "student_GEN",//生成器的名字
       table = "GENERATOR_TABLE",   //在数据库中,表的名字
       pkColumnName = "key", //主键所在列的名字
       valueColumnName = "studentId",   //保存下一次,要保存id列的数据,是去这里取得的ID的值
       pkColumnValue = "Student",   //指定要用到Id的那张表
        initialValue=1,             //起始值为1
       allocationSize = 1          //步长为1
       )

    @Id 在实体类的getId()上面强注释
        获取对应的id作为列名,并能在这个方法中,获取id的值
        相当于设置表里面的主键

    @GeneratedValue //在@id和getId()直接设置的去生成器里面拿值,让每次要添加的数据,ID不相同,不唯一设置该列自增

    generator="生成器的名字" //在哪个生成器取Id
    5种格式
        1 Auto   随机
        2 table   生成一个表,存放在表里面
        3 Identity 序列一类的
        4 sequence   序列生成器,生成序列化的数字
        5 自定义   自己写的
    @GeneratedValue(strategy=GenerationType.生成的格式 , generator="生成器的名字")
    @GeneratedValue(strategy=GenerationType.TABLE , generator="student_GEN")

    @OneToOne

        要么都写,一个写@oneToone 一个写@ManyToOne
        要么在多的里面写@ManyToOne   多的里面必须要加 unique="true" 设置唯一就是一对一了

        XML :
    @OneToOne(mappedBy="wife")
        //我不保留对方的引用,只让对方保存我的引用,并且,是对方的wife那条属性,保存的是我的引用,
        告诉hibernate我们是一对一关系,但是映射是在husband的wife的属性做的,以那边为标准,这边不用管,但是那边的属性指向的是wife的id
        就是在对面表中,生成一个列,这个列,专门保存本表的id的引用,当本表添加的时候,就让对面表的这个列,生成一个值,当对面表添加的时候,会参考这个列,生成一个ID,当做对面表的ID
            在本实体类中,获取另外一个类的属性的get**()上面写
            @OneToOne
                告诉hibernate我们是一对一关系,但是映射是在husband的wife的属性做的,以那边为标准,这边不用管,但是那边的属性指向的是wife

    @ManyToOne

        告诉hibernate我们是多对一的关系

        多对一必须写在多的里面

    @JoinTable : //更改表的名字和列的名字

    @ManyToMany//多对多

   // 想更改表的名字和列的名字
   @JoinTable(name = "t_s", // 表名中间表
            joinColumns = { @JoinColumn(name = "teacher_id") },// 中间表的列名
   inverseJoinColumns = { @JoinColumn(name = "student_id") })//上面的列名指向的是谁,先通过上面指定的列名,找到这个列名,就能找到student表

    @JoinColumn

        自己指定外键列的名字,还可以指定长度,约束等
        @JoinColumn(name="wifeid") 指定外键名字为wifeid 写在外键列的get外键引用()方法上面

            //在少的表,设置多的表中,保存少的表的引用的列的列名
            //多的表,保存少的表的引用的那个列的列名

    @Embedded

           把两个表弄成一个表,且另一个表没有@Entity,写在get**()方法上面
        @Embedded(name="asd")指定别的表,保存当前表的引用的那个列的列名

!!!只有在一对一的时候,才有主键映射和外键映射
//主键映射

        @PrimaryKeyJoinColumn
        在对面引用的列上面加 @PrimaryKeyJoinColumn 就是主键映射
        主键映射 : 不会多生成一个列,添加的时候,会去参照另一个表的主键来生成本表的主键,本表主键和另一个表的主键有关联

//外键映射

        @ForeignKeyJoinColumn
         @OneToOne(mappedBy="wife") //我不保留对面的引用,让对面来保存我的引用,并且是保存在对面的wife这个属性,
         //我不保存对面的引用,让对面用wife这个属性来保存我的引用

        外键映射 : 多生成一个列,添加的时候,这个新的列会去参照另一个表的主键,让这个列,和另一个表有关联

mappedBy :

    只要是有双向的关系,就必须保持对方的引用,必须有mappendBy(对面)(限于双向) 少的一方必须用set集合保存多的一方的引用,且两边都注明多对以@ManyToOne(多的写) 和@OneToMany(一个的写)

    对表来说,只有多的一方保存少的一方的引用,那些设置都是给程序看的,和数据库没有任何关系

@OneToMany(mappedBy="group",//就是在对面表中,生成一个列,这个列,专门保存本表的id的引用,当本表添加的时候,就让对面表的这个列,生成一个值,当对面表添加的时候,会参考这个列,生成一个ID,当做对面表的ID
           cascade={CascadeType.ALL},//设置级联操作,在什么时候起作用
           fetch=FetchType.EAGER //级联操作的时机,这里默认是Lazy因为是少的一方

           )

cascade :

    cascade={CascadeType.ALL/DETACH/MERGE/PERSIST/REFRESH/REMOVE/自定义};
    //设置级联操作在什么时候起作用,就是A的增删改查,B也有改变,就相当于是绑定了事件,后面的值,就是事件,当触发这个事件的时候,就A,B两个表的属性都更新同步,级联操作
        ALL : 是所有操作都级联
        DETACH :
        MERGE : 也就是修改的时候,相当于update,级联
        REMOVE : 删除的时候,级联
        还有自定义
fetch :

    fetch=FetchType.EAGER/LAZY   //这是级联操作的时机,
        EAGER : 的时候,是比如 A里面有个列保存了B的引用,如果这里设置的是EAGER.那取出或者查看的时候,会把这个保存B的引用的那个列也拿出来,

        生成语句 :
        //生成一条查询语句

        LAZY : 的时候,是如果 A里面有个列保存了B的引用,如果这里设置的是LAZY,那取出或者查看的时候,不会把这个保存B的引用的那个列拿出来,只取出别的列,如果在关闭session对象(缓冲)之前,用到那个保存B的引用的那个列,就会再生成一个查询语句,去数据库查询,再把那个列拿出来

         生成语句 :
        //如果用到保存B引用的那个列,就会生成两个查询语句,否则就是生成一个查询语句,并且第一次查询语句中不包括保存B引用的那个列

//执行顺序
@Before/@BerforeClass -- > @Test --> @After/@AfterClass

    @Before :

        用于测试类中 , 用它强注释的,是第一个执行的,
        测试方法是成员方法此方法是公共的,没有返回值的,没有参数列表的,成员方法

    @BerforeClass

        用于测试类中 , 用它强注释的,是第一个执行的,
        测试方法是静态方法此方法是公共的,静态的,没有返回值的,没有参数列表的,静态方法

    @Test :

        测试方法 :
            1 公共的的成员方法
            2 没有返回值
            3 没有形参列表

    @After :

        用于测试类中 , 用它强注释的,是最后一个执行的,
        测试方法是成员方法此方法是公共的,没有返回值的,没有参数列表的,成员方法

    @AfterClass :

         用于测试类中 , 用它强注释的,是最后一个执行的,
        测试方法是静态方法此方法是公共的,静态的,没有返回值的,没有参数列表的,静态方法

//三种状态 :

        瞬时状态(临时状态)--->持久状态(保存到数据库)--->游离状态(保存完成后关闭session对象 (session.close()))

    //三种状态的区分关键在于
        1 有没有ID
        2 ID在数据库中有没有
        3 内存中有没有(session缓存)

Transient :

    Transient(瞬时状态) : 内存中一个实体类对象,没有ID,缓存中也没有
    //实例化实体类的时候,就是瞬时状态

Persistent :

    Persistent(持久状态) : 内存中有,缓存中有,数据库中有(ID)
    //保存到数据库中,就是持久状态

Detached :

    Detached(游离状态) : 内存有,缓存没有,数据库有,ID
    //关闭session对象之后(session.close()),就是游离状态

    //这三种状态需要关注的问题是在该状态下,如果进行数据库操作会发生什么结果,比如改变属性的值会不会发出update语句

        瞬时状态 : 不会发出update语句
        持久状态和游离状态都会发出update语句

//联合主键

    @EmbeddedId : 嵌入的,写在实体类中,主键类的引用上面,对应的get主键类();方法上面
    @Embeddable : 可被嵌入的,该类作为另一个类的一部分,写在主键类中,
    1
    @IdClass :
    比如说是两个主键,id和name列,就在实体类中的getId()和getName()上面,加@id 声明主键,并且在类上面写 @IdClass(写的主键类名.class),    再把这两个主键写在一个实体类中,
    但是这个存有多个主键的实体类,必须实现serializable这个接口
    在主键类的类上面,不用写@Embeddable

2
    @EmbeddedId :
    或者是本类中不写id和name,但是有主键类的引用,然后在主键类对应的get主键类();方法上面,写个@EmbeddedId,就行了
    但是在主键类的类上面,要写@Embeddable


//关联两个表

    new SchemaExport(new AnnotationConfiguration().configure()).create(false, true);

//面向对象的形式 :

HQL :

Query :

//---------------------------模糊查询

QBE :
       Topic tExample = new Topic();//自己写的类
        //创建类对象,就是一个表中的一个行的属性
       tExample.setTitle("T_");//往对象里面设置属性(set***()方法) , 像T_的,一个典型,只能是一个确定值的对象,用于搜索,

       Example e = Example.create(tExample).ignoreCase().enableLike();// 静态方法添加模糊查询的方法
       Criteria c = session.createCriteria(Topic.class)//给指定类(表)添加约束
               .add(Restrictions.gt("id", 2))//id属性大于2的
                .add(Restrictions.lt("id", 8))//id属性小于8的
               .add(e);//上面写好的模糊查询 "T_"

//-----------------1+N

//1+N:只要查询当前对象,他就会查询别的
   //可以多表查询,可以解决1+N问题
   //设置为Lazy
@BatchSize :

        @BatchSize(size = 5);////@BathSize: 默认是一个一个抓取,这里可以指定每次抓取的个数
        写在类上面

left_outer_join_fetch :

    (用iterator(迭代器)就不能使用join)

     Query q = session.createQuery("from Topic t left outer join fetch t.category c ");//Topic是对象,对象里面有个属性是另外一个表的引用,t.category就能获得另外一个类对应的表和其中的属性

        List topics = q.list();//把查询出来的值,封装到对应的对象中,再封装到list集合中
        简写 :
            List topics = session.createQuery("from Topic t left outer join fetch t.category c");

前提 : 必须有一个对象(表)中的属性(列),保存的是另一个表的引用
    如 : Topic对象中有个属性保存了Category的引用

    如 : List topics = session.createQuery("from 表1 别名(t) left outer join fetch t.表名2 别名(c)");

    inner_join_fetch :

         List topics = session.createQuery("from Topic t inner join fetch t.category c");

    left_outer_join_fetch :

    结果集 :
        表2在表1的左边
         //先查询Topic对象对应的表,再通过topic找到category对应的表,都查询出来,并且,category对应的表,查询出来并显示在Topic的左面 (相当于把两个表的结果集,合并成一个表,一个在左面,一个在右面)
        List topics = session.createQuery("from Topic t left outer join fetch t.category c");

    right_outer_join_fetch :

    结果集 :
        表2在表1的右边
         //先查询Topic对象对应的表,再通过topic找到category对应的表,都查询出来,并且,category对应的表,查询出来并显示在Topic的右面 (相当于把两个表的结果集,合并成一个表,一个在左面,一个在右面)
         List topics = session.createQuery("from Topic t right outer join fetch t.category c");

iterator :

       // iterator: 如果使用不允许使用join
        //迭代器,把查询的数据直接用迭代器遍历
        Iterator<泛型,一般用于对象名> categories = session.createQuery("from 对象别名").iterate();//
        Iterator categories = session.createQuery("from Category c").iterate();//

       while (categories.hasNext()) {//hasNext(),是问下一位还有没有元素,返回值为boolean型,true/false
           Category c = categories.next();//next()是取得下一位元素的值,
           System.out.println(c.getName());//因为里面都是对象,所以可以通过上面获取的对象的引用,去访问对象里面的属性
       }

Cacheable :

        开启缓存,要和ehcache.xml一起使用
        List categories = session.createQuery("from Category").setCacheable(true).list();//查询Category对象对应的表,然后放入缓存中,封装到list集合中
        setCacheable(true);//开启缓存