Spring Boot 整合 MyBatis 快速搭建 Web 开发环境

最新推荐文章于 2023-04-24 21:53:21 发布

只是曾路过

最新推荐文章于 2023-04-24 21:53:21 发布

阅读量809

点赞数 1

分类专栏： Spring Boot 文章标签： spring boot mybatis maven java 后端

本文链接：https://blog.csdn.net/qq_45716120/article/details/113246232

版权

Spring Boot 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

文章目录

一、整合 Mybatis，搭建 Web 环境
二、配置数据库连接池 Druid

在 SSM 中，各种框架的整合要写繁琐的 XML 配置文件。但如果使用 Spring Boot ，很快就能够搭建一个三层架构的 Web 环境。简而言之，使用 Spring Boot 构建服务端，能够快速开发出 http 接口。

一、整合 Mybatis，搭建 Web 环境

1、创建数据库表

创建数据库 springboot-data，学生表 student：

drop database if exists `springboot-data`;
create database `springboot-data`;
use `springboot-data`;

drop table if exists `student`;
create table `student`
(
   `id`                   int(10) not null auto_increment,
   `name`                 varchar(20) not null,
   `pwd`                  varchar(20) not null,
   primary key (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;

insert into `student` (`name`,`pwd`)
values 
('小明','123456'),
('小华','234567'),
('小红','345678');

2、导入相关依赖

要整合 Mybatis，需要添加如下依赖：

spring-boot-starter-jdbc
mysql-connector-java
mybatis-spring-boot-starter

Maven 如下：

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jdbc</artifactId>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>2.1.1</version>
		</dependency>

3、创建项目的包和目录

在搭建 web 环境前，我们首先新建如下目录：

controller
mapper
pojo
service
resources / mapper
resources / application.yaml

项目结构如下：
在这里插入图片描述

4、配置数据库连接

无论持久层采用什么框架，既然要连接数据库，那么参数都是必须要配置的
在 application.yaml 中添加jdbc 与 mybatis 的相关配置：

spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/springboot-data?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
    driver-class-name: com.mysql.cj.jdbc.Driver

mybatis:
  type-aliases-package: com.study.pojo
  mapper-locations: classpath:mapper/*.xml

type-aliases-package 指定扫描我们的 pojo 包，开启别名映射（通过类名首字母小写即可指定实体类型），简化 mybatis 中 xml 的 resultType 的书写
mapper-locations 指定 mybatis 中 xml 存放的位置；其中的 classpath 表示映射到 resources 目录下

5、实现 pojo 层

在 pojo 目录下创建 student 实体类：

public class Student {
    private int id;
    private String name;
    private String pwd;
    // 补充 getter/setter 等

6、实现 mapper / dao 层

在上方的 mapper 目录下创建 StudentMapper 接口，添加 @Repository 与 @Mapper 注解，在其中定义 CRUD 方法：

@Repository
@Mapper
public interface StudentMapper {

    List<Student> queryStudentList();

    Student queryStudentById(int id);

    int addStudent(Student user);

    int updateStudent(Student user);

    int deleteStudent(int id);
    
}

@Repository 注解用于将该 Mapper 添加到 Spring IOC 容器中，功能与 @Components 注解一样
@Mapper 注解表明该接口是一个 Mapper，会被自动扫描到

在下方的 resources / mapper 目录下创建 StudentMapper.xml，在其中实现 StudentMapper 接口定义的方法：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.study.mapper.StudentMapper">

    <select id="queryStudentList" resultType="student">
        select * from student;
    </select>

    <select id="queryStudentById" resultType="student">
        select * from student where id = #{id};
    </select>

    <insert id="addStudent" parameterType="student">
        insert into student (id,name,pwd) values (#{id},#{name},#{pwd})
    </insert>

    <update id="updateStudent" parameterType="student">
        update student set name=#{name}, pwd=#{pwd} where id=#{id}
    </update>

    <delete id="deleteStudent">
        delete from student where id = #{id}
    </delete>
    
</mapper>

7、实现 service 层

在 service 目录下新建 StudentService 接口，定义业务方法（这里简单地调用 mapper 层实现 CRUD）：

public interface StudentService {
    
    List<Student> queryStudentList();

    Student queryStudentById(int id);

    int addStudent(Student student);

    int updateStudent(Student student);

    int deleteStudent(int id);
    
}

在 impl 目录下新建 StudentServiceImpl 实现类，添加 @Service 注解，并在其中自动装配 StudentMaper，相关代码如下：

@Service
public class StudentServiceImpl implements StudentService {

    @Autowired
    private StudentMapper studentMapper;

    @Override
    public List<Student> queryStudentList() {
        return studentMapper.queryStudentList();
    }

    @Override
    public Student queryStudentById(int id) {
        return studentMapper.queryStudentById(id);
    }

    @Override
    public int addStudent(Student student) {
        return studentMapper.addStudent(student);
    }

    @Override
    public int updateStudent(Student student) {
        return studentMapper.updateStudent(student);
    }

    @Override
    public int deleteStudent(int id) {
        return studentMapper.deleteStudent(id);
    }

}

@Service 注解用于将该 Service 添加到 Spring IOC 容器中，功能与 @Components 注解一样

8、实现 controller 层

在 controller 目录下新建 StudentController，添加 @RestController 以及 @RequestMapping 注解，在其中自动装配 StudentService，调用 service 层的 CRUD 方法，完整代码如下：

@RestController
@RequestMapping("/students")
public class StudentController {

    @Autowired
    private StudentService studentService;

    @GetMapping("/list")
    public List<Student> queryStudentList() {
        List<Student> students = studentService.queryStudentList();
        return students;
    }

    @GetMapping("/add")
    public List<Student> addStudent() {
        Student student = new Student(4,"小强", "456789");
        int i = studentService.addStudent(student);
        return queryStudentList();
    }

    @GetMapping("/update")
    public List<Student> updateStudent() {
        Student student = new Student(4,"小强222", "456789");
        int i = studentService.updateStudent(student);
        return queryStudentList();
    }

    @GetMapping("/delete/{id}")
    public List<Student> deleteStudent(@PathVariable("id") int id) {
        int i = studentService.deleteStudent(4);
        return queryStudentList();
    }

}

@RestController 注解表明该类是一个控制器类，且只返回 JSON 数据，不进行视图跳转，其作用相当于 @Controller 加 @ResponseBody 注解

9、测试 CRUD

1、启动项目，在浏览器地址栏中输入：http://localhost:8080/students/list
在这里插入图片描述
服务端返回了包含所有记录的 JSON 数据，查询正确

2、在浏览器地址栏中输入：http://localhost:8080/students/add
在这里插入图片描述
新增了一条记录，添加成功

3、在浏览器地址栏中输入：http://localhost:8080/students/update
在这里插入图片描述
name 发生了变化，修改成功

4、在浏览器地址栏中输入：http://localhost:8080/students/delete/4
在这里插入图片描述
第 4 条记录被删除，删除成功

此时，我们的 Web 环境已经搭建完毕并且测试通过，剩下的就是具体的业务实现了

二、配置数据库连接池 Druid

我们需要在原来的基础之上，再添加以下两个依赖：

druid：用于配置 Druid
log4j：用于日志监控

Maven 如下：

		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.1.21</version>
		</dependency>
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>1.2.17</version>
		</dependency>

修改 application.yaml，在其中添加 druid 的相关配置：首先要通过 type 指定 druid 作为数据源，然后下方再具体配置 druid 数据源的相关参数以及开启日志监控等功能

spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/springboot-data?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
    driver-class-name: com.mysql.cj.jdbc.Driver
    # 指定类型为 Druid
    type: com.alibaba.druid.pool.DruidDataSource

    # 自己绑定 druid 数据源专有配置
    initialSize: 5
    minIdle: 5
    maxActive: 20
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true

    # 配置监控统计拦截的 filters 
    # stat：监控统计、log4j：日志记录  wall：防止 sql 注入
    filters: stat,wall,log4j
    maxPoolPreparedStatementPerConnectionSize: 20
    userGlobalDataSourceStat: true
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

mybatis:
  type-aliases-package: com.study.pojo
  mapper-locations: classpath:mapper/*.xml

配置文件写好后，再定义一个 DruidConfig 类，通过 @Configuration 注解表明其是一个配置类，然后通过@ConfigurationProperties 将配置文件的相关参数注入到数据源 DataSource 中，最后添加日志监控后台的账号密码以及过滤器

@Configuration
public class DruidConfig {

    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druidDateSource() {
        return new DruidDataSource();
    }

    // 后台监控
    @Bean
    public ServletRegistrationBean statViewServlet() {
        ServletRegistrationBean<StatViewServlet> bean = new ServletRegistrationBean<>(new StatViewServlet(),"/druid/*");
        // 设置日志监控后台的账号、密码
        HashMap<String,String> initParameters = new HashMap<>();
        initParameters.put("loginUsername","admin");
        initParameters.put("loginPassword","123456");
        // 允许所有人访问
        initParameters.put("allow","");
        bean.setInitParameters(initParameters);
        return bean;
    }

    // fileter
    @Bean
    public FilterRegistrationBean webStatFilter() {
        FilterRegistrationBean bean = new FilterRegistrationBean();
        bean.setFilter(new WebStatFilter());
        Map<String,String> initParameters = new HashMap<>();
        // 过滤请求
        initParameters.put("exclusions","*.js,*.css,/druid/*");
        bean.setInitParameters(initParameters);
        return bean;
    }

}

启动项目，在浏览器地址栏中输入：http://localhost:8080/druid，此时会进入到后台日志监控的登录界面：
在这里插入图片描述
输入上面我们配置的账号密码（admin, 123456），即可登录到日志监控界面：

在这里插入图片描述
点击 SQL 监控，然后在浏览器地址栏发起一个请求：http://localhost:8080/students/list，即可看到 SQL 的执行记录
由于 /students/list 请求返回的是所有数据，所以下方显示的 SQL 是 select * from student

以上就是 Druid 数据源的基本配置与使用。可以看到，通过简单的配置，便能够实现数据库后台的日志监控，说明其功能还是十分强大的。