Spring Boot常用数据库开发技术总结：JDBCTemplate、JPA、Mybatis

本是古典何须时尚 2023-09-25 21:58 41阅读 0赞

**目录**

1.概述

2.环境

3.JdbcTemplate

4.JPA

4.1.概述

4.2.基本使用

4.3.转换器

5.mybatis

--------------------

## 1.概述 ##

数据库开发一直是JAVA开发的核心之一，作为现在JAVA EE的基石框架，Spring Boot自身携带了一个JDBCTemplate框架，其对JDBC进行了基础的封装，使得Spring Boot原生就支持据库开发。同时Spring Boot也不排斥其它优秀的持久层框架，允许他们以极低的代价平滑的接入。

本文主要介绍最常用到的三个持久层框架，JdbcTemplate、JPA、mybatis如何接入Spring Boot并在其上进行开发。

## 2.环境 ##

*  spring boot 2.6.3
 *  MySQL

**基础依赖：**

<dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>
        </dependencies>
    
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-dependencies</artifactId>
                    <version>2.6.3</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>

**表：**

CREATE TABLE `user` (
      id int NOT NULL AUTO_INCREMENT,
      username varchar(50) NOT NULL,
      password varchar(50) NOT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB  DEFAULT CHARSET=utf8;

**数据库配置：**

# 数据库连接配置
    spring.datasource.url=jdbc:mysql://localhost:3306/mydb?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=GMT%2B8
    spring.datasource.username=root
    spring.datasource.password=123456
    spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

## 3.JdbcTemplate ##

JdbcTemplate是spring框架里面提供的一个JDBC的抽象层，封装了对创建的SQL操作，如SQL语句执行、结果处理等功能，使得我们能更方便地使用JDBC。

**依赖：**

JdbcTemplate是spring框架里的东西，在Spring Boot体系里其被包含在jdbc的starter中。

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

**使用：**

@Service
    public class UserService {
        @Autowired
        JdbcTemplate jdbcTemplate;
    
        RowMapper<User> userMapper=new RowMapper<User>() {
            public User mapRow(ResultSet resultSet, int rowNum) throws SQLException {
                User user = new User();
                user.setId(resultSet.getInt("id"));
                user.setUsername(resultSet.getString("username"));
                user.setPassword(resultSet.getString("password"));
                return user;
            }
        };
    
        // 插入一条用户数据
        public void addUser(User user) {
            String sql = "INSERT INTO user (username, password) VALUES (?, ?)";
            jdbcTemplate.update(sql, user.getUsername(), user.getPassword());
        }
    
        // 删除一条用户数据
        public void deleteUser(int id) {
            String sql = "DELETE FROM user WHERE id = ?";
            jdbcTemplate.update(sql, id);
        }
    
        // 更新一条用户数据
        public void updateUser(User user) {
            String sql = "UPDATE user SET username = ?, password = ? WHERE id = ?";
            jdbcTemplate.update(sql, user.getUsername(), user.getPassword(), user.getId());
        }
    
        // 查询所有用户数据
        public List<User> findAllUsers() {
            String sql = "SELECT id, username, password FROM user";
            return jdbcTemplate.query(sql, userMapper);
        }
    
        // 根据 ID 查询一条用户数据
        public User findUserById(int id) {
            String sql = "SELECT id, username, password FROM user WHERE id = ?";
            return jdbcTemplate.queryForObject(sql, new Object[]{id}, userMapper);
        }
    }

## 4.JPA ##

### 4.1.概述 ###

JPA（Java persistence api，JAVA持久化API），是一种JSR规范，其定义了Java对象和关系型数据库之间该如何映射，总结起来是：

*  对象关系映射，需要描述好对象中的每个属性和关系型数据中每个字段之间的映射关系。
 *  操作API，需要提供一套基础CRUD的API。
 *  查询语言，需要支持自定义SQL进行比较灵活的查询。

spring boot中对jpa的实现是基于hibernate的，其通过注解来实现对象关系映射、提供了一套基础CRUD的API，然后依托于HQL支持了自定义SQL进行灵活的查询。

### 4.2.基本使用 ###

**依赖：**

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

**对象关系映射：**

@Entity(name="user")
    @Table(name = "user")
    public class User {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private int id;
        @Column(name = "username")
        private String username;
        @Column(name="password")
        private String password;
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    }

**接口：**

这是spring boot jpa的关键，接口继承JpaRepository，定义好实体关系映射和id类型。

import com.eryi.bean.User;
    import org.springframework.data.jpa.repository.JpaRepository;
    import org.springframework.stereotype.Service;
    
    @Service
    public interface UserService extends JpaRepository<User,Integer> {
    }

**使用：**

JpaRepository自带了一套基础CRUD的API，直接调用即可。

@RequestMapping("getUser")
    public User addUser(User user){
           return userService.findById(user.getId()).get();
    }

### 4.3.转换器 ###

有时候数据库里存的字段值不是我们直接想要的，而是需要做一些转换，比如user如果有个性别字段，数据库里可能是用1表示男性，用2表示女性，而我们想要的是男女，Spring Boot Jpa提供了转换器来进行转换。

定义转换器：

public class SexConverter implements AttributeConverter<SexEnum,Integer>{ 
    //将枚举转换为数据库列 
    @Override 
    public Integer convertToDatabaseColumn (SexEnum sex) { return sex.getId () ; 
    
    //将数据库列转换为枚 
    @Override 
    publ ic SexEnum convertToEntityAttrbute (Integer id) { return SexEnum.getEnumByid (id); 
    
    }

在想要进行转换的字段上使用转换器:

public class User{
    @Convert(converter=SexConverter.class)
    private SexEnum sex;
    }

## 5.mybatis ##

mybatis就不赘述了，现在大家最常用的，直接开整！

**依赖：**

<dependency>
       <groupId>org.mybatis</groupId>
       <artifactId>mybatis</artifactId>
       <version>3.5.7</version>
    </dependency>

**配置：**

**实体类：**

public class User {
        private Long id;
        private String username;
        private String password;
        // getter 和 setter 方法省略
    }

**接口：**

@Mapper
    public interface UserDao {
        User getUserById(Long id);
        List<User> getAllUsers();
        void addUser(User user);
        void updateUser(User user);
        void deleteUser(Long id);
    }

**mapper.xml:**

在 src/main/resources/mapper\`目录下创建 UserDao.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.example.demo.dao.UserDao">
    
        <select id="getUserById" parameterType="long" resultType="com.example.demo.entity.User">
            SELECT * FROM user WHERE id = #{id}
        </select>
    
        <select id="getAllUsers" resultType="com.example.demo.entity.User">
            SELECT * FROM user
        </select>
    
        <insert id="addUser" parameterType="com.example.demo.entity.User">
            INSERT INTO user (username, password) VALUES (#{username}, #{password})
        </insert>
    
        <update id="updateUser" parameterType="com.example.demo.entity.User">
            UPDATE user SET username = #{username}, password = #{password} WHERE id = #{id}
        </update>
    
        <delete id="deleteUser" parameterType="long">
            DELETE FROM user WHERE id = #{id}
        </delete>
    </mapper>