SpringBoot 开发 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中引入相关依赖包。



    org.springframework.boot
    spring-boot-starter-jdbc



    mysql
    mysql-connector-java

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 {

    
    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;

    
    public List getAll() {
        List 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;
    }

    
    public User getById(Long id) {
        User target = jdbcTemplate.queryForObject("select id, name, age from tb_user where id = ?", new BeanPropertyRowMapper(User.class),id);;
        return target;
    }

    
    public int create(User entity){
        return jdbcTemplate.update("insert into tb_user(id, name, age) values(?, ?, ?)", entity.getId(), entity.getName(), entity.getAge());
    }

    
    public int updateById(User entity){
        return jdbcTemplate.update("update tb_user set  name = ?, age = ? where id = ? ", entity.getName(), entity.getAge(), entity.getId());
    }


    
    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 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 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 时，只需要添加所需的模板引擎模块依赖包即可，内容如下。



    org.springframework.boot
    spring-boot-starter-thymeleaf

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，内容如下：

用户ID	用户名称	用户年龄
100	张三丰	99

2.2.4、编写页面请求对象

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

@Controller
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/")
    public String index(ModelMap map) {
        // 查询所有的用户
        List 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 getUsers() {
        // 查询所有的用户
        System.out.println("收到查询用户的请求");
        List 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 {

    
    @Bean
    public FilterRegistrationBean helloFilterRegistrationBean() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        registration.setName("logFilter"); // 指定过滤器名称
        registration.setFilter(new LogFilter()); // 指定过滤器实现类
        registration.setUrlPatterns(Collections.singleton("
    @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 {

    
    @ExceptionHandler(value = Exception.class)
    @ResponseBody
    public Map exceptionHandler(Exception ex){
        Map errorMap = new HashMap<>();
        errorMap.put("code","500");
        errorMap.put("message",ex.getMessage());
        return errorMap;
    }
}

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

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