MyBatis学习04-前篇之Spring-Data-JPA

最新推荐文章于 2023-05-13 23:09:49 发布

还有头发的老李

最新推荐文章于 2023-05-13 23:09:49 发布

阅读量214

点赞数

分类专栏： MyBatis 文章标签： java mybatis

本文链接：https://blog.csdn.net/wwww641788662/article/details/106749175

版权

MyBatis 专栏收录该内容

11 篇文章 1 订阅

订阅专栏

MyBatis学习04-前篇之Spring-Data-JPA

1 前言

JDBC 是 JAVA 操作数据库的最原始的方式，commons-dbutils、JdbcTemplate等都是对 JDBC 操作的一层封装，使用 JDBC、commons-dbutils、JdbcTemplate 等进行开发，还是需要对数据库操作的相关资源进行考虑。程序员是懒惰的，对于一些重复性的工作，都会考虑如何使用一套工具或者一套框架进行解决，于是提出了 ORM 框架的概念。

ORM 即 Object-Relationl Mapping，它的作用是在关系型数据库和对象之间作一个映射，这样，我们在具体的操作数据库的时候，就不需要再去和复杂的SQL语句打交道，只要像平时操作对象一样操作它就可以了。字母O起源于"对象"(Object),而R则来自于"关系"(Relational)。几乎所有的程序里面，都存在对象和关系数据库。在业务逻辑层和用户界面层中，我们是面向对象的。当对象信息发生变化的时候，我们需要把对象的信息保存在关系数据库中。当你开发一个应用程序的时候(不使用 O/R Mapping),你可能会写不少数据访问层的代码，用来从数据库保存，删除，读取对象信息，等等。你在代码中写了很多的方法来读取对象数据，改变状态对象等等任务。而这些代码写起来总是重复的。

ORM 解决的主要问题是对象关系的映射。域模型和关系模型分别是建立在概念模型的基础上的。域模型是面向对象的，而关系模型是面向关系的。一般情况下，一个持久化类和一个表对应，类的每个实例对应表中的一条记录，类的每个属性对应表的每个字段。 ORM 技术具有如下特点：

提高了开发效率。由于 ORM 可以自动对 Entity 对象与数据库中的 Table 进行字段与属性的映射，所以我们实际可能已经不需要一个专用的、庞大的数据访问层。
ORM 提供了对数据库的映射，不用 sql 直接编码，能够像操作对象一样从数据库获取数据。

2 Spring-Data-JPA

2.1 官网地址

https://spring.io/projects/spring-data-jpa#overview

2.2 简介

2.2.1 JPA

JPA 的是 Java Persistence API 的简写，是 Sun 官方提出的一种ORM 规范！
Sun 提出此规范有2个原因：1. 简化现有 Java EE 和 Java SE 应用开发工作。2. Sun 希望整合 ORM 技术，实现天下归一。
JPA 是一套规范，而不是具体的 ORM 框架。
故 Hibernate、TopLink 等 ORM 框架都是 JPA 的实现，其中 Hibernate 已获得Sun的兼容认证。
JPA 的标准的定制是 hibernate 作者参与定制的，所以 JPA 是 Hibernate 的一个总成。

JPA 的优势：

开发者面向 JPA 规范的接口，但底层的 JPA 实现可以任意切换：觉得 Hibernate 好的，可以选择 Hibernate JPA 实现；觉得 TopLink 好的，可以选择 TopLink JPA 实现。
这样开发者可以避免为使用Hibernate学习一套 ORM 框架，为使用 TopLink 又要再学习一套 ORM 框架。

2.2.2 Spring-Data-JPA

首先 Spring 框架几乎是无所不能，无所不在。
其次 Spring 也想要做持久化相关工作，并且已有 Spring-data-** 这一系列包（Spring-data-jpa,Spring-data-template,Spring-data-mongodb等）。
其中 Spring-data-jpa 即代表着，Spring 框架对 JPA 的整合。
Spring Data JPA 是在 JPA 规范的基础下提供了 Repository 层的实现。

Spring-Data-JPA 对 JDBC 进行了一系列的封装加强，使用 Spring-Data-JPA 可以不写一行 SQL 代码就完成一套简单的应用系统。 Spring-Data-JPA 官方介绍如下：

Spring Data JPA, part of the larger Spring Data family, makes it easy to easily implement JPA based repositories. This module deals with enhanced support for JPA based data access layers. It makes it easier to build Spring-powered applications that use data access technologies.

Implementing a data access layer of an application has been cumbersome for quite a while. Too much boilerplate code has to be written to execute simple queries as well as perform pagination, and auditing. Spring Data JPA aims to significantly improve the implementation of data access layers by reducing the effort to the amount that’s actually needed. As a developer you write your repository interfaces, including custom finder methods, and Spring will provide the implementation automatically.

2.3 示例

运行环境：Win10 + Jdk1.8 + Maven3 + Intellij IDEA 2020 + mysql5.7

1、示例代码地址

https://gitee.com/lif/study-mybatis/tree/master

2、目录结构如下

在这里插入图片描述

3、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">
    <parent>
        <artifactId>study-mybatis</artifactId>
        <groupId>com.ddpyjqtd</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <modelVersion>4.0.0</modelVersion>

    <artifactId>simple-spring-data-jpa</artifactId>

    <name>simple-spring-data-jpa</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>

        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-jpa -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
            <version>2.3.0.RELEASE</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-test -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>2.3.0.RELEASE</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.20</version>
            <scope>runtime</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.10</version>
            <scope>provided</scope>
        </dependency>

    </dependencies>
</project>

4、增加 model 类： Demo.java

package com.ddpyjqtd.demo.model;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import java.util.Date;

/***
 * 测试表对应的demo类
 *
 * @author ddpyjqtd
 * @date 2020/5/22 16:30
 */
@Getter
@Setter
@ToString
@Entity
@Table
public class Demo {
    /**
     * int 类型字段
     */
    @Id
    private int demoInt;
    /**
     * String 类型字段
     */
    private String demoVarchar;
    /**
     * text 类型字段
     */
    private String demoText;
    /**
     * datetime 类型字段
     */
    private Date demoDateTime;

}

5、增加 Spring Boot 配置文件：application.properties，内容如下：

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root

spring.jpa.show-sql=true

6、增加 Spring Boot 启动类：JpaApplication.java，内容如下：

package com.ddpyjqtd.demo;


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * SpringBoot 启动类
 *
 * @author: ddpyjqtd
 * @date: 2020/6/1 22:37
 */
@SpringBootApplication
public class JpaApplication {

    /**
     * 主函数
     *
     * @param args 参数
     * @author ddpyjqtd
     * @date 2020/6/1 22:37
     */
    public static void main(String[] args) {
        SpringApplication.run(JpaApplication.class);
    }
}

7、编写数据库操作接口：IDemoRepository.java，内容如下：

package com.ddpyjqtd.demo.dao;

import com.ddpyjqtd.demo.model.Demo;
import org.springframework.data.jpa.repository.JpaRepository;

/**
 * 使用 jpa 方式操作数据库
 *
 * @author: ddpyjqtd
 * @date: 2020/5/31 22:54
 */
public interface IDemoRepository extends JpaRepository<Demo, Integer> {
}

8、执行 SQL

CREATE TABLE demo  (
  demo_int int(255) NOT NULL COMMENT 'int 类型字段',
  demo_varchar varchar(255)  NULL DEFAULT NULL COMMENT 'String 类型字段',
  demo_text text  NULL COMMENT 'text 类型字段',
  demo_date_time datetime(0) NULL DEFAULT NULL COMMENT 'datetime 类型字段',
  PRIMARY KEY (demo_int) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bin COMMENT = '示例表，各个字段为数据库的各种类型' ROW_FORMAT = Dynamic;


insert into demo (demo_int, demo_varchar, demo_text, demo_date_time)
VALUES (1, 'this is demo_varchar', 'this is demo_text', now());

9、编写测试类：TestDemoDao.java，内容如下：

package com.ddpyjqtd.demo.dao;

import com.ddpyjqtd.demo.JpaApplication;
import com.ddpyjqtd.demo.model.Demo;
import lombok.extern.slf4j.Slf4j;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.Optional;

/**
 * 测试类
 *
 * @author: ddpyjqtd
 * @date: 2020/5/31 23:02
 */
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = JpaApplication.class)
@Slf4j
public class TestDemoDao {

    @Autowired
    private IDemoRepository demoRepository;

    /**
     * 测试通过主键查询 demo 对象的方法
     *
     * @author ddpyjqtd
     * @date 2020/5/31 23:06
     */
    @Test
    public void testFindDemoByDemoId() {
        Optional<Demo> demo = demoRepository.findById(1);
        log.info("demo info : {}", demo.toString());
        Assert.assertNotNull(demo);
    }
}

10、运行测试类，执行结果如下：

Hibernate: select demo0_.demo_int as demo_int1_0_0_, demo0_.demo_date_time as demo_dat2_0_0_, demo0_.demo_text as demo_tex3_0_0_, demo0_.demo_varchar as demo_var4_0_0_ from demo demo0_ where demo0_.demo_int=?
2020-06-14 17:40:12.467  INFO 15120 --- [           main] com.ddpyjqtd.demo.dao.TestDemoDao        : demo info : Optional[Demo(demoInt=1, demoVarchar=this is demo_varchar, demoText=this is demo_text, demoDateTime=2020-06-06 06:37:37.0)]
2020-06-14 17:40:12.478  INFO 15120 --- [extShutdownHook] j.LocalContainerEntityManagerFactoryBean : Closing JPA EntityManagerFactory for persistence unit 'default'
2020-06-14 17:40:12.480  INFO 15120 --- [extShutdownHook] o.s.s.concurrent.ThreadPoolTaskExecutor  : Shutting down ExecutorService 'applicationTaskExecutor'
2020-06-14 17:40:12.481  INFO 15120 --- [extShutdownHook] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Shutdown initiated...
2020-06-14 17:40:12.493  INFO 15120 --- [extShutdownHook] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Shutdown completed.

Process finished with exit code 0

2.4 优缺点

2.4.1 优点

Spring 对 DAO 的高度封装，不需要编写SQL就可以完成大部分业务的数据库操作。
内置了基础的数据库操作接口，开发过程中只需要实现定制化的接口即可，大量减少开发的工作量。
数据库移植性高。
基于 Spring，目前大部分份系统都会集成 Spring 进行开发，集成方便。
使用简单，系统开发成本最低，开发效率完胜其它所有的 ORM 框架。

2.4.2 缺点

对于复杂 sql 编写存在研编码，且会导致系统风格不统一问题。
jPA 在性能优化是个问题。

还有头发的老李

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
MyBatis学习04-前篇之Spring-Data-JPA

MyBatis学习04-前篇之Spring-Data-JPA1 前言2 Spring-Data-JPA2.1 官网地址2.2 简介2.2.1 JPA2.2.2 Spring-Data-JPA2.3 示例2.4 优缺点2.4.1 优点2.4.2 缺点1 前言JDBC 是 JAVA 操作数据库的最原始的方式，commons-dbutils、JdbcTemplate等都是对 JDBC 操作的一层封装，使用 JDBC、commons-dbutils、JdbcTemplate 等进行开发，还是需要对数据库操作的相
复制链接

扫一扫

专栏目录