SpringBoot——整合SpringMVC、整合连接池、整合MyBatis、整合事务（四）

一、整合SpringMVC

1.创建普通Maven工程后，以spring父工程为父工程，引入需要的启动器

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

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

2.创建application.properties配置文件，添加配置或者覆盖默认配置，例如改端口号为8888

3.创建UserApplication引导类
4.创建UserController控制层代码

5.启动服务器测试

6.创建static静态文件目录

7.创建拦截器

package com.beizhen.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @author : Bei-Zhen
 * @date : 2021-01-31 20:26
 */
@Component
public class MyInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("前置方法正在执行！");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("后置方法正在执行！");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("完成方法正在执行！");
    }
}

8.配置拦截器

package com.beizhen.config;

import com.beizhen.interceptor.MyInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * 配置拦截器
 * 1.声明该类是一个java配置类
 * 2.实现WebMvcConfiguration接口
 * @author : Bei-Zhen
 * @date : 2021-01-31 20:36
 */
@Configuration
public class WebMvcConfiguration implements WebMvcConfigurer {

    @Autowired
    private MyInterceptor myInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(myInterceptor).addPathPatterns("/**");
    }
}

9.springboot默认是显示info以上的日志，我们需要进行配置

# 设置org.springframework包的日志级别为debug
logging.level.org.springframework=debug

10.进行日志和拦截器测试，此时整合SpringMVC成功

二、整合连接池

1.引入jdbc启动器和mysql驱动

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

2.SpringBoot已经自动帮我们引入了一个连接池HikariCP
HikariCP应该是目前速度最快的连接池了，我们看看它与c3p0的对比：

3.配置连接池参数

# 连接池四大参数(driverClassName可省略，SpringBoot默认为MySQL)
spring.datasource.url=jdbc:mysql:///test
spring.datasource.username=root
spring.datasource.password=root

spring.datasource.hikari.idle-timeout=60000
spring.datasource.hikari.maximum-pool-size=30
spring.datasource.hikari.minimum-idle=10

三、整合MyBatis

1.引入MyBatis启动器

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

2.配置文件

# mybatis 别名扫描
mybatis.type-aliases-package=cn.beizhen.pojo
# mapper.xml文件位置,如果没有映射文件，请注释掉
#mybatis.mapper-locations=classpath:mappers/*.xml

3.需要注意，这里没有配置mapper接口扫描包，因此我们需要给每一个Mapper接口添加@Mapper注解，才能被识别，通用Mapper的作者也为自己的插件编写了启动器，我们直接引入即可

<!-- 通用mapper -->
<dependency>
    <groupId>tk.mybatis</groupId>
    <artifactId>mapper-spring-boot-starter</artifactId>
    <version>2.0.2</version>
</dependency>

4.创建User实体类

package com.beizhen.pojo;

import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import java.sql.Date;

/**
 * @author : Bei-Zhen
 * @date : 2021-01-31 21:15
 */
@Table(name = "tb_user")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String userName;

    private String password;

    private String name;

    private Integer age;

    private Integer sex;

    private Date birthday;

    private Date created;

    private Date updated;

    public Long getId() {
        return id;
    }

    public void setId(Long 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;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Integer getSex() {
        return sex;
    }

    public void setSex(Integer sex) {
        this.sex = sex;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public Date getCreated() {
        return created;
    }

    public void setCreated(Date created) {
        this.created = created;
    }

    public Date getUpdated() {
        return updated;
    }

    public void setUpdated(Date updated) {
        this.updated = updated;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                ", birthday=" + birthday +
                ", created=" + created +
                ", updated=" + updated +
                '}';
    }
}

5.创建UserMapper接口

package com.beizhen.mapper;

import com.beizhen.pojo.User;
import org.apache.ibatis.annotations.Mapper;

/**
 * @author : Bei-Zhen
 * @date : 2021-01-31 21:21
 */
@Mapper
public interface UserMapper extends tk.mybatis.mapper.common.Mapper<User> {
}

四、整合事务

其实，我们引入jdbc或者web的启动器，就已经引入事务相关的依赖及默认配置了

SpringBoot中通过注解来控制。就是我们熟知的@Transactional

package com.beizhen.service;

import com.beizhen.mapper.UserMapper;
import com.beizhen.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 * @author : Bei-Zhen
 * @date : 2021-01-31 21:33
 */
@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public User queryUserById(long id){
        return this.userMapper.selectByPrimaryKey(id);
    }

    @Transactional
    public void deleteUserById(Long id){
        this.userMapper.deleteByPrimaryKey(id);
    }
}

五、测试

在UserController中添加测试方法

@Autowired
    private UserService userService;

    @GetMapping("{id}")
    @ResponseBody
    public User queryUserById(@PathVariable("id")Long id){
        return this.userService.queryUserById(id);
    }

整合成功效果！

六、SpringBoot实战总结

1.整合springMVC

1.修改端口(server.port=8888)
2.访问静态资源(classpath:META/resources classpath:resources classpath:static classpath:public)
3.拦截器:
1)自定义拦截器:实现HandlerInterceptor接口
2）配置拦截器:自定义一个java配置类(@Configuration)，实现webMvcConfigurer接口

2.整合数据源

1.引入jdbc启动器mysql驱动
2.添加配置: spring.dataSource.url username password

3.整合mybatis

1.引入启动器
2.覆盖默认配置: mybatis.type-aliases-package=cn.beizhen.pojo mybatis.mapper-locations=classpath:mybatis/mappers/**/*. xm1
3.代码:定义一个接口，在接口上添加@Mapper注解

4.整合通用mapper

1.引入启动器
2.代码:接口继承Mapper<User>

5.整合事务

添加@Transactional