SpringDataJpa学习(一) orm思想和hibernate以及jpa的概述和jpa的基本操作

最新推荐文章于 2020-04-20 15:28:14 发布

爱喵的Hero

最新推荐文章于 2020-04-20 15:28:14 发布

阅读量232

点赞数 1

分类专栏： Spring Data Jpa Java 文章标签： java 数据库

本文链接：https://blog.csdn.net/weixin_40982607/article/details/104681652

版权

Java 同时被 2 个专栏收录

8 篇文章 0 订阅

订阅专栏

Spring Data Jpa

7 篇文章 0 订阅

订阅专栏

第一 ORM思想
传统的jdbc对数据库的操作

主要目的：操作实体类就相当于操作数据库表。

建立两个映射关系：
```
 实体类和表的映射关系
 实体类中属性和表中字段的关系
```
好处：不再重点关注sql语句。

实现了ORM思想的框架：mybatis,hibernate
第二 hibernate框架介绍

概述：
Hibernate是一个开放源代码的对象关系映射框架。它对jdbc进行了非常轻量级的对象封装，它将POJO与数据表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成sql语句，自动执行，使得java程序员可以随心所欲的使用对象编程思维来操作数据库
第三 JPA规范

JPA概述：
JPA全称是Java Persistence API,即Java持久化API，是SUN公司推出的一套基于ORM的规范，内部是由一系列的接口和抽象类构成。

Java EE 5.0 平台标准的 ORM 规范，使得应用程序以统一的方式访问持久层

JPA（Java持久化API）是一种Java应用程序接口规范，描述java应用中关系数据的管理，充当面向对象的领域模型和关系数据库系统之间的桥梁。

Application code —> JPA ---->实现JPA规范的框架（比如hibernate、spring data jpa） ----> 数据库

graph LR

A[Application code] --> |jpa规范| B(hibernate)
B -->|jdbc| C(mysql数据库)

第四 JPA的基本操作
案例：对客户的相关操作（增删查改）
```
 客户：就是一家公司
 客户表：cst_customer
```
i:环境搭建
1.创建maven工程导入坐标

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.ysk</groupId>
    <artifactId>jap-day1</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-entitymanager -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>5.4.4.Final</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-c3p0 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
            <version>5.4.5.Final</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/log4j/log4j -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

    </dependencies>

</project>

2.需要配置jpa的核心配置文件
*配置到类路径下的一个叫做 META-INF 的文件夹下
*命令要求：persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
    <!--解决报错，需要配置persistence-unit节点
        持久化单元
        name 持久化单元名称
        transaction-type 事务管理方式
            JPA:分布式事务管理
            RESOURCE_LOCAL:本地事务管理
    -->
    <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
    <!-- jpa的实现方式 -->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>

    <!-- 可选配置：配置jpa实现方的配置信息 -->
        <properties>
            <!-- 数据库信息
             用户名，javax.persistence.jdbc.user
             密码，javax.persistence.jdbc.password
             驱动，javax.persistence.jdbc.driver
             数据库地址 javax.persistence.jdbc.url
             -->
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="123456"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql:///mytest"/>

            <!--配置jpa实现方(hibernate)的配置信息
                显示sql   ：   hibernate.show_sql : false|true
                自动创建数据库表：hibernate.hbm2ddl.auto :
                                    create : 程序运行时创建数据表，如果有表，先删除再创建
                                    update : 程序运行时创建表，如果有表，不会创建表
                                    none   : 不会创建表
            -->
            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.hbm2ddl.auto" value="create"/>
        </properties>

    </persistence-unit>
</persistence>

3.编写客户的实体
4.配置实体类和表，类中属性和表中字段的映射关系

package cn.ysk.domain;

import javax.persistence.*;

/**
 * 客户实体类
 *      配置映射关系
 *          1.实体类和表的映射关系
 *              @Entity 声明实体类
 *              @Table  配置实体类和表的映射关系
 *                  name：配置数据库表的名称
 *           2.实体类中属性和表中字段的映射关系
 *              @Id 声明主键的配置
 *              @GeneratedValue 配置主键的生成策略
 *                  GenerationType.IDENTITY 自增
 *              @Column 配置属性和字段的映射关系
 *                  name 数据库表中字段的名称
 *
 *
 * @Author ysk
 * @Date 2020/3/5 21:21
 * @Version 1.0
 */

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

    @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_level")
    private String custLevel;
    @Column(name = "cust_industry")
    private String custIndustry;
    @Column(name = "cust_phone")
    private String custPhone;
    @Column(name = "cust_address")
    private String custAddress;

    public Customer() {
    }

    public Long getCustId() {
        return custId;
    }

    public void setCustId(Long custId) {
        this.custId = custId;
    }

    public String getCustName() {
        return custName;
    }

    public void setCustName(String custName) {
        this.custName = custName;
    }

    public String getCustSource() {
        return custSource;
    }

    public void setCustSource(String custSource) {
        this.custSource = custSource;
    }

    public String getCustLevel() {
        return custLevel;
    }

    public void setCustLevel(String custLevel) {
        this.custLevel = custLevel;
    }

    public String getCustIndustry() {
        return custIndustry;
    }

    public void setCustIndustry(String custIndustry) {
        this.custIndustry = custIndustry;
    }

    public String getCustPhone() {
        return custPhone;
    }

    public void setCustPhone(String custPhone) {
        this.custPhone = custPhone;
    }

    public String getCustAddress() {
        return custAddress;
    }

    public void setCustAddress(String custAddress) {
        this.custAddress = custAddress;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "custId=" + custId +
                ", custName='" + custName + '\'' +
                ", custSource='" + custSource + '\'' +
                ", custLevel='" + custLevel + '\'' +
                ", custIndustry='" + custIndustry + '\'' +
                ", custPhone='" + custPhone + '\'' +
                ", custAddress='" + custAddress + '\'' +
                '}';
    }
}

5.完成第一个操作，保存客户数据到数据库中

/**
 * Jpa的操作步骤
 *  1.加载配置文件创建工厂对象（实体管理类工厂）
 *      Persistence:静态方法（根据持久化单元名称创建实体管理器工厂）
 *          createEntityManagerFactory(”持久化单元名称“)
 *  2.通过实体管理类工厂获取实体管理器
 *      createEntityManager : 获取EntityManager对象
 *      方法:createEntityManager
 *      * 内部维护了很多的内容
 *          维护了数据库信息
 *          维护了缓存信息
 *          维护了所有实体管理器对象
 *          再创建EntityManagerFactory的过程中会根据配置创建数据库表
 *      * EntityManagerFactory的创建过程比较浪费资源
 *      特点：线程安全的对象
 *          释：多个线程访问一个EntityManagerFactory不会有线程安全问题
*          * 如何解决EntityManagerFactory的创建过程浪费资源（耗时）的问题？
 *          思路：创建一个公共的EntityManagerFactory的对象
 *          * 静态代码块的形式创建EntityManagerFactory
 *
 *  3.获取事务对象，开启事务
 *      EntityManager对象：实体类管理器
 *          beginTransaction : 创建事务对象
 *          persist : 保存
 *          merge : 更新
 *          remove : 删除
 *          find/getRefrence : 根据id查询
 *      Transaction 对象 :事务
 *          begin:开启事务
 *          commit:提交事务
 *          rollback:回滚
 *  4.完成增城改查操作
 *      对的
 *  5.提交事务（抛出异常时，回滚事务）
 *  6.释放资源
 */

package cn.ysk.test;

import cn.ysk.domain.Customer;
import org.junit.Test;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;

/**
 * @Author ysk
 * @Date 2020/3/5 21:40
 * @Version 1.0
 */

public class JpaTest {

    /**
     * 测试jpa的保存
     *      案例：保存一个客户到数据表中
     * Jpa的操作步骤
     *  1.加载配置文件创建工厂对象（实体管理类工厂）
     *  2.通过实体管理类工厂获取实体管理器
     *  3.获取事务对象，开启事务
     *  4.完成增城改查操作
     *  5.提交事务（抛出异常时，回滚事务）
     *  6.释放资源
     */
    @Test
    public void testSave(){
        //1.加载配置文件创建工厂对象（实体管理类工厂）
        EntityManagerFactory factory =  Persistence.createEntityManagerFactory("myJpa");

        //2.通过实体管理类工厂获取实体管理器
        EntityManager em = factory.createEntityManager();

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

        //4.完成增城改查操作,保存一个客户到数据库中
        Customer customer = new Customer();
        customer.setCustName("ysk");
        customer.setCustIndustry("IT");

        //保存
        em.persist(customer); //保存操作

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

        //6.释放资源
        em.close();
        factory.close();

    }
}

爱喵的Hero

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringDataJpa学习(一) orm思想和hibernate以及jpa的概述和jpa的基本操作

第一 ORM思想传统的jdbc对数据库的操作主要目的：操作实体类就相当于操作数据库表。建立两个映射关系：实体类和表的映射关系实体类中属性和表中字段的关系好处：不再重点关注sql语句。实现了ORM思想的框架：mybatis,hibernate第二 hibernate框架介绍概述：Hibernate是一个开放源代码的对象关系映射框架。它对jdbc进行了非常轻量级的对象...
复制链接

扫一扫

专栏目录