JPA 基本使用

Posted 2020-11-10 遇事不决，可问神奇海螺

依赖配置

        <!-- 集成c3p0连接池到Hibernate ORM -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
            <version>5.4.2.Final</version>
        </dependency>

        <!-- hibernate对jpa的支持包 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>5.0.7.Final</version>
        </dependency>

        <!-- mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>

JPA核心配置文件

1. 位置：META-INF 的文件夹下（resources目录下）
2. 命名：persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">  <!-- 导入约束 -->

    <!-- transaction-type:
        JPA:分布式事务管理
        RESOURCE_LOCAL：本地事务管理 -->
    <persistence-unit name="myjpa" transaction-type="RESOURCE_LOCAL">
        <!--jpa实现-->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <!--数据库信息-->
        <properties>
            <property name="javax.persistence.jdbc.user" value="root"></property>
            <property name="javax.persistence.jdbc.password" value="root"></property>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"></property>
            <property name="javax.persistence.jdbc.url"
                      value="jdbc:mysql://localhost:3306/littledonkey?serverTimezone=GMT%2B8&useSSL=false"></property>
                      
            <!--jpa实现方的配置-->
            <!--显示sql，打印到控制台-->
            <property name="hibernate.show_sql" value="true"></property>
            <!--自动创建数据库表-->
            <!--配置jpa实现方(hibernate)的配置信息
                显示sql              ：   false|true
                自动创建数据库表      ：  hibernate.hbm2ddl.auto
                    create      : 程序运行时创建数据库表（如果有表，先删除表再创建）
                    update      ：程序运行时创建表（如果有表，不会创建表）
                    none        ：不会创建表-->
            <property name="hibernate.hbm2ddl.auto" value="update"></property>
        </properties>
    </persistence-unit>
</persistence>

实体类对象（配置对象和表的映射关系）

/**
 * 老板
 */
@Entity
@Table(name = "boss")   //对应表名
public class Boss {

    /**
     * @Id：声明主键的配置
     * @GeneratedValue:配置主键的生成策略 strategy
     *      GenerationType.IDENTITY ：自增（底层数据库需支持自动增长，对id自增）
     *
     *      JPA提供的四种标准用法为TABLE,SEQUENCE,IDENTITY,AUTO.?
     *          TABLE：jpa提供的一种机制，通过一张数据库表的形式帮助我们完成主键自增。?
     *          SEQUENCE：根据底层数据库的序列来生成主键，条件是数据库支持序列。?（oracle）
     *          IDENTITY：主键由数据库自动生成（主要是自动增长型）?（mysql）
     *          AUTO：由程序自动的帮助我们选择主键生成策略。
     *
     * @Column:配置属性和字段的映射关系 
     *      name：数据库表中字段的名称
     */

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "boss_id")
    private Long bossId;
    @Column(name = "boss_name")
    private String bossName;

    /**
     * 配置外键（外键引用的那个列在主表中必须是主键列或者唯一列。外键设在‘多’的一方）
     * 
     * 使用注解的形式配置多表关系
     *            1.声明关系
     *                @OneToMany : 配置一对多关系
     *                    targetEntity ：对方对象的字节码对象
     *            2.配置外键
     *                @JoinColumn : 配置外键
     *                    name：从表（多的一方）外键字段名称（不设置name的值，则在默认情况下，name=从表名称+“_”+从表主键的字段名）
     *                    referencedColumnName：主表的主键字段名称
     *                    unique：是否唯一。默认值不唯一
     *                    nullable：是否允许为空。默认值允许。
     *                    insertable：是否允许插入。默认值允许。
     *                    updatable：是否允许更新。默认值允许。
     *                    columnDefinition：列的定义信息。
     *
     * 在一的一方添加了外键了配置，所以对于boss而言，也具备了维护外键的作用
     *
     *
     * @OneToMany:
     *     作用：建立一对多的关系映射
     *     属性：
     *      targetEntityClass：指定多的多方的类的字节码
     *      mappedBy：指定从表实体类中引用主表对象的名称。
     *      cascade：指定要使用的级联操作
     *      fetch：指定是否采用延迟加载
     *              EAGER   ：立即加载
     *              LAZY    ：延迟加载
     *      orphanRemoval：是否使用孤儿删除
     *
     * @ManyToOne
     *     作用：建立多对一的关系
     *     属性：
     *      targetEntityClass：指定一的一方实体类字节码
     *      cascade：指定要使用的级联操作
     *      fetch：指定是否采用延迟加载
     *      optional：关联是否可选。如果设置为false，则必须始终存在非空关系。
     */
    //@OneToMany(targetEntity = Customer.class,cascade = CascadeType.ALL)
    //@JoinColumn(name = "cus_boss_id",referencedColumnName ="boss_id" )
    @OneToMany(mappedBy = "boss",cascade = CascadeType.ALL)     //放弃维护权
    private Set<Customer> customer=new HashSet<>();
}

/**
 * 顾客
 */
@Entity
@Table(name = "customer")
public class Customer {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "cus_id")
    private Long cusId;     //(主键)
    @Column(name = "cus_name")
    private String cusName;

    /**
     * 配置顾客到老板的多对一关系
     *     使用注解的形式配置多对一关系
     *      1.配置表关系
     *          @ManyToOne : 配置多对一关系
     *              targetEntity：对方的实体类字节码
     *      2.配置外键
     *
     * 配置外键的过程，配置到了多的一方，就会在多的一方维护外键
     *
     */
    @ManyToOne(targetEntity = Boss.class,fetch = FetchType.LAZY)
    @JoinColumn(name = "cus_boss_id",referencedColumnName = "boss_id")
    private Boss boss;
}

使用

    public void test() {

        /**
         * Persistence：用于加载配置文件，创建实体管理器工厂
         *
         * EntityManagerFactory：用于创建实体管理器（创建过程比较浪费资源）
         *      特点：线程安全的对象
         *      解决创建过程耗时问题：静态代码块创建公共对象 
         *
         * EntityManager：获取事务，以及持久化数据库的操作
         *
         * 方法说明：
         *  getTransaction : 获取事务对象
         *  persist ： 保存操作
         *  merge ： 更新操作
         *  remove ： 删除操作
         *  find/getReference ： 根据id查询
         */
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("myjpa");
        EntityManager entityManager = emf.createEntityManager();
        EntityTransaction et = entityManager.getTransaction();
        et.begin();
        Customer customer = new Customer();
        customer.setCustName("小红");
        customer.setCustAddress("北京");
        entityManager.persist(customer);
        et.commit();
        entityManager.close();
        emf.close();
    }

基本语法

    简单查询

    /**
     * find : 根据id查询数据
     *       class：查询数据的结果需要包装的实体类类型的字节码
     *       id：查询的主键的取值
     *       entityManager.find(Customer.class, 1l)
     *
     *
     * getReference方法（延迟加载（懒加载））
     *        1.获取的对象是一个动态代理对象
     *        2.调用getReference方法不会立即发送sql语句查询数据库
     *          当调用查询结果对象的时候，才会发送查询的sql语句：什么时候用，什么时候发送sql语句查询数据库

     * 调用remove方法完成删除操作
     *         entityManager.remove(customer);
     *
     * 更新操作
     *         merge(customer);
     *
     */


    复杂查询（jpql：查询语句写实体类与实体类属性）（sql：写表与表的字段）

    /**查询全部
     *          创建query对象
     *          String jpql = "from Customer";
     *          Query query = em.createQuery(jpql);
     *          查询并得到返回结果，得到集合返回类型
     *          List list = query.getResultList();
     *
     * 分页查询
     *          创建query对象
     *          String jpql = "from Customer";
     *          Query query = em.createQuery(jpql);
     *          //起始索引
     *          query.setFirstResult(0);
     *          //每页显示条数
     *          query.setMaxResults(2);
     *          //查询并得到返回结果，得到集合返回类型
     *          List list = query.getResultList();
     *
     * 条件查询
     *          创建query对象
     *          String jpql = "from Customer where custName like ? ";
     *          Query query = em.createQuery(jpql);
     *          //对占位符赋值，从1开始
     *          query.setParameter(1, "传智播客%");   //已传智播客开头
     *          //查询并得到返回结果
     *          Object object = query.getSingleResult();
     *
     * 排序查询： 倒序查询全部客户（根据id倒序）
     *          sql：SELECT * FROM customer ORDER BY cust_id DESC
     *          jpql：from Customer order by custId desc
     *
     * 统计查询
     *          String jpql = "select count(custId) from Customer";
     *          Query query = em.createQuery(jpql);
     *          // 2.查询并得到返回结果
     *          Object count = query.getSingleResult();
     */