精华内容
下载资源
问答
  • Spring Data JPA教程

    千次阅读 2020-06-05 03:05:39
    在Java类或对象与关系... 在本教程中,我们将讨论Spring数据的JPA实现。 1.简介 1.1什么是JPAJPA或Java Persistence API是Java规范,用于访问,管理和持久化Java类或对象与关系数据库之间的数据。 该规范是EJB...

    在Java类或对象与关系数据库之间管理数据是一项非常繁琐且棘手的任务。 DAO层通常包含许多样板代码,应简化这些样板代码,以减少代码行数并使代码可重复使用。

    在本教程中,我们将讨论Spring数据的JPA实现。

    1.简介

    1.1什么是JPA?

    JPA或Java Persistence API是Java规范,用于访问,管理和持久化Java类或对象与关系数据库之间的数据。 该规范是EJB 3.0的一部分。

    JPA不是实现或产品,它只是一个规范。 它包含需要实现的一组接口。 它是一个框架,为JPA实现提供了额外的抽象层。 存储库层将包含三层,如下所述。

    • Spring Data JPA:–提供Spring数据存储库接口,这些接口可用于创建JPA存储库。
    • Spring Data Commons:–它提供了在特定于数据存储的spring数据项目之间共享的基础结构。
    • 实现JPA持久性API的JPA提供程序。

    Spring数据JPA允许我们不添加任何存储库层来编写任何样板代码。

    1.2 JPA的历史

    JPA2.0:– JPA2.0的开发始于2007年,名称为JSR317。该版本被标记为2.0,因为无法获得1.0的共识。 重点是解决著名供应商ORM所提供的功能。

    JPA 2.1: -JPA2.1于2011年7月作为JSR 338开始。一些主要功能是实体图,存储过程,转换器等。

    JPA 2.2: -JPA2.2是2017年JPA系列的最新功能。它包括对Java 8日期和时间类型的支持以及流查询结果的功能。

    JPA仍在进行大量更改,我们可以期待不久的JPA的更新版本。

    1.3 Spring数据仓库

    Spring Data Commons项目提供了存储库抽象,该存储库抽象由特定于数据存储的子项目扩展。

    我们必须熟悉Spring Data仓库接口,因为它将帮助我们实现接口。 让我们看一下接口。

    Spring Data Commons:–作为该项目的一部分,提供了以下接口:

    Spring Data JPA:–该项目提供以下接口:

    存储库层次结构如下所示:

    Spring数据存储库层次结构

    让我们尝试通过一个示例程序来了解Spring Data JPA。

    1.4 Spring数据自定义查询

    让我们考虑一个用例,其中我们必须基于查询从数据库中获取数据。 编写自定义查询是非常有用的情况。 Spring Data JPA具有不同的编写自定义查询的方式。 我们将大致分类如下所述的方式。

    自动自定义查询:自动自定义查询的创建也称为从方法名称查询创建。 Spring Data JPA具有用于查询创建的内置机制,可用于直接从查询方法的方法名称解析查询。 该机制首先从方法名称中删除公共前缀,并从其余方法名称中解析查询的约束。 为了使用这种方法,我们必须确保通过合并实体对象的属性名称和支持的关键字来创建存储库接口的方法名称。

    使用这种方法的优点是它很容易实现。 但是限制是,如果查询包含多个参数,则方法名将不可读。 同样,JPA不支持的关键字(例如lower)也不适用于此方法。

    手动自定义查询:手动自定义查询也称为使用@Query标记创建查询。 @Query批注将用于使用JPA查询语言创建查询,并将这些查询直接绑定到存储库接口的方法。 调用查询方法时,Spring Data JPA将执行@Query注释指定的查询。

    这种方法的优点是您可以使用JPA查询语言来创建查询。 此外,查询仍位于存储库层。 这种方法的局限性是@Query只能在支持JPA查询语言时使用。

    下面提到的程序使用这两种方法。

    1.5 Spring Data JPA异常转换

    需要考虑的重点是因为默认的Spring ORM模板未与SPring JPA一起使用,是否通过使用Spring Data JPA丢失了异常转换?是否不将JPA异常转换为Spring的DataAccessException层次结构?

    答案是否定的 。 通过在DAO上使用@Repository批注,仍可以启用异常转换。 注释使Spring Bean后处理器可以为所有@Repository Bean提供在Container中找到的所有PersistenceExceptionTranslator实例的建议,并像以前一样提供异常转换。

    2.工具与技术

    让我们看看用于构建程序的技术和工具。

    • Eclipse Oxygen.2发布(4.7.2)
    • Java –版本9.0.4
    • Maven – 3.5.3
    • Spring启动– 2.0.1-发布
    • PostgreSQL – 10
    • 邮差

    3.项目结构

    我们的项目结构如下图所示。

    Spring Data JPA教程的项目结构

    上面的项目结构使用的是Maven。 也可以使用Gradle创建该项目,并且pom.xml将替换为build.gradle文件。 该项目的结构将稍微延迟使用Gradle进行构建。

    4.方案目标

    作为程序的一部分,我们将尝试使用spring boot创建一个简单的Web服务。 该Web服务将用于PostgreSQL数据库上的数据操作。

    4.1 pom.xml

    该程序的pom.xml文件如下所示。

    使用Spring Boot的SpringData JPA的pom.xml

    <?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>com.springjpa</groupId>
    	<artifactId>SpringJPA-PostgreSQL</artifactId>
    	<version>0.0.1</version>
    	<packaging>jar</packaging>
    
    	<name>SpringJPA-PostgreSQL</name>
    	<description>Demo project for Spring Boot JPA - PostgreSQL</description>
    
    	<parent>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-parent</artifactId>
    		<version>2.0.1.RELEASE</version>
    		<relativePath/> 
    	</parent>
    
    	<properties>
    		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    		<java.version>1.9</java.version>
    	</properties>
    
    	<dependencies>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-data-jpa</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-web</artifactId>
    		</dependency>
    
    		<dependency>
    			<groupId>org.postgresql</groupId>
    			<artifactId>postgresql</artifactId>
    			<scope>runtime</scope>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-test</artifactId>
    			<scope>test</scope>
    		</dependency>
    		<dependency>
      <groupId>javax.xml.bind</groupId>
      <artifactId>jaxb-api</artifactId>
      <version>2.3.0</version>
    </dependency>
    	</dependencies>
    
    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-maven-plugin</artifactId>
    			</plugin>
    		</plugins>
    	</build>
    	
    
    
    </project>

    pom.xml文件将包含程序需要的依赖项。

    4.2应用类别

    对我们来说,Application.java类是SpringJpaPostgreSqlApplication.java类。 该类如下所示。

    Spring Boot的SpringJpaPostgreSqlApplication.java类

    package com.tutorial;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.CommandLineRunner;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    import com.tutorial.repo.EmployeeRepository;
    
    @SpringBootApplication
    public class SpringJpaPostgreSqlApplication implements CommandLineRunner{
    
    	@Autowired
    	EmployeeRepository repository;
    	
    	public static void main(String[] args){
    		SpringApplication.run(SpringJpaPostgreSqlApplication.class, args);
    	}
    
    	public void run(String... args) throws Exception {
    		// TODO Auto-generated method stub
    		
    	}
    
    }

    CommandLineRunner接口用于指示当bean包含在Spring Application中时应运行。

    4.3模型类别

    我们将创建一个Employee.java类作为模型类。 该类如下所示。

    程序的模型类

    package com.tutorial.model;
    
    import java.io.Serializable;
    
    import javax.persistence.Column;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.Table;
    
    @Entity
    @Table(name = "employee")
    public class Employee implements Serializable {
    
    	private static final long serialVersionUID = -3009157732242241606L;
    	@Id
    	@GeneratedValue(strategy = GenerationType.AUTO)
    	@Column(name="id")
    	private long id;
    
    	@Column(name = "firstname")
    	private String firstName;
    
    	@Column(name = "lastname")
    	private String lastName;
    	
    	@Column(name = "age")
    	private int age;
    
    	protected Employee() {
    	}
    
    	public Employee(String firstName, String lastName,int age) {
    		this.firstName = firstName;
    		this.lastName = lastName;
    		this.age = age;
    	}
    
    	@Override
    	public String toString() {
    		return String.format("Employee[id=%d, firstName='%s', lastName='%s', age='%d']", id, firstName, lastName,age);
    	}
    
    	
    	public long getId() {
    		return id;
    	}
    
    	public void setId(long id) {
    		this.id = id;
    	}
    
    	public String getFirstName() {
    		return firstName;
    	}
    
    	public void setFirstName(String firstName) {
    		this.firstName = firstName;
    	}
    
    	public String getLastName() {
    		return lastName;
    	}
    
    	public void setLast_Name(String lastName) {
    		this.lastName = lastName;
    	}
    
    	public int getAge() {
    		return age;
    	}
    
    	public void setAge(int age) {
    		this.age = age;
    	}
    }

    @Entity :用于定义该类为Entity类。
    @Table :此批注用于指定数据库中定义的表名。
    @Id :Id注释用于指定Id属性 @GeneratedValue :当我们要设置自动生成的值时使用。 GenerationType是用于生成特定列的值的机制。 @Column :此批注用于将表中的列与类中的属性进行映射。

    4.4储存库接口

    存储库接口用于扩展CRUD接口。 该接口在程序中添加了存储库层。 Spring Data JPA提供了两种创建查询的主要方法。 然后,在存储库界面中使用这些查询来从数据库中获取数据。

    用于扩展CRUD存储库的存储库类

    package com.tutorial.repo;
    
    import java.util.List;
    
    import org.springframework.data.jpa.repository.Query;
    import org.springframework.data.repository.CrudRepository;
    import org.springframework.data.repository.query.Param;
    import org.springframework.stereotype.Repository;
    
    import com.tutorial.model.Employee;
    
    @Repository
    public interface EmployeeRepository extends CrudRepository<Employee, Long>{
    	List findByLastName(String lastName);
    	
    @Query("SELECT e FROM Employee e WHERE e.age = :age")
        public List findByAge(@Param("age") int age);
    }

    CrudRepositoryCrudRepository Common项目的接口。 上面提到的两种用于查询创建的方法在代码的以下位置使用。

    自动自定义查询:

    List findByLastName(String lastName);

    方法findByLastName包含姓氏作为参数,将用于数据搜索。 另外,将使用JPA查询构建器自动创建查询。

    手动自定义查询:

    @Query("SELECT e FROM Employee e WHERE e.age = :age")
        public List findByAge(@Param("age") int age);

    在此方法中,我们手动定义了一个查询以根据年龄取数据,然后将查询与findByAge方法绑定。

    4.5属性文件

    作为用于连接数据库的Spring Boot的一部分,我们将在属性文件中提供详细信息。 属性文件如下所示。

    Spring启动的application.properties文件

    spring.datasource.url=jdbc:postgresql://localhost:5432/postgres
    spring.datasource.username=postgres
    spring.datasource.password=password
    spring.jpa.generate-ddl=true
    spring.jpa.show-sql=true
    spring.jpa.properties.hibernate.format_sql=true

    作为属性文件的一部分,提供了数据库URL和凭据。 属性spring.jpa.show-sql=true显示JPA进行数据操作期间生成的SQL查询。

    4.6控制器等级

    控制器是整个程序中最重要的一类。 这是负责所有url映射的类。 我们在此类本身中添加了用于数据操作的存储库方法。

    程序的控制器类

    package com.tutorial.controller;
    
    import java.util.List;
    import java.util.Optional;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.http.HttpStatus;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    
    import com.tutorial.model.Employee;
    import com.tutorial.repo.EmployeeRepository;
    
    @RestController
    @RequestMapping("/employee")
    public class WebController {
    	@Autowired
    	EmployeeRepository repository;
    	
    	@RequestMapping(value="/save",method = RequestMethod.POST)
    	public HttpStatus insertEmployee(@RequestBody Employee employee){
    		boolean status = repository.save(employee) != null;		
    		return status? HttpStatus.CREATED : HttpStatus.BAD_REQUEST;
    	}
    	
    	
    	@RequestMapping("/findall")
    	public List findAll(){
    		
    		
    		return (List) repository.findAll();
    	}
    	
    	@RequestMapping("/findbyid")
    	public Optional findById(@RequestParam("id") long id){
    		Optional result = repository.findById(id);
    		return result;
    	}
    	
    	@RequestMapping("/findbylastname")
    	public List fetchDataByLastName(@RequestParam("lastname") String lastName){
    		 		
    		return repository.findByLastName(lastName);
    	}
    	@RequestMapping("/findbyage")
    	public List fetchDataByAge(@RequestParam("age") int age){
    		 		
    		return repository.findByAge(age);
    	}
    }

    @RestController标记用于将类定义为rest控制器类。
    @RequestMapping标记指定请求的路径映射。 值属性指定URL映射,方法属性指定它的方法类型,例如GET,POST,PUT等。 如果默认情况下不指定method属性,则该方法被视为GET方法。

    在此类中,我们自动连接了存储库,并使用界面中可用的方法进行数据检索,插入和删除。

    为了运行spring boot应用程序,我们必须提供命令spring-boot: run

    5.输出

    下面提到的查询可用于在PostgreSQL中创建Employee表。

    用于查询Employee表的SQL查询

    create table employee (
    id serial not null primary key,
    firstName varchar(20) not null,
    lastName varchar(20) not null,
    age integer not null
    );

    让我们检查数据库中可用的数据。 数据库中的当前可用数据如下所示。

    PostgreSQL中的数据

    现在,让我们尝试使用postman集合来查找findall API,以获取结果行。 结果将如下所示在邮递员上。

    Findall API在邮递员上的结果

    为了在数据库中添加一些雇员对象。 我们将使用save API并将传递一个employee对象。

    使用保存API将对象存储在DB中

    让我们检查数据库中保存API的用法。 该数据库将如下所示。

    使用Save API保存数据后

    同样,我们可以使用findbylastname API来查找具有request参数中提供的姓氏的记录。

    findbylastname API的结果

    让我们看看绑定到手动自定义查询的方法的结果。

    findByAge API的结果

    6.总结

    本教程的摘要在下面提到。

    1. SpringData JPA提供了用于JPA持久性API的存储库抽象。
    2. 我们了解了CRUD存储库的用法。
    3. 我们使用自动自定义查询来基于姓氏搜索行。
    4. 我们了解了手动定制查询的创建。
    5. JPA异常翻译取决于@Repository标记。

    7.下载Eclipse项目

    这是使用SpringBoot的SpringData JPA教程。

    您可以在此处下载此示例的完整源代码: SpringJPA-PostgreSQL.zip

    翻译自: https://www.javacodegeeks.com/2018/05/spring-data-jpa-tutorial.html

    展开全文
  • spring data jpa 教程

    2013-12-23 13:17:41
    第一章:Spring Data JPA入门 包括:是什么、能干什么、有什么、HelloWorld等 第二章:JpaRepository基本功能 包括:代码示例JpaRepository提供的CRUD功能,还有翻页、排序等功能 第三章:JpaRepository的查询 ...
  • 创建使用Java Persistence API的存储... 如果您想了解更多有关Spring Data JPA的信息,请阅读我的Spring Data JPA教程 。 翻译自: https://www.javacodegeeks.com/2014/12/spring-data-jpa-tutorial-introduction.html

    创建使用Java Persistence API的存储库是一个繁琐的过程,需要大量时间,并且需要大量样板代码。 通过执行以下步骤,我们可以消除一些样板代码:

    1. 创建一个抽象的基础存储库类,该类为实体提供CRUD操作。
    2. 创建扩展抽象基础存储库类的具体存储库类。

    这种方法的问题在于,我们仍然必须编写用于创建数据库查询并调用它们的代码。 更糟的是,每次要创建新的数据库查询时,我们都必须这样做。 这是浪费时间

    如果我告诉您我们可以创建JPA存储库而无需编写任何样板代码,您会怎么说?

    很有可能您可能不相信我,但是Spring Data JPA可以帮助我们做到这一点。 Spring Data JPA项目的网站指出

    实现应用程序的数据访问层已经很长一段时间了。 为了执行简单查询以及执行分页和审核,必须编写太多样板代码。 Spring Data JPA旨在通过将工作量减少到实际需要的数量来显着改善数据访问层的实现。 作为开发人员,您将编写包括自定义finder方法在内的存储库接口,Spring会自动提供实现

    这篇博客文章介绍了Spring Data JPA。 我们将学习Spring Data JPA的真正含义,并快速浏览一下Spring Data存储库接口。

    让我们开始吧。

    什么是Spring Data JPA?

    Spring Data JPA不是JPA提供程序 。 它是一个库/框架,在我们的JPA提供程序的顶部添加了额外的抽象层。 如果我们决定使用Spring Data JPA,则我们应用程序的存储库层包含以下三层:

    下图说明了存储库层的结构:

    springdatajpalayers

    补充阅读:

    乍一看,Spring Data JPA似乎使我们的应用程序变得更加复杂。 它的确在我们的存储库层中增加了一层,但是与此同时,它使我们无需编写任何样板代码。

    听起来这是一个不错的权衡。 对?

    Spring数据存储库简介

    Spring Data JPA的功能在于由Spring Data Commons项目提供并由特定于数据存储的子项目扩展的存储库抽象。

    我们可以使用Spring Data JPA而不用注意存储库抽象的实际实现,但是我们必须熟悉Spring Data存储库接口。 这些接口描述如下:

    首先 ,Spring Data Commons项目提供以下接口:

    其次 ,Spring Data JPA项目提供以下接口:

    存储库层次结构如下所示:

    springdataj存储库

    很好,但是我们如何使用它们呢?

    这是一个公平的问题。 本教程的下一部分将回答该问题,但实际上我们必须遵循以下步骤:

    1. 创建一个存储库接口,并扩展Spring Data提供的存储库接口之一。
    2. 将自定义查询方法添加到创建的存储库界面(如果需要的话)。
    3. 将存储库接口注入到另一个组件,并使用Spring自动提供的实现。

    让我们继续并总结从这篇博客文章中学到的知识。

    摘要

    这篇博客文章教会了我们两件事:

    • Spring Data JPA不是JPA提供者。 它只是“隐藏”了其存储库抽象之后的Java Persistence API(和JPA提供程序)。
    • Spring Data提供了多个用于不同目的的存储库接口。

    本教程的下一部分描述了如何获取所需的依赖关系。

    如果您想了解更多有关Spring Data JPA的信息,请阅读我的Spring Data JPA教程

    翻译自: https://www.javacodegeeks.com/2014/12/spring-data-jpa-tutorial-introduction.html

    展开全文
  • 刚开始使用Springboot开发项目时,ORM框架就用的Spring Data JPA,只是之前断断续续用了一年有余,没有做一些总结...1、首先新建一个springboot项目,项目名为springdata,springboot的版本就用2.0.5.RELEASE。 <...

    刚开始使用Springboot开发项目时,ORM框架就用的Spring Data JPA,只是断断续续用了一年有余,没有做一些总结,趁着现在疫情严重,工作不多的情况下,就来做个笔记,记录一下Springboot集成Spring Data JPA的大体步骤。
    1、首先新建一个springboot项目,项目名为springdata,springboot的版本就用2.0.5.RELEASE。

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.5.RELEASE</version>
        <relativePath/>
    </parent>
    

    2、导入相应的jar包

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
    
        <!-- mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
    
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
    

    3、新建User实体类,并加入注解

    import lombok.Data;
    import lombok.ToString;
    import javax.persistence.*;
    import java.io.Serializable;
    
    @Data
    @Entity
    @Table(name = "user")
    @ToString
    public class User implements Serializable {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Integer id;
        @Column(name = "user_name")
        private String userName;
        @Column(name = "user_age")
        private Integer userAge;
    }
    

    注解说明:
    @Entity: 标明该类是一个实体类
    @Table: 指明数据库的表名
    @Id: 指定表的主键
    @GeneratedValue:指定主键的生成策略
    @Column: 指明类的成员属性和表中字段的对应关系
    4、新建UserDao接口,集成JpaRepository类,并新增查询用户sel方法,更新用户update方法

    import com.springdata.model.User;
    import org.springframework.data.jpa.repository.JpaRepository;
    import org.springframework.data.jpa.repository.Modifying;
    import org.springframework.data.jpa.repository.Query;
    import org.springframework.data.repository.query.Param;
    import org.springframework.stereotype.Repository;
    import org.springframework.transaction.annotation.Transactional;
    
    @Repository
    public interface UserDao extends JpaRepository<User, Integer> {
        @Query(value = "select id, user_name, user_age from user where id = :id", nativeQuery = true)
        User sel(@Param("id") int id);
    
        @Transactional
        @Modifying
        @Query(value = "update user set user_name = :userName, user_age = :userAge where id = :id", nativeQuery = true)
        void update(@Param("userName") String userName, @Param("userAge") Integer userAge, @Param("id") Integer id);
    }
    

    5、在resources目录的application.properties配置文件下新增mysql数据库配置和jpa配置

    server.port=8080
    
    # mysql数据库配置
    spring.datasource.url=jdbc:mysql://localhost:3306/test
    spring.datasource.username=root
    spring.datasource.password=root
    spring.datasource.driver-class-name=com.mysql.jdbc.Driver
    
    # JPA配置
    # 显示执行的sql语句
    spring.jpa.show-sql=true
    

    6、创建UserService接口类和实现类UserServiceImpl

    import com.springdata.model.User;
    import java.util.List;
    
    public interface UserService {
        public User sel(int id);
        public void add(User user);
        public void update(User user);
    }
    
    import com.springdata.dao.UserDao;
    import com.springdata.model.User;
    import com.springdata.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import java.util.List;
    
    @Service
    public class UserServiceImpl implements UserService {
        @Autowired
        private UserDao userDao;
    
        @Override
        public User sel(int id) {
            return userDao.sel(id);
        }
    
        @Override
        public void add(User user) {
            userDao.save(user);
        }
    
        @Override
        public void update(User user) {
            userDao.update(user.getUserName(), user.getUserAge(), user.getId());
        }
    }
    

    7、创建控制器类UserController

    import com.springdata.model.User;
    import com.springdata.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.*;
    import java.util.List;
    
    @RestController
    @RequestMapping("/user")
    public class UserController {
        @Autowired
        private UserService userService;
    
        @GetMapping(value = "/getUser/{id}")
        public String getUser(@PathVariable int id) {
            return userService.sel(id).toString();
        }
    
        @PostMapping(value = "/addUser", produces = "application/json;charset=UTF-8")
        public String addUser(@RequestBody User user) {
            try {
                userService.add(user);
            } catch (Exception e) {
                e.printStackTrace();
                return "error";
            }
            return "success";
        }
    
        @PostMapping(value = "/updateUser", produces = "application/json;charset=UTF-8")
        public String updateUser(@RequestBody User user) {
            try {
                userService.update(user);
            } catch (Exception e) {
                e.printStackTrace();
                return "error";
            }
            return "success";
        }
    }
    

    8、在mysql的test库下创建user表

    CREATE TABLE `user` (
    	`id` INT(32) NOT NULL AUTO_INCREMENT,
    	`user_name` VARCHAR(32) NOT NULL,
    	`user_age` INT(3) NOT NULL,
    	PRIMARY KEY (`id`) USING BTREE
    )
    

    9、启动springdata项目并使用postman测试
    新增用户:
    在这里插入图片描述
    修改用户:
    在这里插入图片描述
    查询用户:
    在这里插入图片描述
    至此Springboot集成Spring Data JPA已经全部完成,测试也非常成功,是不是很简单!
    有可以改进的地方希望诸位同学不要吝惜笔墨,加以指正,万分感谢!

    展开全文
  • Spring Data JPA 106精讲

    千人学习 2019-08-02 17:28:32
    本套课程从最基础JPASpringData JPA面面俱到!一共有106讲, 本系列课程会实战演示SpringData JPA的各个功能特性。 1:本系列课程全程使用注解,无xml 2:详解Spring Data JPA封装的各种查询方式 3:详解Spring ...
  • spring data JPA实战(一)实现基本的增删改查 1.构建项目 1.1使用IDEA新建项目 定义包名后next-&amp;amp;gt;勾选基本依赖 finish 完成 1.2 配置数据库参数 删除application.properties,新建application.yml,...

    spring data JPA教程(一)实现基本的增删改查

    1.构建项目

    1.1使用IDEA新建项目

    定义包名后next->勾选基本依赖

    finish 完成

    1.2 配置数据库参数

    删除application.properties,新建application.yml,配置信息如下:

    spring:
      datasource:
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://localhost:3306/jpa-demo?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
        username: root
        password: root
      jpa:
        hibernate:
          ddl-auto: update
        show-sql: true
    

    com.mysql.jdbc.Driver 是 mysql5的jdbc驱动
    com.mysql.cj.jdbc.Driver 是 mysql6的jdbc驱动

    需要注意的是com.mysql.cj.jdbc.Driver是要配置时区的,这里配置为 Asia/Shanghai

    ddl-atuo取值

    • **create: **每次运行该程序,根据modl类创建信标,表内有数据会清空
    • **create-drop: **每次程序启动,会根据model类创建新的表,程序结束sessionFactory销毁时,把对应表删除掉.
    • update 每次运行程序,没有表格会新建表格,表内有数据不会清空,只会更新
    • validate: 加载Hibernate时,校验model类与数据库的字段类型是否相同,不会创建或更新表 不同会报错

    mysql新建数据库 jpa-demo

    2.定义实体类

    User.java

    @Entity
    public class User {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private  Long id;
        private String nickname;
        private String telnum;
        @Temporal(TemporalType.TIMESTAMP)
        private Date signDate;
        //spring boot jpa 需要提供默认的构造函数
        public User(){}
        //此处省略get和set方法
    }
    

    用到的注解含义

    @Entity

    应用于实体类,表明该实体类被JPA管理,将映射到指定的数据库表

    @Id

    应用于实体类的属性或者属性对应的getter方法,表示该属性映射为数据库表的主键

    @GerneratedValue

    于@Id一同使用,表示主键的生成策略,通过strategy属性指定。

    JPA提供的生成策略有:

    • AUTO — JPA自动选择合适的策略,是默认选项
    • IDENTITY — 采用数据库ID自增长的方式来生成主键值,Oracle不支持这种方式;
    • SEQUENCE — 通过序列产生主键,通过@SequenceGenerator注解指定序列名,MySql不支持这种方式;
    • TABLE — 采用表生成方式来生成主键值,这种方式比较通用,但是效率低

    2.定义Repository接口

    UserRepository.java

    package com.wg.japdemo.domain;
    import org.springframework.data.jpa.repository.JpaRepository;
    public interface UserRepository extends JpaRepository<User,Long> {
    }
    

    3.实现service层

    UserService.java 定义了基本的增删改查接口

    package com.wg.japdemo.service;
    import com.wg.japdemo.domain.User;
    import org.springframework.stereotype.Service;
    public interface UserService {
        User saveUser(User user);
        void deleteUser(User user);
        void deleteUser(Long id);
        User updateUser(User user);
        User findUser(Long id);
    }
    

    UserServiceImpl.java UserService接口实现类

    package com.wg.japdemo.service;
    
    import com.wg.japdemo.domain.User;
    import com.wg.japdemo.domain.UserRepository;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    /**
     * @Author: wanggang.io
     * @Date: 2018/12/13 8:56
     * @todo
     */
    @Service
    public class UserServiceImpl implements UserService {
        @Autowired
        private UserRepository userRepository;
        @Override
        public User saveUser(User user) {
            User user1 =  userRepository.save(user);
            return user1;
        }
    
        @Override
        public void deleteUser(User user) {
          userRepository.delete(user);
        }
    
        @Override
        public void deleteUser(Long id) {
            userRepository.deleteById(id);
        }
    
        @Override
        public User updateUser(User user) {
    
            return userRepository.save(user);
        }
        
        @Override
        public User findUser(Long id) {
            return userRepository.findById(id).get();
        }
    }
    
    

    4.实现Controller层

    UserController.java

    package com.wg.japdemo.controller;
    
    import com.wg.japdemo.domain.User;
    import com.wg.japdemo.domain.Wallet;
    import com.wg.japdemo.service.UserServiceImpl;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    import java.math.BigDecimal;
    import java.util.Date;
    
    /**
     * @Author: wanggang.io
     * @Date: 2018/12/13 9:03
     * @todo
     */
    @RestController
    @RequestMapping("user")
    public class UserController {
    
        @Autowired
        private UserServiceImpl userServiceImpl;
        @GetMapping("add")
        private User addUser(String nickName,String telNum){
            User user = new User();
            user.setNickname(nickName);
            user.setTelnum(telNum);
            userServiceImpl.saveUser(user);
            return user;
        }
        @GetMapping("del")
        private String delUser(Long id){
            userServiceImpl.deleteUser(id);
            return "SUCCESS";
        }
        @GetMapping("update")
        private User updateUser(Long id,String nickName){
            User user = userServiceImpl.findUser(id);
            user.setNickname(nickName);
            userServiceImpl.updateUser(user);
            return user;
        }
        @GetMapping("find")
        private User findUser(Long id){
            return userServiceImpl.findUser(id);
        }
    }
    
    

    5.运行

    好了,是时候运行程序验证下我们的成果了

    首次执行程序时,jpa会根据User类在数据库中自动生成表

    通过log打印的sql,可以看到执行了建表操作

    Hibernate: create table user (id bigint not null auto_increment, nickname varchar(255), sign_date datetime, telnum varchar(255)) engine=MyISAM

    打开chrom浏览器,依次访问下面链接 ,我本机的8080端口被占用了,这里使用的时9191

    新增

    http://localhost:9191/user/add?nickName=Jack&telNum=13848484848

    新建User用户 nickName为jack,telNum为:13848484848

    修改

    http://localhost:9191/user/update?nickName=Tom&id=1

    将Id为1的用户nickName修改为Tom

    删除

    http://localhost:9191/user/del?id=1

    删除Id为1的用户

    查询

    http://localhost:9191/user/find?id=2

    查询Id为2的用户

    项目地址

    展开全文
  • spring-data-jpa:Spring Data JPA教程
  • 主要给大家总结介绍了关于使用Spring Data JPA的一些坑点,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧。
  • 一、JPA概述 开篇立即进入正题,以下是最古老的数据库操作方式(应用程序直接连接数据库): #mermaid-svg-V6DI5QB7oR2JM7z4 .label{font-family:'trebuchet ms', verdana, arial;font-family:var(--mermaid-font-...
  • Lustre 中的 Spring Data JPA 教程 教程示例代码:
  • Spring Data JPA项目

    2020-02-25 22:00:42
    课程以Spring Data JPA和Swagger2为主线,讲解如何使用JPA访问数据库,如何使用Swagger2为前端构建在线API文档
  • 本课程针对广大的Java开发工作者。使大家可以全面、完整的掌握SpringDataJpa技术。并独立实现复杂的查询业务。
  • 在创建使用Spring Data JPA的应用程序... 其他阅读:如果您不熟悉Spring Data JPA,则应该阅读以下博客文章,然后再继续阅读此博客文章: Spring Data JPA教程:简介提供了Spring Data JPA的快速介绍,并概述了Sprin...
  • Spring Data JPA详细使用教程 简介 Spring Data提供了针对数据库(包括SQL和NOSQL)的整合方案,对Hibernate JPA、Jedis等工具的api进行高级的封装,为我们提供简单方便地操作接口。 Spring Data JPASpring Data...
  • 第1章1.ORM概述[了解] ORM(Object-Relational Mapping) 表示对象关系映射。在面向对象的软件开发中,通过ORM,就可以把对象映射到关系型数据库中。只要有一套程序能够做到建立对象与数据库的关联,操作对象就可以...
  • Spring Data Jpa系列教程(一)--------入门

    万次阅读 多人点赞 2018-03-09 10:18:55
    大渣好,我是小小书生,现在开始,我们来学习船新的一门技术,SpringDataJpa,它是一个。。额。。(我百度一下)   JPA(Java Persistence API)是Sun官方提出的Java持久化规范。它为Java开发人员提供了一种对象/...
  • 为什么要重新学习“Spring Data JPA”?俗话说的好:“未来已经来临,只是尚未流行”,纵观市场上的 ORM 框架,MyBatis 以灵活著称,但是要维护复杂的配置,并且不是 Spring 官方的天然全家桶,还得做额外的配置工作...
  • spring data jpa视频教程

    2018-06-29 15:38:22
    spring data jpa 视频教程百度云盘下载地址
  • 各位同学大家好, 最近在学springboot 整合的SpringDataJPA框架,有点小心得就想着分享给大家 ,正好今天2020 7月12号是我27岁生日(步入中年)就把这篇SpringBoot整合SpringDataJPA 教程 送给大家希望大家喜欢 废话...
  • Spring Data JPA详细入门

    千次阅读 2020-02-01 13:58:40
    Spring Data JPA超详细入门,使用的spring boot是2.2.4.RELEASE版本,相较之前的版本有所不同。本文主要讲解了如何创建实体类,怎样创建dao层,并在dao层自定义sql查询
  • Spring Data JPA数据库操作教程.zip
  • Spring Data JPA精讲

    2019-02-28 23:05:14
    本课程是《Java零基础至高级应用》系统课程的第18章,全套课程精细讲解,课程提供全套代码笔记其它相关素材及答疑服务,可谓是低投资高回报!
  • spring data jpa介绍 首先了解JPA是什么? JPA(Java Persistence API)是Sun官方提出的Java持久化规范。它为Java开发人员提供了一种对象/关联映射工具来管理Java应用中的关系数据。他的出现主要是为了简化现有的...
  • SpringData提供了针对数据库(包括SQL和NOSQL)的整合方案,对Hibernate JPA、Jedis等工具的api进行高级的封装,为我们提供简单方便地操作接口。 Spring Data JPA Spring Data提供了针对数据库(包括SQL和NOSQL)的...
  • Spring Data JPA教程:审计(一)

    千次阅读 2016-02-29 17:58:30
    提到审计,首先从脑海中蹦出的就是审计日志,记录了实体版本的修改信息。实现审计日志是个既耗时又复杂的任务。...下面我们介绍一下怎样通过Spring Data JPA提供的审计功能记录实体的创建和修改时间。一开始
  • spring data jpa 入门

    千次阅读 热门讨论 2017-01-12 17:15:03
    初衷本文是spring data jpa 入门级的操作,实现CRUD操作,详细的概念可以参考文末的文章。参考网上一些文章,实际coding的时候还是出好多错误,这里记录摸索填坑的过程。
  • Spring Data JPA是一个旨在简化基于JPA的存储库的创建并减少与数据库通信所... 这是我的Spring Data JPA教程的第一部分,它将向您介绍在将Hibernate用作JPA提供程序时如何配置Spring Data JPA。 在开始之前,我想弄...
  • springDataJpa入门教程(1)-基于springBoot的基本增删改查

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,599
精华内容 2,239
关键字:

springdatajpa教程

spring 订阅