Spring Data JPA

龙梓琦

已于 2022-04-15 11:36:07 修改

阅读量930

点赞数

文章标签： java spring

于 2022-04-12 16:02:57 首次发布

本文链接：https://blog.csdn.net/qq_46000574/article/details/124007429

版权

构建内容

构建一个应用程序，该应用程序将POJO（普通旧Java对象）存储在基于内存的数据库中。

一.Spring Initializr 预初始化项目

手动初始化项目：

导航到https://start.spring.io.此服务提取应用程序所需的所有依赖项，并为您完成大部分设置。
选择 Gradle 或 Maven 以及您要使用的语言。本指南假定您选择了 Java。
单击依赖关系，然后选择 Spring Data JPA，然后选择 H2 数据库。
单击"生成"。

下载生成的 ZIP 文件，该文件是使用您的选择配置的 Web 应用程序的存档。

如果您的 IDE 具有 Spring Initializr 集成，则可以从 IDE 完成此过程。
您还可以从 Github 分叉项目，然后在 IDE 或其他编辑器中打开它。

二.定义简单实体

在此示例中，将存储对象，每个对象都注释为一个JPA实体。
以下清单显示了“客户”类

package com.example.accessingdatajpa;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity //代表它是一个JPA实体
public class Customer {
   

  @Id//将此属性用@Id标注，以便JPA其识别为对象的ID
  @GeneratedValue(strategy=GenerationType.AUTO)  //指示自动生成ID
  /*有三个属性，分别为id,firstName,lastName*/
  private Long id;
  private String firstName;
  private String lastName;

  /*两个构造函数*/
  //缺省构造函数只是为了JPA，不直接使用它
  protected Customer() {
   }
	//另一个构造函数，用于创建要保存到数据库的实例
  public Customer(String firstName, String lastName) {
   
    this.firstName = firstName;
    this.lastName = lastName;
  }

  @Override
  public String toString() {
   
    return String.format(
        "Customer[id=%d, firstName='%s', lastName='%s']",
        id, firstName, lastName);
  }

  public Long getId() {
   
    return id;
  }

  public String getFirstName() {
   
    return firstName;
  }

  public String getLastName() {
   
    return lastName;
  }
}

三.创建简单查询

Spring Data JPA专注于使用JPA在关系数据库中存储数据。
JPA最引人注目的功能时能够在运行时从存储库界面自动创建存储库实现。

eg:
创建一个与实体一起使用的存储库界面

package com.example.accessingdatajpa;

import java.util.List;

import org.springframework.data.repository.CrudRepository;

public interface CustomerRepository extends CrudRepository<Customer, Long> {
   //CustomerRepository扩展接口。
//<Customer, Long>:<实体的类型，使用的ID的参数类型> 
//extends CrudRepository<Customer, Long>作用：通过扩展，继承了几种用于处理持久性的方法，包括用于保存、删除和查找实体的方法。

  List<Customer> findByLastName(String lastName);//Spring Data JPA还允许通过声明其他查询方法来定义其他查询方法。

  Customer findById(long id);
}

四.实例：SpringBoot使用SpringDataJPA完成CRUD

1.构建项目
勾选web,Mysql,JPA组件

2.配置数据源以及JPA
我们修改application.properties文件配置为application.yml配置。.yml比.properties配置要更清晰更有层次感，可以很明了的看懂配置信息。
在resources目录下创建application.yml文件，并且配置DataSource以及JPA

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1.3306/exam?charaterEncoding=utf8
    username: root
    password: 123456

  jpa:
    database: mysql
    show-sql: true
    hibernate:
      naming_strategy: org.hibernate.cfg.ImprovedNamingStrategy

3.编写一个控制器
----UserController

package com.huangjuan.demo;


import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping(value = "/user")
public class UserController {
   
}

4.创建实体

根据数据库中的字段常见一个对应的StudentEntity来作为操作的对象。
注意：
@Table
当实体类与其映射的数据库表名不同名时，需要使用@Table标注说明，该标注与@Entity标注并列使用，置于实体类声明语句之前。
属性
name-----指明数据库的表名
name属性用于指定数据库表名称
若不指定则以实体类名称作为表名

catalog/schema------用于设置表所属的数据库目录或者模式，通常为数据库名
catalog属性用于指定数据库实例名，一般来说persistence.xml文件中必须指定数据库url，url中将包含数据库实例

uniqueConstraints-----用于设置约束条件，通常不需要设置。

@GenerateValue-----ID自增

@Column()-----字段名

代码：

package com.huangjuan.demo.pojo;

import javax.persistence.*;
import java.io.Serializable;

@Entity
@Table(name = "myemp")
public class Myemp implements Serializable {
   
    @Id
    @GeneratedValue
    @Column(name="id")
    private Long id;

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

    @Column(name = "sal")
    private Long sal;

    @Column(name = "job")
    private String job;
    

    public Long getId() {
   
        return id;
    }

    public void setId(Long id) {
   
        this.id = id;
    }

    public String getName() {
   
        return name;
    }

    public void setName(String name) {
   
        this.name = name;
    }

    public Long getSal() {
   
        return sal;
    }

    public void setSal(Long sal) {
   
        this.sal = sal;
    }

    public String getJob() {
   
        return job;
    }

    public void setJob(String job) {
   
        this.job = job;
    }
}

5.创建JPA
创建MyempJPA接口并且继承SpringDataJPA内的接口作为父类
UserJPA继承了JPARepository接口（SpringDataJPA提供的简单数据操作接口）、JpaSpecificationExecutor（SpringDataJPA提供的复杂查询接口）、Serializable（序列化接口）。

package com.huangjuan.demo.jpa;

import com.huangjuan.demo.pojo.Myemp;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

import java.io.Serializable;

public interface MyempJPA extends JpaRepository<Myemp,Long>, JpaSpecificationExecutor<Myemp>, Serializable {
   
}

SpringDataJPA内部使用了类代理的方式让继承了它接口的子接口都以spring管理的Bean的形式存在，也就是说我们可以直接使用@Autowired注解在spring管理bean使用。像以前调用Dao层一样，在service层调用。

eg:

@RestController
@RequestMapping(value = "/user")
public class MyempController {
   
    @Autowired
    private MyempJPA myempJPA;

    public List<Myemp> list(){
   
        return null;
    }
}

6.编写查询方法

创建一个查询员工列表的方法

package com.huangjuan.demo.controller;


import com.huangjuan.demo.jpa.MyempJPA;
import com.huangjuan.demo.pojo.Myemp;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@RequestMapping(value = "/user",method = RequestMethod.GET)
public class MyempController {
   
    @Autowired
    private MyempJPA myempJPA;

    public List<Myemp> list(){
   
       return myempJPA.findAll();
    }
}

其中myempJps.findAll()方法就是SpringDataJPA为我们提供的内置方法，它可以查询表内所有的数据，除了findAll还有很多有用的方法

编写添加方法—save()

  @RequestMapping(value = "/save",method = RequestMethod.GET)
    public Myemp save(Myemp emp){
   
        return myempJPA.save(emp);
    }

编写删除方法—delete()

 @RequestMapping(value = "/delete",method = RequestMethod.GET)
    public List<Myemp> delete(Long id){
   
        myempJPA.deleteById(id);
        return myempJPA.findAll();
    }

实验
访问用户列表路径：http://127.0.0.1:8080/myemp/list
添加一条用户信息到数据库，请求地址：http://127.0.0.1:8080/myemp/save?name=admin&sal=9000&job=“项目经理”
删除数据库数据，127.0.0.1:8080/myemp/delete?id=1

五.Spring Data JPA使用@Query与@Modifying注解自定义修改和删除操作

JPQL是面向对象进行查询的语言，还可以通过自定义的JPQL完成
内容

六.系统学习JPA

（1)SpringDataJPA搭建xml的配置方式

我们使用自行配置项目环境，不使用SpringBoot初始化（有利于熟悉SpringBoot的原码）
1.找到Spring Data JPA的依赖
版本兼容

兼容版本的最简单方法是依靠我们随定义的兼容版本一起提供的Spring Data Release Train BOM。Spring Data
Release Train BOM----统一版本管理，有效的避免版本冲突

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework.data</groupId>
      <artifactId>spring-data-bom</artifactId>
      <version>2021.1.3</version>
      <scope>import</scope>
      <type>pom</type>
    </dependency>
  </dependencies>
</dependencyManagement>

用标签：dependencyManagement 会继承 spring-data-bom 下面的所有依赖

声明springdatajpa的依赖

<dependencies>
  <dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-jpa</artifactId>
  </dependency>
<dependencies>

声明与hibernate相关的依赖

  <!--junit4测试单元的工具-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>

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

        <!--openjpa-->
        <dependency>
            <groupId>org.apache.openjpa</groupId>
            <artifactId>openjpa-all</artifactId>
            <version>3.2.0</version>
        </dependency>

        <!--Mysql and MariaDB-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.22</version>
        </dependency>

连接池

 		<!--连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.8</version>
        </dependency>

Spring Test

  <!--SpringTest-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.10</version>
            <scope>test</scope>
        </dependency>

2.持久化配置----【先使用xml，再用javaConfig(配置文件）】
persistence.xml（源头）

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

    <!--需要配置persistence-unit结点
        持久化单元：
            name:持久化单元名称(JPA的实现对象）
            transaction-type:事务管理的方式
                JTA:分布式事务管理
                RESOURCE_LOCAL：本地事务管理
    -->
    <persistence-unit name="hibernateJPA" transaction-type="RESOURCE_LOCAL">
        <!--JPA的实现方式-->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <!--需要进行ORM的POJO类-->
        <class>com.huangjuan.pojo.Student</class>

        <!--可选配置：配置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://127.0.0.1:3306/exam?characterEncoding=utf8"/>



            <!--配置jpa实现方(hibernate）的配置信息
                显示sql             :    false|true
                自动创建数据库表      :    hibernate.hbm2ddl.auto
                        create     :    程序运行时创建数据库表（如果有表，先删除后创建）
                        update     :    程序运行时创建表（如果有表，不会创建表）
                        none       :    不会创建表

            -->
            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.hbm2ddl.auto" value="update"/>
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5InnoDBDialect"/>
        </properties>
    </persistence-unit>
</persistence>

注意：ORM----对象映射关系

spring.xml配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    https://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/data/jpa
    https://www.springframework.org/schema/data/jpa/spring-jpa.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">


    <!--用于整合jpa
        @EnableJpaRepositories

        数据访问层包的位置：com.acme.repositories（base-package）

        指定
        entity-manager-factory-ref="entityManagetFactory"
        transaction-manager-ref="transactionManager"
    -->
    <jpa:repositories base-package="com.huangjuan.repositories"
                      entity-manager-factory-ref="entityManagetFactory"
                      transaction-manager-ref="transactionManager"
    />

    <!--配置EntityManagerFactory的bean
    bean
        name===方法名
        class===bean对应的类
    -->
    <bean name="entityManagetFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <!--配置持久化单元的内容-->
            <!--配置JPA的实现方式-->
            <property name="jpaVendorAdapter">
                <!--Hibernate实现
                    persistence.xml
                    <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
                -->
                <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                    <!--属性设置-->
                    <!--配置jpa实现方(hibernate）的配置信息
                        自动创建数据库表      :    hibernate.hbm2ddl.auto
                                ture     :    程序运行时创建表（如果有表，不会创建表）
                                false       :    不会创建表
                     -->
                    <property name="generateDdl" value="true"></property>
                    <!--数据库显示配置-->
                    <property name="showSql" value="true"></property>
                </bean>
            </property>

        <!--扫描实体类的包-->
        <property name="packagesToScan" value="com.huangjuan.pojo"></property>


        <!--数据源/连接池
        将配置指定上====>ref
        -->
        <property name="dataSource" ref="dataSource"></property

最低0.47元/天解锁文章

龙梓琦

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring Data JPA

构建内容构建一个应用程序，该应用程序将POJO（普通旧Java对象）存储在基于内存的数据库中。一.Spring Initializr 预初始化项目手动初始化项目：导航到https://start.spring.io.此服务提取应用程序所需的所有依赖项，并为您完成大部分设置。选择 Gradle 或 Maven 以及您要使用的语言。本指南假定您选择了 Java。单击依赖关系，然后选择 Spring Data JPA，然后选择 H2 数据库。单击"生成"。下载生成的 ZIP 文
复制链接

扫一扫