hiberbate

笔记

1.什么是hibernate Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的JaveEE架构中取代CMP，完成数据持久化的重任。 特点:

将对数据库的操作转换为对Java对象的操作，从而简化开发。通过修改一个"持久化"对象的属性从而修改数据库表中对应的记录数据。
提供线程和进程两个级别的缓存提升应用程序性能。
有丰富的映射方式将Java对象之间的关系转换为数据库表之间的关系。
屏蔽不同数据库实现之间的差异。在Hibernate中只需要通过"方言"的形式指定当前使用的数据库，就可以根据底层数据库的实际情况生成适合的SQL语句。
非侵入式:Hibernate不要求持久化类实现任何接口或继承任何类，POJO即可。

hibernate的基本使用 1.创建maven项目导入依赖


    
        junit
        junit
        4.12
        test
    
    
        org.hibernate
        hibernate-entitymanager
        5.4.21.Final
    
    
    
        org.hibernate
        hibernate-core
        5.4.21.Final
    
    
        log4j
        log4j
        1.2.16
    
    
        mysql
        mysql-connector-java
        8.0.12

2.配置核心文件类路径下META-INF下创建persistence.xml文件

<?xml version="1.0" encoding="UTF-8"?>

    
    
        
        org.hibernate.jpa.HibernatePersistenceProvider

3.编写客户的实体类

/**
* 客户的实体类
*      配置映射关系
*          1.实体类和表的映射关系
*          2.实体类属性和表中字段的映射关系
*/


/*
* @Entity:声明实体类
* @Table:配置实体类和表的映射关系
*   name:配置数据库表的名称
*
*
* */


@Entity
@Table(name = "cst_customer")
public class Customer {


    /**
     * @Id:声明主键的配置
     * @GeneratedValue:配置主键的生成策略
     *      strategy:
     *          GenerationType.IDENTITY表示自增
     *
     * @Column:配置属性和字段的映射关系
     *      name:数据库表中字段的名称
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "cust_id")
    private Long custId;


    @Column(name = "cust_name")
    private String custName;


    @Column(name = "cust_source")
    private String custSource;


    @Column(name = "cust_industry")
    private String custIndustry;


    @Column(name = "cust_level")
    private String custLevel;


    @Column(name = "cust_address")
    private String custAddress;


    @Column(name = "cust_phone")
    private String custPhone;

4.测试

/**
* 测试jpa的保存
*      案例:保存一个客户到数据库中
* Jpa的操作步骤:
*      1.加载配置文件创建工厂对象(实体管理类工厂)对象
*      2.通过实体管理类工厂获取实体管理器
*      3.获取事务对象,开启事务
*      4.完成增删改查操作
*      5.提交事务(回滚事务)
*      6.释放资源
*/


@Test
public void testSave(){
    //  1.加载配置文件创建工厂对象(实体管理类工厂)对象
    EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
    //  2.通过实体管理类工厂获取实体管理器
    EntityManager entityManager = factory.createEntityManager();
    //  3.获取事务对象,开启事务
    EntityTransaction tx = entityManager.getTransaction(); //获取事务对象
    tx.begin(); //开启事务


    //  4.完成增删改查操作
    Customer customer = new Customer();
    customer.setCustName("gg");
    customer.setCustAddress("11");
    customer.setCustSource("213");


    //保存
    entityManager.persist(customer);


    //  5.提交事务(回滚事务)
    tx.commit();
    //  6.释放资源(与开启顺序相反)
    entityManager.close();
    factory.close();


}

输出

log4j:WARN No appenders could be found for logger (org.jboss.logging).
log4j:WARN Please initialize the log4j system properly.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
Hibernate: drop table if exists cst_customer
Hibernate: create table cst_customer (cust_id bigint not null auto_increment, cust_address varchar(255), cust_industry varchar(255), cust_level varchar(255), cust_name varchar(255), cust_phone varchar(255), cust_source varchar(255), primary key (cust_id)) engine=InnoDB
Hibernate: insert into cst_customer (cust_address, cust_industry, cust_level, cust_name, cust_phone, cust_source) values (?, ?, ?, ?, ?, ?)

hibernate主键生成策略

public enum GenerationType {
    TABLE,    //jpa提供的一种机制,通过一张数据库表的形式帮助我们完成主键自增
    SEQUENCE,    //序列,oracle,底层数据库必须支持序列
    IDENTITY,    //自增,mysql
    AUTO;        //由程序自动的帮助我们选择主键生成策略

    private GenerationType() {
    }
}

hibernate的基本操作

* hibernate的操作步骤: * 1.加载配置文件创建工厂对象(实体管理类工厂)对象

EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
Persistence的静态方法createEntityManagerFactory(持久化单元名称)

持久化单元名称:

* 2.通过实体管理类工厂获取实体管理器

EntityManager entityManager = factory.createEntityManager();
createEntityManager:
    内部维护了数据库信息
    维护了缓存信息
    维护了所有的实体管理器对象
    在创建EntityManagerFactory的过程中会根据配置创建数据库表
EntityManagerFactory的创建过程比较浪费资源
特点:线程安全的对象
    多个线程访问同一个EntityManagerFactory不会有线程安全问题
如何解决EntityManagerFactory的创建过程浪费资源(耗时)的问题
思路:创建一个公共的EntityManagerFactory对象
    静态代码块的形式创建EntityManagerFactory

* 3.获取事务对象,开启事务

EntityTransaction tx = entityManager.getTransaction(); //获取事务对象
tx.begin(); //开启事务

EntityManager对象:实体类管理器
    beginTransaction:创建事务对象
    persist:保存 
    merge:更新
    remove:删除
    find/getReference:根据id查询

EntityTransaction对象:事务
    begin:开启事务
    commit:提交事务
    rollback:回滚

* 4.完成增删改查操作

1.添加案例persist

public class JpaTest {
    /**
     * 测试jpa的保存
     *      案例:保存一个客户到数据库中
     * Jpa的操作步骤:
     *      1.加载配置文件创建工厂对象(实体管理类工厂)对象
     *      2.通过实体管理类工厂获取实体管理器
     *      3.获取事务对象,开启事务
     *      4.完成增删改查操作
     *      5.提交事务(回滚事务)
     *      6.释放资源
     */


    @Test
    public void testSave(){
        //  1.加载配置文件创建工厂对象(实体管理类工厂)对象
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
        //  2.通过实体管理类工厂获取实体管理器
        EntityManager entityManager = factory.createEntityManager();
        //  3.获取事务对象,开启事务
        EntityTransaction tx = entityManager.getTransaction(); //获取事务对象
        tx.begin(); //开启事务

        //  4.完成增删改查操作
        Customer customer = new Customer();
        customer.setCustName("gg");
        customer.setCustAddress("11");
        customer.setCustSource("213");

        //保存
        entityManager.persist(customer);

        //  5.提交事务(回滚事务)
        tx.commit();


        //  6.释放资源(与开启顺序相反)
        entityManager.close();
        factory.close();


    }

    @Test
    public void test1(){
        EntityManager entityManager = JpaUtils.getEntityManager();
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        Customer customer = new Customer();
        customer.setCustName("gg3");
        customer.setCustAddress("11");
        customer.setCustSource("8989");
        entityManager.merge(customer);
        transaction.commit();
    }


    @Test
    public void test2(){
        EntityManager entityManager = JpaUtils.getEntityManager();
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();

        /**
         * find:根据id查询数据
         *      class:查询数据的结果需要包装的实体类类型和字节码
         *      id:查询的主键的取值
         */
        Customer customer = entityManager.find(Customer.class, 2L);
        System.out.println(customer);


        transaction.commit();
        entityManager.close();
    }


    @Test
    public void test3(){
        EntityManager entityManager = JpaUtils.getEntityManager();
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        
        Customer customer = entityManager.getReference(Customer.class, 2L);
        System.out.println(customer);


        transaction.commit();
        entityManager.close();
    }

}

2.查询案例 find与的getReference区别

/**
* 根据id查询客户
*     使用find方法查询:
*          1.查询的对象就是当前客户对象本身
*          2.在调用find方法的时候,就会发送sql语句查询数据库
*     * 立即加载
*/

============================================================

/**
* 根据id查询客户
*      getReference方法
*          1.获取的对象是一个动态代理对象
*          2.调用getReference方法不会立即发送sql语句查询数据库
*              * 当调用查询结果对象的时候,才会发送查询的sql语句,
*              * 什么时候用,什么时候发送sql语句查询数据库
*  延迟加载(懒加载)
*      * 得到的是一个动态代理对象
*      * 什么时候使用才会查询
*/

3.删除案例remove

@Test
public void testDelete(){
    EntityManager entityManager = JpaUtils.getEntityManager();
    EntityTransaction transaction = entityManager.getTransaction();
    transaction.begin();

    Customer customer = entityManager.find(Customer.class, 4L);
    entityManager.remove(customer);

    transaction.commit();
}

4.修改merge

//更新merge
@Test
public void testUpdate(){
    EntityManager entityManager = JpaUtils.getEntityManager();
    EntityTransaction transaction = entityManager.getTransaction();
    transaction.begin();


    Customer customer = entityManager.find(Customer.class, 3L);


    customer.setCustAddress("001");
    customer.setCustName("可可");
    customer.setCustIndustry("乱码");


    entityManager.merge(customer);


    transaction.commit();
}

5.查询全部

/**
     * 查询全部
     *      jpql:
     *      sql:select * from com.gg.domain.Customer
     */
    @Test
    public void TestFindAll(){
        // 1.获取entityManager
        EntityManager entityManager = JpaUtils.getEntityManager();
        // 2.开启事务
        EntityTransaction tx = entityManager.getTransaction();
        tx.begin();


        // 3.查询全部
//        String jpql = "from com.gg.domain.Customer";
        String jpql = "from Customer";
        // 创建Query查询对象,query对象才是执行jpql对象
        Query query = entityManager.createQuery(jpql);
        //发送查询,并封装结果集
        List list = query.getResultList();


        for (Object obj : list) {
            System.out.println(obj);
        }


        // 4.提交事务
        tx.commit();
        // 5.释放资源
        entityManager.close();
    }

6.倒序查询

/**
*  排序查询:倒序查询全部客户(根据id倒序)
*      sql:select * from cst_customer order by cust_id desc
*      jpql: from Customer order by custId desc
*/
@Test
public void TestFindAllOrder(){
    // 1.获取entityManager
    EntityManager entityManager = JpaUtils.getEntityManager();
    // 2.开启事务
    EntityTransaction tx = entityManager.getTransaction();
    tx.begin();


    // 3.查询全部
    String jpql = "from Customer order by custId desc";
    // 创建Query查询对象,query对象才是执行jpql对象
    Query query = entityManager.createQuery(jpql);
    //发送查询,并封装结果集
    List list = query.getResultList();


    for (Object obj : list) {
        System.out.println(obj);
    }


    // 4.提交事务
    tx.commit();
    // 5.释放资源
    entityManager.close();
}

7.查询记录数

/**
*  sql: select COUNT(cust_id) From cst_customer
*  jpql: select COUNT(cust_id) From cst_customer
*/
@Test
public void TestCount(){
    // 1.获取entityManager
    EntityManager entityManager = JpaUtils.getEntityManager();
    // 2.开启事务
    EntityTransaction tx = entityManager.getTransaction();
    tx.begin();

    // 3.查询全部
    String jpql = "select COUNT(custId) From Customer";
    // 创建Query查询对象,query对象才是执行jpql对象
    Query query = entityManager.createQuery(jpql);
    //发送查询,并封装结果集
    Object singleResult = query.getSingleResult();
    System.out.println(singleResult);

    // 4.提交事务
    tx.commit();
    // 5.释放资源
    entityManager.close();


}

8.分页查询

/**
* 分页查询
*  sql: select * From cst_customer limit ?,?
*  jpql: From Customer
*/
@Test
public void TestLimit(){
    // 1.获取entityManager
    EntityManager entityManager = JpaUtils.getEntityManager();
    // 2.开启事务
    EntityTransaction tx = entityManager.getTransaction();
    tx.begin();


    // 3.查询全部
    String jpql = "From Customer";
    // 1-创建Query查询对象,query对象才是执行jpql对象
    Query query = entityManager.createQuery(jpql);
    // 2-对参数赋值


    // 起始索引
    query.setFirstResult(1);
    // 页大小
    query.setMaxResults(2);


    // 3-发送查询,并封装结果集
    List resultList = query.getResultList();

    for (Object o : resultList) {
        System.out.println(o);
    }
    // 4.提交事务
    tx.commit();
    // 5.释放资源
    entityManager.close();


}

9.条件查询方式1

/**
* 条件查询
* 查询以xxx开头的客户
*      sql: select * From cst_customer where cust_name like '%gg%'
*      jpql: From Customer where custName like '%gg%'
*/
@Test
public void TestLike(){
    // 1.获取entityManager
    EntityManager entityManager = JpaUtils.getEntityManager();
    // 2.开启事务
    EntityTransaction tx = entityManager.getTransaction();
    tx.begin();


    // 3.查询全部
    String jpql = "From Customer where custName like :cust_name ";    //jpql也支持占位符
    // 1-创建Query查询对象,query对象才是执行jpql对象
    Query query = entityManager.createQuery(jpql);
    // 2-对参数赋值


    // 第一个参数:占位符的索引位置(从0开始),第二个参数:取值
    query.setParameter("cust_name","可%");


    // 3-发送查询,并封装结果集
    List resultList = query.getResultList();


    for (Object o : resultList) {
        System.out.println(o);
    }
    // 4.提交事务
    tx.commit();
    // 5.释放资源
    entityManager.close();


}

10.条件查询方式2

@Test
public void TestLike1(){
    // 1.获取entityManager
    EntityManager entityManager = JpaUtils.getEntityManager();
    // 2.开启事务
    EntityTransaction tx = entityManager.getTransaction();
    tx.begin();


    // 3.查询全部
    String jpql = "From Customer where custName like ?1 ";    //jpql也支持占位符
    // 1-创建Query查询对象,query对象才是执行jpql对象
    Query query = entityManager.createQuery(jpql);
    // 2-对参数赋值


    // 第一个参数:占位符的索引位置(从0开始),第二个参数:取值
    query.setParameter(1,"可%");


    // 3-发送查询,并封装结果集
    List resultList = query.getResultList();


    for (Object o : resultList) {
        System.out.println(o);
    }
    // 4.提交事务
    tx.commit();
    // 5.释放资源
    entityManager.close();


}

ORM

hiberbate

相关

pyqt5-tools安装后 desinner.exe 报错 PyQt5 the application failed to start beca

SQLAlachemy ORM 初识

初试form表单提交信息

Jenkins performance插件生成性能测试报告【待完成】

C# Winform表格DataGridView自定义列（文本列、ComboBox列）

在winform的窗体上画图如何保证画的图像在切换界面或者最小化等操作时不会消失

【Python之路Day13】网络篇之MySQL、ORM框架

Gin中记录Gorm数据库表生成-查询使用

（八十）c#Winform自定义控件-分割线标签-HZHControls

c#Winform自定义控件-目录-HZHControls

（七十七）c#Winform自定义控件-采样控件-HZHControls

ORM（Object Relational Mapping）

标签