SpingBoot整合jdbctemplate/MyBatis/Srping Data-比较

最新推荐文章于 2023-07-27 15:48:09 发布
最新推荐文章于 2023-07-27 15:48:09 发布
阅读量534 收藏 3
点赞数 2
分类专栏： Java核心技术 SpingBoot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wd_888/article/details/105335563
版权

文章目录

SpringBoot提供的数据持久层的解决方案：

  1. SpringBoot+jdbctemplate（用的很少，自己demo用用挺好，轻量级，功能比较少）
  2. SpringBoot+MyBatis(实际开发中使用最多)
  3. SpringBoot+Spring Date JPA（没有2用的多，它的优点可能就在于它是Spring整个体系下提供的，并且支持ORM，因为底层基于Hibernate实现的，自动完成实体类和表的映射，就不用像MyBatis那样手动完成映射了。）
概念

1.Hibernate：Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。属于全自动的ORM框架，着力点在于POJO和数据库表之间的映射，完成映射即可自动生成和执行sql。
2.Mybatis：MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。属于半自动的ORM框架，着力点在于POJO和SQL之间的映射，自己编写sql语句，然后通过配置文件将所需的参数和返回的字段映射到POJO。
3.Spring Data JPA：Spring Data是一个通过命名规范简化数据库访问，并支持云服务的开源框架。其主要目标是使得对数据的访问变得方便快捷，并支持map-reduce框架和云计算数据服务。

1.SpringBoot+jdbctemplate

JdbcTemplate 是 Spring 自带的 JDBC 模版组件，底层实现了对 JDBC 的封装，⽤用法与 MyBatis 类似，开发者需要⾃自定义 SQL 语句句，JdbcTemplate 帮助开发者完成数据库连接，SQL 执⾏，以及结果集的解析。
目录结构：
在这里插入图片描述
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.southwind</groupId>
    <artifactId>jdbctemplate</artifactId>
    <version>1.0-SNAPSHOT</version>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

</project>

entity：

@Data
public class Student {
    private int id;
    private String name;
}

数据层：

public interface StudentRepository {
    Student findById(int id);
}

@Repository
public class StudengRepositoryImpl implements StudentRepository {

    @Autowired
    JdbcTemplate jdbcTemplate;

    @Override
    public Student findById(int id) {
        //三个参数：1.sql。2.参数数组。3.BeanPropertyRowMapper是RowMapper的实现类。RowMapper是一个接口，作用是解析结果集，将sql查询出的ResultSet对象转换为泛型指定的java对象。
        return jdbcTemplate.queryForObject("select * from student where id = ?",new Object[]{id},new BeanPropertyRowMapper<Student>(Student.class));
    }
}

controller层：

@RestController
public class StudentHandler {

    @Autowired
    StudentRepository studentRepository;

    @GetMapping("/findById/{id}")
    public Student findById(@PathVariable("id") int id){
        return studentRepository.findById(id);
    }
}

Application启动类：

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

配置文件：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/jdbc?serverTimezone=UTC
    username: root
    password: xxxx
    driver-class-name: com.mysql.cj.jdbc.Driver

数据库部分就建了个Student表。
上面代码复制即可运行。
因为jdbc现实中很少使用的，所以就curd就不具体写了。
可以注意的是：

JdbcTemplate 对基本的 CRUD 操作提供了了良好的⽀支持，通过调⽤用 query 和 update ⽅方法即完成相关操作，其中 query 是⽤用来做查询操作的，update 是⽤用来做添加、删除、修改功能。

1、queryForObject(String sql,Object[] args,RowMapper rowMapper)，查询⼀条记录，并且将结果集封装成 Java 对象。
2、query(String sql,RowMapper rowMapper)，查询⼀组数据，并且将结果集封装成集合对象。RowMapper 是⼀个接⼝，作⽤就是解析结果集，将 JDBC 查询出的 ResultSet 对象转换为对应的 Java对象，在调⽤用该对象时需要指定目标类的结构，泛型。

update(String sql, Object… args)
参数：1、要执⾏的 SQL 语句。2、可变参数 Object…args，满⾜参数的可变性。

客户端⽤?传参 key-value 形式将数据传给 Spring MVC 服务端，业务方法的形参列表不需要添加任何注解即可自动封装参数 Java 对象。
客户端传 JSON 格式数据，业务⽅法的形参列表需要添加 @RequestBody 注解，才能封装参数 Java 对象。

业务方法的参数的注解形式比较：

@PathVariable:

@GetMapping("/findById/{id}")
    public Student findById(@PathVariable("id") int id){
        return studentRepository.findById(id);
    }

访问服务的url格式：http://localhost:8080/findById/1

@RequestParam:

@GetMapping("/findById")
    public Student findById(@RequestParam int id){
        return studentRepository.findById(id);
    }

访问服务的url格式：http://localhost:8080/findById?id=1,当然@RequestParam:是可以省略的！

@RequestBody:

@GetMapping("/saveByStu")
    public Student findById(@RequestBody Student stu){
        return studentRepository.findById(stu);
    }

访问服务的url格式：http://localhost:8080/saveByStu,我是用postman测试的，传入josn格式的数据。如果不写这个注解，是数据添加不进去的。因为参数压根就没有解析拿到。

2.SpringBoot+MyBatis

目录结构：
在这里插入图片描述
与jdbcTemplate相比，MyBatis主要区别在于不用再java中写sql语句，而是用xml语句完成，灵活性和扩展性更好。

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>www.gosang</groupId>
    <artifactId>springbootMyBatis</artifactId>
    <version>1.0-SNAPSHOT</version>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>
</project>

application.yml

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC
    username: root
    password: xxxx
    driver-class-name: com.mysql.cj.jdbc.Driver
mybatis:
  mapper-locations: /mapping/*.xml
  type-aliases-package: com.gosang.entity

配置了实体类和mapping的映射。

Application

package com.gosang;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.gosang.repository")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

启动类与jdbc不同的是加了@MapperScan(“com.gosang.repository”)，扫描，把这些代理类交给Spring管理。

其他的业务代码就大差不差了。如下：
StudentRepository.java

public interface StudentRepository {
    List<Student> findAll();
    Student findById(int id);

    void save(Student student);
    void update(Student student);
    void delete(int id);
}

StudentRepository.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.gosang.repository.StudentRepository">
    <select id="findAll" resultType="Student">
        select * from student
    </select>

    <select id = "findById" parameterType = "int" resultType = "Student">
        select * from Student where id = #{id}
    </select>

    <insert id="save" parameterType="Student">
        insert into Student(name) VALUES (#{name});
    </insert>

    <update id="update" parameterType="Student">
        update Student set name = #{name} where id = #{id}
    </update>

    <delete id="delete" parameterType="int">
        delete from Student where id = #{id}
    </delete>
</mapper>

StudentHandler.java

@RestController
public class StudentHandler {

    @Autowired
    StudentRepository studentRepository;

    @GetMapping("/findAll")
    public List<Student> fingAll(){
        return studentRepository.findAll();
    }

    @GetMapping("/findById")
    public Student findById(int id){
        return studentRepository.findById(id);
    }

    @PostMapping("/save")
    public void save(@RequestBody Student student){
        studentRepository.save(student);
    }

    @PutMapping("/update")
    public void update(@RequestBody Student student){
        studentRepository.update(student);
    }

    @DeleteMapping("/delete")
    public void delete(int id){
        studentRepository.delete(id);
    }
}

同上在postman中去测试。
http://localhost:8080/findAll
http://localhost:8080/findById?id=1
在这里插入图片描述在这里插入图片描述**小结：**与jdbc那种在java文件中写sql式的硬编码方式相比MyBatis就显得更加灵活，耦合度更低。

3.SpringBoot+Spring Date JPA

Spring Date JPA是Spring提供的持久层解决方案，但它本身并不是一个具体的实现，它是比较上层的封装，底层还是基于Hibernate。
虽然JdbcTemplate同样是Spring提供的，但他只是一个模板。Spring Date JPA是一个体系更大的基于Hibernate的持久层实现。

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.southwind</groupId>
    <artifactId>springboot+springdatajpa</artifactId>
    <version>1.0-SNAPSHOT</version>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

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

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

</project>

application.yml

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: xxx
    url: jdbc:mysql://localhost:3306/mybatis
  jpa:
    show-sql: true
    properties:
      hibernate:
        format_sql: true

Application

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

entity实体类

@Data
@Entity
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @Column
    private String name;
}

这里实体类的写法就和前两种有所区别了。能自动完成映射这些注解少不了。

StudentRepository

public interface StudentRepository extends JpaRepository<Student,Long> {
    public Student findByName(String name);
}

用这个方案和Hibernate一样，连sql语句都不用写了，都是JpaRepository会提供的。我们只要继承这个接口就可以使用的，开箱即用。要注意的是，起名字一定要规范，才能自动识别到对应类型的sql。如public Student findByName(String name);。

StudentHandler

@RestController
public class StudentHandler {
    @Autowired
    private StudentRepository studentRepository;

    @GetMapping("/findAll")
    public List<Student> findAll(){
        return studentRepository.findAll();
    }

    @GetMapping("/findById/{id}")
    public Student findById(@PathVariable("id") Long id){
        return studentRepository.findById(id).get();
    }

    @PostMapping("/save")
    public void save(@RequestBody Student student){
        studentRepository.save(student);
    }

    @PutMapping("/update")
    public void update(@RequestBody Student student){
        studentRepository.save(student);
    }

    @DeleteMapping("/deleteById/{id}")
    public void deleteById(@PathVariable("id") Long id){
        studentRepository.deleteById(id);
    }

    @GetMapping("/findByName/{name}")
    public Student findByName(@PathVariable("name") String name){
        return studentRepository.findByName(name);
    }
}
GoSang
关注
专栏目录
SpringBoot同时整合JdbcTemplate,Mybatis,Jpa多数据源（MySQL和SQL sever）
熊老大的专栏
06-20 1878
SpringBoot同时整合JdbcTemplate,Mybatis,Jpa多数据源（MySQL和SQL sever）
springboot集成jdbcTemplate/Mybatis/JPA
weixin_45863786的博客
02-29 518
1.springboot集成jdbcTemplate模板 引入相应的mysql和jdbcTemplate包 <!-- jdbcTemplat jdb模板依赖 --> <dependency> <groupId>org.springframework.boot</groupId> ...
SpringBoot初学（4）– JdbcTemplate和Mybatis
weixin_30410999的博客
03-13 357
前言 github： https://github.com/vergilyn/SpringBootDemo 代码位置： 一、Spring Boot集成JdbcTemplate或NamedParameterJdbcTemplate spring boot中JdbcTemplate与NamedParameterJdbcTemplate都是被自动配置的，所以只要注入就可用。（在传统的spr...
MySQL JDBC与JDBCTemplate和Mybatis比较
鸟人的博客
10-12 354
我们来比较一下JDBC，JDBCTemplate，MyBatis对MySQL数据库的操作，如下 根据id删除 添加一条记录 更新一条记录 根据Id查找记录 JdbcTemplate XML 代码 Mybatis XML 基于Spring的配置 XML Mapper的XML文件
Spring Boot多数据源配置之JdbcTemplate
热门推荐
江南一点雨的专栏
03-17 1万+
多数据源配置也算是一个常见的开发需求，Spring和SpringBoot中，对此都有相应的解决方案，不过一般来说，如果有多数据源的需求，我还是建议首选分布式数据库中间件MyCat去解决相关问题，之前有小伙伴在我的知识星球上提问，他的数据根据条件的不同，可能保存在四十多个不同的数据库中，怎么办？这种场景下使用多数据源其实就有些费事了，我给的建议是使用MyCat，然后分表策略使用sharding-by...
SpringBoot持久层技术(jdbcTemplate+mybatis+springdataJPA)
coding_deliver的博客
10-19 559
整合jdbcTemplate jdbctemplate是Spring提供的JDBC框架，利用AOP技术来解决直接使用jdbc带来的大量代码的繁杂问题 SpringBoot对JdbcTemplate的使用提供了一套自动化配置类：JdbcTemplateAutoConfiguration类,所以想要使用只需要提供JdbcTemplate的依赖和dataSource依赖即可 案例 整合Mybaits SpringBoot同样为Mybatis提供了自动化配置 导入Mybatis依赖、数据库依赖、数据库连接池的依赖
jdbc/mybatis使用及Spring-mybatis整合源码分析
ppprog的博客
08-09 217
本文主要对 JDBC连接db / Spring-JDBC连接db / Mybatis独立使用 / Spring整合Mybatis 几种db连接和使用的过程作出总结，并对其中的关键环节进行源码分析。 事务部分暂时还没整理，后面会补全。 部分配置文件还没加上，后面会补全。 说明：文中大部分内容来源于阅读《Spring源码深度解析》时的笔记，同时添加了一些自己的理解。书中使用的Spring 5.x版本，代码有点老，但核心原理一直都差不多。 1 JDBC连接db 一般流程 在开发环境加载指定db的驱动程序 在ja
spring-mybatis整合jar包，spring-mybatis整合jar包
03-17
在这个整合包中，Mybatis作为数据访问层的工具，与Spring的IoC容器配合，实现了DAO（Data Access Object）的管理。 4. **javassist-3.17.1-GA.jar**：这是一个Java字节码操作库，Mybatis用它来动态生成代理类，实现...
SpringBoot整合jdbcTemplate特详细教程
weixin_42139662的博客
01-24 6656
这里主要就是写一下自己是如何使用springboot来做的JdbcTemplate的整合操作的 先说一下自己的环境吧:系统是win10的,jdk1.8(64位),mysql 是Ver 14.14 Distrib 5.5.27, for Win32 (x86) 第一步先创建一个springboot的项目 先来看一下最终的目录结构吧 pom文件 &lt;?xml version="1....
SpringBoot (三) 整合数据库访问 jdbcTemplate、MyBatis
有勇气的牛排博客
03-04 566
Spring Data了解下：Spring Data官网：https://docs.spring.io/spring-data/jpa/docs/current/reference/html/ Spring Data主要为数据访问提供一个相似的、一致的、基于Spring的编程模型，同时保留各个数据库的存储特征，这使得数据访问技术变得非常简单。常用的整合数据模型有：Jdbc、MyBatis、durid
SpringBoot建立数据库连接JdbcTemplate和Mybatis两种方式
CWH615的博客
03-08 6616
Spring Boot有两种方法与数据库建立连接，一种是使用JdbcTemplate，另一种集成Mybatis，下面分别为大家介绍一下如何集成和使用这两种方式。1. 使用JdbcTemplate&lt;dependency&gt;    &lt;groupId&gt;mysql&lt;/groupId&gt;    &lt;artifactId&gt;mysql-connector-java&lt...
Spring Boot实践三 --数据库访问（JdbcTemplate、mybatis、JPA Hibernate）
最新发布
造梦先森Kai的专栏
07-27 1392
2，在src/main/resources/application.properties中配置数据源信息。
Spring Boot常用数据库开发技术总结：JDBCTemplate、JPA、Mybatis
Joker_ZJN的博客
04-05 1571
本文主要介绍最常用到的三个持久层框架，JdbcTemplate、JPA、mybatis如何接入Spring Boot并在其上进行开发。
大厂大牛教你如何用SpringBoot 整合jdbc和mybatis
p1830095583的博客
04-13 390
通用配置 下面介绍的整合JDBC和整合MyBatis都需要添加的实体类和配置 数据库表 CREATE TABLE `user` ( `id` int(11) NOT NULL AUTO_INCREMENT, `username` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL, `address` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_
springboot 集成 mysql_springboot+jdbctemplate+mybatis方式与0行代码写服务的差异
weixin_39721924的博客
11-26 119
springboot+jdbctemplate方式/spingboot+mybatis方式与0行代码写服务的差异，不看后悔死视频晚上录接口工作量对比(这里只对比最精简模式)1.springboot+jdbctemplate1.springboot+mybatis0行代码写服务开发环境搭建演示项目技术点Springboot项目gradle构建Springboot+jdbctemplate集成Spri...
SpringBoot用JdbcTemplates访问Mysql实例代码
08-30
本篇文章主要介绍了SpringBoot用JdbcTemplates访问Mysql实例代码，非常具有实用价值，需要的朋友可以参考下
JDBC，MYBATIS，Hibernate性能对比！
kanpiaoxue的专栏
01-01 149
来源: http://www.cnblogs.com/softman11/archive/2013/04/06/3001874.html
Springboot 系列（十）使用 Spring data jpa 访问数据库
spring_root的博客
01-22 216
前言 Springboot data jpa 和 Spring jdbc 同属于 Spring开源组织，在 Spring jdbc 之后又开发了持久层框架，很明显 Spring data jpa 相对于 Spring jdbc 更加的便捷强大，不然也就没有开发的必要了。根据下面的文章开始体验下 Spring data jpa 魅力。 Spring data jpa 介绍 Spring dat...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值