JPA框架初次见面

最新推荐文章于 2023-06-06 10:00:00 发布

snailisBigbull

最新推荐文章于 2023-06-06 10:00:00 发布

阅读量105

点赞数

分类专栏： Java JPA 文章标签： JPA hibernate 建表策略表单映射配置 persistence配置

本文链接：https://blog.csdn.net/snailisBigbull/article/details/97187747

版权

Java 同时被 2 个专栏收录

28 篇文章 0 订阅

订阅专栏

JPA

7 篇文章 0 订阅

订阅专栏

1.JPA的认识

1.1 什么是JPA(了解)

jpa：

(1)Java持久层API，jpa就是做持久层,操作数据库

(2)它是对象映射框架(ORM)的规范

ORM: 对象关系映射（Object Relational Mapping，简称ORM）

数据表库 t_employee

id	name
1	2

t_employee ---- 类对应上 Employee

字段id/name ----- 类里面的属性 id name

一行数据 ----- new Employee(1,‘豪豪’)；

对象(Domain类 Entity类对象)

1.2 为什么需要JPA

（1）以前使用jdbc，在对象和数据库数据之间转换特别麻烦

（2）他以面向对象的思维来操作数据，比如我操作一个java里面对象，就相当于操作数据库表数据

1.3 hibernate和JPA的关系(理解)

JPA：他是ORM的规范

Hibernate：它是ORM这个规范实现的框架

JPA是持久化规范，而Hibernate是其实现。

1.4 jdbc和jpa优缺点（理解）

jdbc：优缺点：

jdbc操作数据库底层技术

(1)转换的时候, 对象需要进行封装和拆分比较麻烦

(2)重复性代码比较多

（3）移植数据库比较麻烦

操作数据库的时候，如果使用jdbc，可能要写两套代码

(4)jdbc 自身没有缓存（Cache），如果性能上面需要控制的话，就需要写缓存代码

(5)jdbc不是面向对象的思维来操作的，它是面向sql操作，如果是sql高手，操作jdbc很爽的；

(6)比较简单比较直接，就可以操作数据库

JPA的：

(1)面向对象操作，操作对象就相当于操作数据比如 entityManager.perisit(employee)

(2) 移植数据比较方便，以后如果想换数据库，只需要换一个数据库方言就OK

(3)JPA有缓存，效率不错的 (一级缓存二级缓存查询缓存)

缺点:

(1)不能干预sql的生成，查询一个数据 find 默认查询所有字段 (select * from )

(2)有些优化 jpa做不了，比如特别大数据量的时候，jpa也不适合，mybatis也解决不了 (架构策略分库分表 (分布式))

(3)一个项目里面对sql要求比较高，就不适合jpa

JPA适用于中小型的项目

jpa小结

什么是JPA？java persistence api ，对象关系映射(ORM) 规范(持久化)
Hibernate和JPA的关系? JPA是规范,Hibernate是它的一个实现。
Hibernate是一个完整的对象关系映射框架 mybatis半自动ORM框架
什么是ORM? 对象关系映射
JDBC与JPA的优缺点？

JDBC操作更加底层，它的性能是完全可控的(前提:有控制它性能的能力)

JPA对JDBC的封装,快速开发，自身已经有了很好的性能优化,兼容各种数据库

缺点:不能干涉SQL生成，有些性能问题无法解决

3jpa的使用(掌握)

3.1导入依赖的jar包

3.2 persistence.xml的配置(掌握)

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

    <!--
        持久化单元名称
         name ：取一个单元的名称
        transaction-type：事务类型 本地数据库的事务
    -->
    <persistence-unit name="cn.itsource.jpa" transaction-type="RESOURCE_LOCAL">
        <properties>
            <!-- 必须配置4个连接数据库属性 -->
            <property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" />
            <property name="hibernate.connection.url" value="jdbc:mysql:///jpa" />
            <property name="hibernate.connection.username" value="root" />
            <property name="hibernate.connection.password" value="123456" />

            <!-- 必须配置1个方言属性 -->
            <!-- 实现跨数据库关键类 :查询MySQLDialect的getLimitString方法 -->
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect" />

            <!-- 可选配置 
          ddl数据定义语言(建库建表建约束)
          dml数据操作语言 (insert update delete)
          dql 数据查询语言(select)
          tcl 事务控制语言 (commit rollback)
              -->
            <!-- 是否自动生成表 -->
            <property name="hibernate.hbm2ddl.auto" value="create" />
            <!-- 是否显示sql -->
            <property name="hibernate.show_sql" value="true" />
            <!-- 格式化sql -->
            <!--<property name="hibernate.format_sql" value="true" />-->
        </properties>
    </persistence-unit>
</persistence>

3.3 使用JPA完成一个新增操作

1、new 一个pojo类，调用set方法赋值
2、获得entityManagerFactory实体管理工厂
3、获得entityManager实体管理器（对象）
4、获取事务，然后开启事务
5、持久化操作，persist(Object)
6、提交事务
7、关闭资源
持久化操作实现CRUD方法，添加：persist();
					 修改：merge()	;
					 删除：remove()；
                     查找：find()
                     查询所有：jpql语句
           ；
@Test
    public void testAdd() throws Exception{
        User user = new User();
        user.setName("覃璇璇");
        //实体管理工厂
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("cn.itsource.jpa");

        //通过工厂生成EntityManager(实体管理的对象)
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        //获取事务
        entityManager.getTransaction().begin();//开启事务
        entityManager.persist(user);
        entityManager.getTransaction().commit();//提交事务
        entityManager.close();
        entityManagerFactory.close();
    }

/**
	方法：   新增 persist
			修改 merge
			删除remove
			查询 find
			查询所有 jpql语句
			
/

查询所有： jpql语句

@Test
    public void testQueryAll() throws Exception{
        /*
        * 查询所有
        * jpql语句，类似于sql语句，JPA提供的查询数据的语言
        * 写法：sql：select * from t_user;
        *       jpql: select o from User o;  //o,为对象的别名
        * */
        //获得实体管理器
        EntityManager entityManager = JPAUtils.getEntityManager();
        //开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        String jpql = "select o from User o";
        Query query = entityManager.createQuery(jpql);
        List list = query.getResultList();

        //for增强快捷键iter
        for (Object o : list) {
            System.out.println(o);
        }
    }

3.4 建表策略（掌握）

	        建表自动生成表的策略，配置是persistence.xml时对以下策略进行选择
			
			<!-- 是否自动生成表 -->
            <property name="hibernate.hbm2ddl.auto" value="create" />
           	  
				create 创建策略，先删除 在创建
                update (测试)更新策略   不会删除  如果发现没有表，也会创建
                        如果是表里面新增的字段 ，配置都有效果
                         如果这个表里面已经存在该字段 去修改属性 没有效果 比如length
                create-drop 先删除 在创建 在删除  不怎么会用  面试会问
                            并且 把entityManagerFactory关闭
                        临时表 临时使用表 使用完之后，数据就不应该存在
                        
                        
                validate 验证策略 当前实体配置和数据库的配置进行对比验证
                            如果有对应实体，但是没有对应的数据库表 报错
                            数据库多字段 OK
                            数据库少字段 不OK
            使用场景：比如已知数据库的前提下 就可以把实体的配置和数据库的配置进行对比

3.5 JPA的API的认识

[外链图片转存失败(img-wj44wlQT-1563983994045)(E:\课程文件\2019-07-23-jpa01\doc\图片2.png)]

Persistence=>EntityManagerFactory-

3.5.1 EntityManagerFactory

EntityManagerFactory这个类他是重量级的，要与数据库建立联系。不要频繁创建和销毁，很销毁性能

怎么类应该怎么设计?

1:1:1 1个应用程序对应1个entityManagerFactory 对应1个数据库==>持久化单元Persistence Unit

这个类也应该设计成共享的。在设计成共享的时候，尽量线程安全(ThreadLocal --Map（threadid，object）)

1.数据库配置信息它里面有一个连接池(本身就重，创建与销毁太费时间)

2.有二级缓存(查询缓存,…) – 后面讲

3.预定义的JPQL语句(JPQL,SQL) – 后面讲

4.维护所有实体已经它们之间关系 --后面讲

3.5.2 EntityManager

EntityManager 它是实体管理的类，可以管理实体(crud),它是轻量级的类，可以频繁创建和销毁不会销毁太多的性能，他是线程不安全的，但是在设计，多个线程来访问的时候，尽量的保证线程是安全，如果没有线程安全，出现事务并发带来的问题；(脏读虚度(幻读) 不可重复读)

事务并发：多个事务同时操作同一个数据的时候

小屋 10000$ – 小房+10000$ – 转账事务

小业--- 操作数据事务 -- >是可以解决的   乐观锁 悲观锁

(1)管理实体(crud)

（2）EntityManager里面有一个一级缓存(掌握)

缓存：Cache 在内存里面开辟一块空间来临时存储数据

目的：提高查询的效率

缓存什么时候才能用上：(一级缓存命中之后就可以用来)

同一个EntityManagerFactory 同一个EntityManager 同一个OID(实体对象的ID --主键ID)

3.5.3 EntityTransaction(了解)

实体的事务对象

现在 EntityTransaction – 都是本地事务同一个库里面事务

JTA

不同库的事务：分布式事务解决方案 --redis

分布式事务：

不同服务同一个库 --属于分布式事务

不同服务不同库 --属于分布式事务

电商：订单模块（order库–tomcat1）–> 库存模块（store库-tomcat2）支付模块(pay-tomcat3) …

分布式：

比如转账

3.6 单表映射配置(掌握)

	@Entity
	@Table(name="t_employee")
	public class Employee {

    @Id
    @GeneratedValue
    private Long id; //要求：主键，使用数据库的自动生成策略

    @Column(length = 20,name = "username",unique=true,nullable=false)
    private String name;  //要求：varchar(20)，数据库名称为username,不能为空，唯一
    private String password;
    /**
     *  create table t_bb(
     *      id  int(20),
     *      name varchar(200),
     *      age int(20) default 25
     *  )
     *
     *  PK：primary key   主键
     *  UK ：unique key  唯一键
     *  FK ：foreign key  外键
     *
     */
    @Column(columnDefinition="int(20) default 25",insertable = false )
    private Integer age = 25; //要求：默认值是25，在插入数据时不允许覆盖(添加数据时不操作该字段)
    private Boolean sex;// 数据库没有布尔类型,bit对象

    @Column(columnDefinition ="decimal(19,2)")
    private BigDecimal salary;// 19,2

    @Column(updatable=false)
    @Temporal(TemporalType.TIMESTAMP)
    private Date createTime;//包含年月日时分秒，不允许修改 update

    @Temporal(TemporalType.DATE)
    private Date birthday;//包含年月日

    @Temporal(TemporalType.TIME)
    private Date time;//包含时分秒

    @Lob
    private String text;//这是一个大文本 longtext

    @Transient
    private String temp;//这一个字段不要同步到数据库
    }