01、背景介绍

在之前的文章中，我们简单的介绍了 SpringBoot 项目的创建过程，了解了 Spring Boot 开箱即用的特性，本篇文章接着上篇的内容继续介绍 Spring Boot 用于 web 工程开发时的其它特性。

废话不多说了，上代码！

02、应用实践

当将 SpringBoot 框架用于传统的 web 项目开发时，通常分为以下三个过程来实现。

• 第一步：连接数据库，实现对表进行 CRUD 操作
• 第二步：引入模板引擎来开发页面
• 第三步：使用一些常见的 web 特性来满足其它的功能开发

最后源码目录结构如下！

springboot-hello
├── src
│   └── main
│       ├── java
│          ├── com
│             ├── example
│                ├── springboot
│                   ├── Application.java
│                   ├── entity
│                      ├── User.java
│                   ├── service
│                      ├── UserService.java
│                   ├── web
│                      ├── UserController
│       └── resources
│           ├── application.properties
│           ├── templates
│           └─── index.html
└── pom.xml

下面我们依次来看看相关的实践过程。

2.1、数据库操作

这里我们以 Mysql 数据库为例，采用 Spring 的 JdbcTemplate 模板来操作数据的的增删改查，过程如下。

2.1.1、准备数据库表

先创建tb_user表，包含属性id、name、age，可以通过执行下面的建表语句。

CREATE TABLE `tb_user` (
  `id` bigint(20) unsigned NOT NULL,
  `name` varchar(30) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

2.1.2、添加相关依赖包

在我们访问数据库的时候，需要先配置一个数据库驱动包，通常采用 JDBC 方式方式访问，需要在pom.xml中引入相关依赖包。

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

2.1.3、添加数据源配置

与此同时，还需要在application.properties文件中配置相关的数据源访问地址。

spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

2.1.4、编写领域对象

根据数据库中创建的 User 表，创建对应的领域对象。

package com.example.springboot.entity;

public class User {

    /**
     * 用户ID
     */
    private Long id;

    /**
     * 用户名称
     */
    private String name;

    /**
     * 用户年龄
     */
    private Integer age;

    // set、get方法等...
}

2.1.5、编写数据访问对象

通过JdbcTemplate实现对tb_user表中的数据访问操作。

package com.example.springboot.service;

@Service
public class UserService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    /**
     * 查询用户
     * @return
     */
    public List<User> getAll() {
        List<User> users = jdbcTemplate.query("select id, name, age from tb_user", (resultSet, i) -> {
            User user = new User();
            user.setId(resultSet.getLong("id"));
            user.setName(resultSet.getString("name"));
            user.setAge(resultSet.getInt("age"));
            return user;
        });
        return users;
    }

    /**
     * 通过ID查询用户
     * @param id
     * @return
     */
    public User getById(Long id) {
        User target = jdbcTemplate.queryForObject("select id, name, age from tb_user where id = ?", new BeanPropertyRowMapper<User>(User.class),id);;
        return target;
    }

    /**
     * 创建用户
     * @param entity
     * @return
     */
    public int create(User entity){
        return jdbcTemplate.update("insert into tb_user(id, name, age) values(?, ?, ?)", entity.getId(), entity.getName(), entity.getAge());
    }

    /**
     * 修改用户
     * @param entity
     * @return
     */
    public int updateById(User entity){
        return jdbcTemplate.update("update tb_user set  name = ?, age = ? where id = ? ", entity.getName(), entity.getAge(), entity.getId());
    }


    /**
     * 删除用户
     * @param id
     * @return
     */
    public int deleteById(Long id) {
        return jdbcTemplate.update("delete from tb_user where id = ?", id);
    }
}

2.1.6、编写单元测试用例

在src/test/java目录下，编写单元测试用例，验证代码中的增、删、改、查操作的正确性，包名与主目录中保持一致。

package com.example.springboot;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserServiceTest {

    @Autowired
    private UserService userService;

    @Test
    public void test(){
        // 插入5条数据
        userService.create(new User(1L, "张三", 20));
        userService.create(new User(2L, "李四", 21));
        userService.create(new User(3L, "王五", 22));

        // 查询全部数据
        List<User> dbList1 = userService.getAll();
        System.out.println("第一次全量查询结果：" + dbList1.toString());

        // 修改数据
        userService.updateById(new User(2L, "赵六", 21));

        // 查询指定数据
        User updateObj = userService.getById(2l);
        System.out.println("查询[id=2]结果：" + updateObj.toString());

        // 删除数据
        userService.deleteById(2L);
        userService.deleteById(3L);

        // 查询全部数据
        List<User> dbList2 = userService.getAll();
        System.out.println("第二次全量查询结果：" + dbList2.toString());
    }
}

单元测试，运行后的输出结果：

第一次全量查询结果：[User{id=1, name='张三', age=20}, User{id=2, name='李四', age=21}, User{id=3, name='王五', age=22}]
查询[id=2]结果：User{id=2, name='赵六', age=21}
第二次全量查询结果：[User{id=1, name='张三', age=20}]

此时操作数据库中的表数据，已经正常流通了。

上面介绍的JdbcTemplate只是最基本的几个操作，更多其他数据访问操作的使用可以参考：JdbcTemplate API

2.2、Thymeleaf 模板

在传统的 Java web 工程中，通常会采用 JSP 来编写页面并进行数据展示。而在 Spring Boot 框架中，推荐使用 Thymeleaf 模板引擎来开发 Web 页面。

Thymeleaf 是一款用于渲染 XML/XHTML/HTML5 内容的模板引擎，与 JSP、Velocity、FreeMarker 等类似，都可以轻易的与 Spring MVC 等 Web 框架进行集成作为 Web 应用的模板引擎。

下面我们一起来看下简单的页面集成应用。

2.2.1、添加相关依赖包

在 SpringBoot 项目中使用 Thymeleaf 时，只需要添加所需的模板引擎模块依赖包即可，内容如下。

<!--thymeleaf模板引擎-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

2.2.2、添加相关的配置参数

与此同时，还需要在application.properties文件中配置 thymeleaf 模版扫描路径，比如如下配置。

# thymelea模板配置
spring.thymeleaf.prefix=classpath:/templates/
spring.thymeleaf.suffix=.html
spring.thymeleaf.mode=HTML5
spring.thymeleaf.encoding=UTF-8
spring.thymeleaf.cache=false
spring.thymeleaf.enabled=true

其中spring.thymeleaf.prefix就是模板引擎扫描的路径。

2.2.3、创建页面模板

根据上一步映射的模板路径， 在模板路径
src/main/resources/templates下新建模板文件index.html，内容如下：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Home Page</title>
</head>
<body>
<h1>Hello !</h1>
<table>
    <thead>
    <tr>
        <th>用户ID</td>
        <th>用户名称</td>
        <th>用户年龄</td>
    </tr>
    </thead>
    <tbody>
    <tr th:each="prod:${allUsers}">
        <td th:text="${prod.id}">100</td>
        <td th:text="${prod.name}">张三丰</td>
        <td th:text="${prod.age}">99</td>
    </tr>
    </tbody>
</table>
</body>
</html>

2.2.4、编写页面请求对象

最后编写一个页面请求对象，用来处理路径的请求，将数据渲染到index页面上，具体实现如下：

@Controller
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/")
    public String index(ModelMap map) {
        // 查询所有的用户
        List<User> users =  userService.getAll();
        map.addAttribute("allUsers", users);
        return "index";
    }
}

将上文中的三条数据插入到数据库，以便展示。

2.2.5、测试页面展示情况

最后将服务启动，在浏览器发起请求，地址为http://localhost:8080/，展示结果如下：

说明页面渲染正常，符合预期效果。

更多 Thymeleaf 的页面语法，可以访问 Thymeleaf 的官方文档来深入学习使用。

2.3、web 基本特性

除了以上功能，SpringBoot 还有几个常用特性功能，比如 SpringMVC 中的接口开发、过滤器、拦截器、aop 代理、异常处理等。

下面，我们一起简要的看看相关特性的用法。

2.3.1、接口开发

当与其它项目对接的时候，通常会采用 json 数据格式进行请求和返回，在传统的 SpringMVC 项目中，我们通常需要在每个接口方法上加@ResponseBody注解，以便数据以 json 格式返回给用户。

在 Spring Boot 框架中，我们只需要在接口类上添加@RestController注解，即可实现@Controller和@ResponseBody一样的效果。

示例如下。

@RestController
public class ApiController {

    @Autowired
    private UserService userService;

    @GetMapping("/getUsers")
    public List<User> getUsers() {
        // 查询所有的用户
        System.out.println("收到查询用户的请求");
        List<User> users =  userService.getAll();
        return users;
    }
}

将服务启动，访问
http://localhost:8080/getUsers，看看控制台输出结果。

可以看到，与预期一致。

如果是页面开发，只要使用@Controller注解即可，以免无法渲染数据。

2.3.2、过滤器

过滤器在 web 项目开发过程中经常会用到，比如用于收集调用日志、排除有 XSS 威胁的字符等，过滤器本质不属于 SpringBoot 自带的功能，而是 Servlet 提供的功能，SpringBoot 对此做了集成管理，实现方式也很简单。

首先创建一个过滤器实现类，示例如下。

public class LogFilter implements Filter {


    @Override
    public void init(javax.servlet.FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        System.out.println("日志过滤器，request url :"+request.getRequestURI());
        filterChain.doFilter(servletRequest, servletResponse);
    }

    @Override
    public void destroy() {

    }
}

然后将过滤器注册到 SpringBoot 中，示例如下。

@Configuration
public class FilterConfig {

    /**
     * 添加过滤器
     * @return
     */
    @Bean
    public FilterRegistrationBean helloFilterRegistrationBean() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        registration.setName("logFilter"); // 指定过滤器名称
        registration.setFilter(new LogFilter()); // 指定过滤器实现类
        registration.setUrlPatterns(Collections.singleton("/*"));// 指定拦截路径
        registration.addInitParameter("paramName", "paramValue");// 指定初始化参数
        registration.setOrder(1);// 指定顺序
        return registration;
    }
}

将服务启动，访问
http://localhost:8080/getUsers，看看控制台输出结果。

日志过滤器，request url :/getUsers
收到查询用户的请求

说明过滤器已经正常工作了。

2.3.3、拦截器

拦截器在 web 项目开发过程中也经常会用到，比如用于用户权限的拦截等等。拦截器属于 SpringMVC 自带的功能，因此 SpringBoot 默认就支持，实现方式也很简单。

首先创建一个拦截器实现类，示例如下。

public class SignInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        System.out.println("方法前拦截，request url：" +  request.getRequestURI());
        return HandlerInterceptor.super.preHandle(request, response, handler);
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
                           ModelAndView modelAndView) throws Exception {
        System.out.println("方法中拦截(不能拦截异常)，request url：" +  request.getRequestURI());
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
        System.out.println("方法后拦截(能拦截异常)，request url：" +  request.getRequestURI());
    }
}

然后，将拦截器注册到拦截器链中。

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 将SignInterceptor添加到拦截器链中,并且指定拦截路径和拦截顺序
        registry.addInterceptor(new SignInterceptor()).addPathPatterns("/*").order(1);
    }
}

将服务启动，访问
http://localhost:8080/getUsers，看看控制台输出结果。

方法前拦截，request url：/getUsers
收到查询用户的请求
方法中拦截(不能拦截异常)，request url：/getUsers
方法后拦截(能拦截异常)，request url：/getUsers

可以发现，过滤器的执行顺序在拦截器之前。

其中拦截器中postHandle()和afterCompletion()方法，都可以实现对接口执行后进行拦截，两者不同点在于：

• postHandle()方法无法拦截异常；
• afterCompletion()方法可以拦截异常；

可以新增一个getUsersError()方法，增加运行时异常。

@GetMapping("/getUsersError")
public List<User> getUsersError() {
    // 查询所有的用户
    System.out.println("收到查询用户的请求");
    if(1==1){
        throw new NullPointerException("异常测试");
    }
    List<User> users =  userService.getAll();
    return users;
}

再次请求访问
http://localhost:8080/getUsersError，控制台输出结果如下。

方法前拦截，request url：/getUsersError
收到查询用户的请求
方法后拦截，request url：/getUsersError

当出现异常时，可见postHandle()方法，没有被执行。

2.3.4、aop 代理

aop 动态代理也是 web 项目开发过程中常用的功能特性，熟悉 Spring 的同学可能知道，Spring 的动态代理技术使用了 aspectj 框架的注解来实现切面技术，因此在使用的时候，需要添加相关的依赖包。

首先在pom.xml文件中添加 aspectj 依赖包，示例如下。

<!--添加 aspectj 依赖包 -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
</dependency>

编写动态代理类，代理
com.example.springboot.web包下所有类的public方法。

@Order(1)
@Component
@Aspect
public class ControllerAspect {

    /***
     * 定义切入点
     */
    @Pointcut("execution(public * com.example.springboot.web..*.*(..))")
    public void methodAdvice(){}

    /**
     * 方法调用前通知
     */
    @Before(value = "methodAdvice()")
    public void before(JoinPoint joinPoint){
        System.out.println("代理-> 来自Before通知，方法名称：" +  joinPoint.getSignature().getName());
    }

    /**
     * 方法调用后通知
     */
    @After(value = "methodAdvice()")
    public void after(JoinPoint joinPoint){
        System.out.println("代理-> 来自After通知，方法名称：" +  joinPoint.getSignature().getName());
    }

    /**
     * 方法调用后通知，方法正常执行后，有返回值，会通知；如果抛异常，不会通知
     */
    @AfterReturning(value = "methodAdvice()", returning = "returnVal")
    public void afterReturning(JoinPoint joinPoint,Object returnVal){
        System.out.println("代理-> 来自AfterReturning通知，方法名称：" +  joinPoint.getSignature().getName() + ",返回值：" + returnVal.toString());
    }

    /**
     * 方法环绕通知
     */
    @Around(value = "methodAdvice()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("代理-> 来自Around环绕前置通知，方法名称：" +  joinPoint.getSignature().getName());
        Object returnValue = joinPoint.proceed();
        System.out.println("代理-> 来自Around环绕后置通知，方法名称：" +  joinPoint.getSignature().getName());
        return returnValue;
    }


    /**
     * 抛出异常通知
     */
    @AfterThrowing(value = "methodAdvice()", throwing = "ex")
    public void afterThrowing(JoinPoint joinPoint, Exception ex) {
        System.out.println("代理-> 来自AfterThrowing通知，方法名称:" +  joinPoint.getSignature().getName() + "，错误信息："   + ex.getMessage());
    }
}

将服务启动，访问
http://localhost:8080/getUsers，控制台输出结果如下。

代理-> 来自Around环绕前置通知，方法名称：getUsers
代理-> 来自Before通知，方法名称：getUsers
收到查询用户的请求
代理-> 来自Around环绕后置通知，方法名称：getUsers
代理-> 来自After通知，方法名称：getUsers
代理-> 来自AfterReturning通知，方法名称：getUsers,返回值：[User{id=1, name='张三', age=20}, User{id=2, name='李四', age=21}, User{id=3, name='王五', age=22}]

访问
http://localhost:8080/getUsersError，控制台输出结果如下。

代理-> 来自Around环绕前置通知，方法名称：getUsersError
代理-> 来自Before通知，方法名称：getUsersError
收到查询用户的请求
代理-> 来自After通知，方法名称：getUsersError
代理-> 来自AfterThrowing通知，方法名称:getUsersError，错误信息：异常测试

可以很清晰的看到，当出现异常时AfterReturning()通知方法和Around环绕后置通知方法都不会执行，异常信息会进入到AfterThrowing() 通知方法中。

2.3.5、异常处理

Spring Boot 对异常处理也做了很多的支持，开发者可以通过@ExceptionHandler注解来全局代理异常信息，实现方式也很简单。

编写一个全局异常处理类，示例如下。

@ControllerAdvice
public class GlobalExceptionHandler {

    /**
     * 处理Exception异常
     * @param ex
     * @return
     */
    @ExceptionHandler(value = Exception.class)
    @ResponseBody
    public Map exceptionHandler(Exception ex){
        Map<String,Object> errorMap = new HashMap<>();
        errorMap.put("code","500");
        errorMap.put("message",ex.getMessage());
        return errorMap;
    }
}

将服务启动，访问
http://localhost:8080/getUsersError，控制台输出结果如下。

可以看到，异常请求被成功接管。

03、小结

本文主要围绕利用 SpringBoot 框架技术，开发一个传统的 web 项目时需要用到的技术点进行一次简单的知识总结，内容难免有所遗漏，如果有描述不对的地方，欢迎留言指出！

可能有的同学会提出这样的疑问，对于 web 特性中的过滤器、拦截器、aop 代理，如果目标的都是同一个方法，他们的执行顺序怎样的？

在实测过程中，从日志打印来看，执行顺序是过滤器 > 拦截器 > aop 代理，如果有多个相同类型的拦截器，依照顺序依次拦截。