别人都在这个春暖花开的端午节吃粽子，而我在踏青学springboot数据持久化

?? s p r i n g b o o t 中 如 何 数 据 持 久 化 extcolor{Orange}{springboot中如何数据持久化} springboot中如何数据持久化
?? 学 习 过 程 中 的 笔 记 ， 方 便 查 阅 学 习 extcolor{green}{学习过程中的笔记，方便查阅学习} 学习过程中的笔记，方便查阅学习??
?? 循 序 渐 进 ， 从 J D B C 到 D r u i d 再 到 M y b a t i s extcolor{green}{循序渐进，从JDBC到Druid再到Mybatis} 循序渐进，从JDBC到Druid再到Mybatis??
欢迎各位小伙伴??关注??点赞收藏??留言

springboot中如何数据持久化

• • 整合JDBC
  • • 1.初始化项目
    • 2.配置连接数据库
    • • 排错：
    • 3.JDBCTemplate
    • 4.测试增删改查
    • • 查：
      • 增：
      • 改：
      • 删：
      • 源代码：
  • 整合Druid
  • • 简介
    • 配置数据源
  • 整合Mybatis

整合JDBC

1.初始化项目

之前也有讲过，只不过这里主要添加的东西不同。

注意这里如果不勾选数据库驱动的话是连接不上数据库的。最后next->finish

之后我们会看到项目导入了启动器

<!--JDBC-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!--Mysql-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>
1
2
3
4
5
6
7
8
9
10
11

2.配置连接数据库

新建一个application.yaml在这里配置数据库连接

spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/jdbc?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver
1
2
3
4
5
6

配置完之后我们就可以使用了，首先我们先测试一下

@SpringBootTest
class Springboot04DataApplicationTests {

    @Autowired
    DataSource dataSource;

    @Test
    void contextLoads() throws SQLException {
        //查看数据源
        System.out.println(dataSource.getClass());
        //获得数据库连接
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        //关闭连接
        connection.close();
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

可以看到我们的结果为com.zaxxer.hikari.HikariDataSource。

数据源的所有自动配置都在 ：DataSourceAutoConfiguration文件，可以全局搜索查看

排错：

java.sql.SQLException: Access denied for user ‘***’@‘localhost’ (using password: YES)

注意查看自己用户名密码是否一样。注意使用yaml文件时把properties文件删除，不删除同时properties中也有关于数据库的设置，也会报上述的错误。这是因为springboot它首先回去查看properties的配置文件

3.JDBCTemplate

1、有了数据源(com.zaxxer.hikari.HikariDataSource)，然后可以拿到数据库连接(java.sql.Connection)，有了连接，就可以使用原生的 JDBC 语句来操作数据库；

2、即使不使用第三方第数据库操作框架，如 MyBatis等，Spring 本身也对原生的JDBC 做了轻量级的封装，即JdbcTemplate。

3、数据库操作的所有 CRUD 方法都在 JdbcTemplate 中。

4、Spring Boot 不仅提供了默认的数据源，同时默认已经配置好了 JdbcTemplate 放在了容器中，程序员只需自己注入即可使用

5、JdbcTemplate 的自动配置是依赖 org.springframework.boot.autoconfigure.jdbc 包下的 JdbcTemplateConfiguration 类

JdbcTemplate主要提供以下几类方法：

• execute方法：可以用于执行任何SQL语句，一般用于执行DDL语句；
• update方法及batchUpdate方法：update方法用于执行新增、修改、删除等语句；batchUpdate方法用于执行批处理相关语句；
• query方法及queryForXXX方法：用于执行查询相关语句；
• call方法：用于执行存储过程、函数相关语句。

4.测试增删改查

我们可以通过编写controller，注入jdbcTemplate

查：

编写过程中一定要和数据库对应。

增：

执行前：

执行后：

改：

执行前：

执行后：

删：

执行后：

源代码：

导web

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


package com.hxl.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;
import java.util.Map;

@RestController
public class JdbcController {
    /**
     * Spring Boot 默认提供了数据源，默认提供了 org.springframework.jdbc.core.JdbcTemplate
     * JdbcTemplate 中会自己注入数据源，用于简化 JDBC操作
     * 还能避免一些常见的错误,使用起来也不用再自己来关闭数据库连接
     */
    @Autowired
    JdbcTemplate jdbcTemplate;

    //查询数据库的所有信息
    //没有创建实体类，那么数据库中的东西怎么获取呢，使用Map
    @GetMapping("/userList")
    public List<Map<String,Object>> userList(){
        String sql = "select * from users";
        List<Map<String,Object>> list_maps = jdbcTemplate.queryForList(sql);
        return list_maps;
    }

    @GetMapping("/addUser")
    public String addUser(){
        String sql = "insert into users(id,name,password,email,birthday) values(3,'老三', '123456', '3.qq.com','2020-02-09')";
        jdbcTemplate.update(sql);
        return "add-ok";
    }

    @GetMapping("/updateUser/{id}")
    public String updateUser(@PathVariable("id") int id){
        String sql = "update users set name=?,password=? where id=" + id;
        //封装
        Object[] objects = new Object[2];
        objects[0] = "更新者";
        objects[1] = "1234";
        jdbcTemplate.update(sql,objects);
        return "update-ok";
    }

    @GetMapping("/deleteUser/{id}")
    public String deleteUser(@PathVariable("id") int id){
        String sql = "delete from users where id = ?";
        jdbcTemplate.update(sql,id);
        return "deleteUser-ok";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

整合Druid

简介

Druid是Java语言中最好的数据库连接池。Druid能够提供强大的监控和扩展功能。

Java程序很大一部分要操作数据库，为了提高性能操作数据库的时候，又不得不使用数据库连接池。

Druid 是阿里巴巴开源平台上一个数据库连接池实现，结合了 C3P0、DBCP 等 DB 池的优点，同时加入了日志监控。

Druid 可以很好的监控 DB 池连接和 SQL 的执行情况，天生就是针对监控而生的 DB 连接池。

Spring Boot 2.0 以上默认使用 Hikari 数据源， Hikari 与 Driud 都是当前 Java Web 上最优秀的数据源，

Github地址：https://github.com/alibaba/druid/

配置数据源

1.添加依赖

maven仓库https://mvnrepository.com/artifact/com.alibaba/druid

<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.8</version>
</dependency>
1
2
3
4
5
6

2.自定义数据源

在前面我们通过查看数据源dataSource知道我们默认的数据源是com.zaxxer.hikari.HikariDataSource。现在就不使用默认的，通过spring.datasource.type 指定数据源

spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/jdbc?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
1
2
3
4
5
6
7

3.看到是否成功

我们在测试类中注入 DataSource，查看数据源

@SpringBootTest
class Springboot04DataApplicationTests {

    @Autowired
    DataSource dataSource;

    @Test
    void contextLoads() throws SQLException {
        //查看数据源
        System.out.println(dataSource.getClass());
        //获得数据库连接
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        //关闭连接
        connection.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4.成功后就可以初始化

比如说设置，连接初始化大小、最大连接数、等待时间、最小连接数等。

5.这里使用了log4j

所以要先导入依赖

<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>
1
2
3
4
5
6

6.配置Druid数据源监控

Druid 数据源具有监控的功能，并提供了一个 web 界面方便用户查看，类似安装 路由器 时，人家也提供了一个默认的 web 页面。

新建DruidConfig

通过绑定，可以使用配置文件里面的设置。

配置的属性，注入到容器中，首先要注册bean，再加上@ConfigurationProperties注解表示绑定成功

接下来注册Bean

package com.hxl.config;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;
import java.util.HashMap;

@Configuration
public class DruidConfig {
    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druidDataSource(){
        return new DruidDataSource();
    }

    //后台监控web.xml，ServletRegistrationBean
    //配置 Druid 监控管理后台的Servlet；
    //springboot内置Servlet容器，所以没有web.xml文件，故使用Spring Boot的注册Servlet方式ServletRegistrationBean
    @Bean
    public ServletRegistrationBean statViewServlet(){
        ServletRegistrationBean<StatViewServlet> bean = new ServletRegistrationBean<>(new StatViewServlet(),"/druid/*");
        //后台需要有人登录，账号密码配置
        HashMap<String, String> initParameters = new HashMap<>();
        //增加配置
        //这些参数可以在 com.alibaba.druid.support.http.StatViewServlet的父类 com.alibaba.druid.support.http.ResourceServlet 中找到
        initParameters.put("loginUsername","admin");
        initParameters.put("loginPassword","123456");
        //允许谁可以访问
        //后面为空说明所有人都可以访问，有值的话就是指定的人可以访问
        initParameters.put("allow","");
        //initParams.put("allow", "localhost")：表示只有本机可以访问
        //禁止谁访问; initParameters.put("wangmm","192.168.X.X");
        bean.setInitParameters(initParameters);//设置初始化参数
        return bean;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

配置完毕后，我们可以选择访问 ：http://localhost:8080/druid/login.html

登录成功之后就可以查看了

7.配置Druid web监控filter过滤器

根据需求进行配置。

@Bean
public FilterRegistrationBean webStatFilter(){
    FilterRegistrationBean<Filter> bean = new FilterRegistrationBean<>();
    bean.setFilter(new WebStatFilter());
    //可以过滤的请求
    //exclusions：设置哪些请求进行过滤排除掉，从而不进行统计
    Map<String, String> initParameters = new HashMap<>();
    initParameters.put("exclusions", "*.js,*.css,/druid/*,/jdbc/*");
    bean.setInitParameters(initParameters);

    //"/*" 表示过滤所有请求
    bean.setUrlPatterns(Arrays.asList("/*"));
    return bean;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

整合Mybatis

创建新的项目，同时将这几个依赖选中。

1.导入依赖

需要去maven仓库导入Mybatis所需要的依赖。

<!-- https://mvnrepository.com/artifact/org.mybatis.spring.boot/mybatis-spring-boot-starter -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.2.1</version>
</dependency>
1
2
3
4
5
6

2.配置数据库信息

这里使用了基础的数据库连接信息，当然也可以加上前面的Druid

spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/jdbc?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
    driver-class-name: com.mysql.cj.jdbc.Driver
1
2
3
4
5
6

3.测试数据库是否连接成功

package com.hxl;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import javax.sql.DataSource;
import java.sql.SQLException;

@SpringBootTest
class SpringbootMybatisApplicationTests {

    @Autowired
    DataSource dataSource;

    @Test
    void contextLoads() throws SQLException {
        System.out.println(dataSource.getClass());
        System.out.println(dataSource.getConnection());
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

不爆红，有输出数据库信息就是连接成功了

4.导入Lombok

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>
1
2
3
4

5.创建实体类

创建pojo目录以及User.java

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.sql.Date;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    private String name;
    private String password;
    private String email;
    private Date birthday;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

6.创建mapper目录以及对应的 Mapper 接口

package com.hxl.mapper;

import com.hxl.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;

//这个注解表示本类是一个mybatis的mapper类
@Mapper
@Repository //注解是将接口的一个实现类交给spring管理。
public interface UserMapper {
    //获得所有用户信息
    List<User> queryUserList();
    //通过id获得用户信息
    User queryUserById(int id);
    int addUser(User user);
    int updateUser(User user);
    int deleteUser(int id);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

7.创建对应的Mapper映射文件

在resources目录下创建mybatis在其下再创建mapper再创建UserMapper.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.hxl.mapper.UserMapper">
    <select id="queryUserList" resultType="User">
       select * from users;
    </select>

    <select id="queryUserById" resultType="User">
       select * from users where id = #{id};
    </select>

    <insert id="addUser" parameterType="User">
        insert into users(id,name,password,email,birthday) values(#{id},#{name},#{password}.#{email},#{data})
    </insert>

    <update id="updateUser" parameterType="User">
        update users set name=#{name},password=#{password} where id=#{id}
    </update>

    <delete id="deleteUser" parameterType="int">
        delete from users where id = #{id}
    </delete>
</mapper>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

8.整合mybatis

在application.yaml下添加

# 整合mybatis
mybatis:
  type-aliases-package: com.hxl.pojo
  mapper-locations: classpath:mybatis/mapper/*.xml
1
2
3
4

9.资源过滤

maven中配置资源有可能存在资源过滤层问题。所以在pom.xml需要加入

<resources>
    <resource>
        <directory>src/main/java</directory>
        <includes>
            <include>**/*.xml</include>
        </includes>
        <filtering>true</filtering>
    </resource>
</resources>
1
2
3
4
5
6
7
8
9

10.编写Controller

package com.hxl.controller;

import com.hxl.mapper.UserMapper;
import com.hxl.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class UserController {
    @Autowired
    private UserMapper userMapper;

    @GetMapping("/queryUserList")
    public List<User> queryUserList(){
        List<User> userList = userMapper.queryUserList();
        for (User user : userList) {
            System.out.println(user);
        }
        return userList;
    }
    @GetMapping("/queryUserById/{id}")
    public User queryUserById(@PathVariable("id")int id){
        User user = userMapper.queryUserById(id);
        return user;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

11.测试

输入http://localhost:8080/queryUserList

输入http://localhost:8080/queryUserById/1