阿里老司机带你使用Spring框架快速搭建Web工程项目

PPT下载地址：https://yq.aliyun.com/download/2661

首先，示例工程使用Maven管理，这里首先定义了Spring Boot的依赖。Spring Boot是集成了Spring框架的开发套件，它将帮助开发者更快地开发Spring Web的应用。同时在依赖中还可以看到Web依赖、AOP依赖以及模板引擎Thymeleaf的依赖。工程的POM文件如下所示：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>java.alibaba</groupId>
    <artifactId>spring-boot-web-demo</artifactId>
    <version>1.0-SNAPSHOT</version>


    <dependencies>

        <!-- Spring boot 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.0.1.RELEASE</version>
        </dependency>


        <!-- Web 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.0.1.RELEASE</version>
        </dependency>

        <!-- AOP 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
            <version>2.0.1.RELEASE</version>
        </dependency>

        <!-- 模板引擎 Thymeleaf 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
            <version>2.0.1.RELEASE</version>
        </dependency>
    </dependencies>

</project>

package demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * Spring boot 启动类
 *
 * @author yushan.ldq
 * @date 2018/04/22
 */
@SpringBootApplication()
public class WebApplication {
    public static void main(String[] args) {
        SpringApplication.run(WebApplication.class, args);
    }
}

如下代码所示的是UserController类，在其上面可以看到@Controller的注解，因为这个注解，UserController的信息将被注入到IOC容器中。在UserController中可以看到UserService的一个成员变量，这个成员变量在整个UserController并没有得到初始化。因为有一个@Autowired注解，这个UserController就可以在初始化之后会产生由于@Autowired注解声明的依赖，这个依赖将由IOC容器负责注入。其所注入的是UserService接口的实现。

UserController类：

package demo.controller;

import demo.model.User;
import demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

/**
 *
 * @author yushan.ldq
 * @date 2018/04/22
 */
@Controller
@RequestMapping(value = "/users")
public class UserController {

    @Autowired
    @Qualifier("userServiceImpl")
    private UserService userService;

    @RequestMapping(method = RequestMethod.GET)
    public String getUsersPage(ModelMap modelMap) {
        modelMap.addAttribute("userList", userService.findAll());
        return "users";
    }

    @RequestMapping(value = "/add", method = RequestMethod.GET)
    public String createUserPage(ModelMap modelMap) {
        modelMap.addAttribute("user", new User());
        return "userCreate";
    }

    @RequestMapping(method = RequestMethod.POST)
    public String createUser(@ModelAttribute User user) {
        userService.create(user);
        return "redirect:/users";
    }


    @RequestMapping(value = "/{id}/delete", method = RequestMethod.GET)
    public String deleteUser(@PathVariable Integer id) {
        userService.delete(id);
        return "redirect:/users";
    }
}

对于UserService接口而言，其具有一个实现类，在实现类中有一个@Service注解，因为这个注解，UserService的实现类将被注入到IOC容器中，最终IOC容器可以初始化UserService的实现类的一个对象，并将对象注入到UserController里面，这样就可以通过IOC拿到一个完整的UserController对象，并且依赖已经自动装配好了。这也就是IOC的作用。在所有的代码中都没有UserService的实例化，这些都是由SpringBoot和IOC共同完成的。

UserService接口：

package demo.service;

import java.util.List;

import demo.model.User;

/**
 * @author yushan.ldq
 * @date 2018/04/22
 */
public interface UserService {

    User findById(Integer id);

    User create(User user);

    User update(User user);

    User delete(Integer id);

    List<User> findAll();
}

UserServiceImpl实现类：

package demo.service.impl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import demo.model.User;
import demo.service.UserService;
import org.springframework.stereotype.Service;

/**
 * @author yushan.ldq
 * @date 2018/04/22
 */
@Service()
public class UserServiceImpl implements UserService{

    private Map<Integer, User> userDb = new HashMap<Integer, User>();

    public User findById(Integer id) {
        return null;
    }

    public User create(User user) {
        user.setId(userDb.size() + 1);
        return userDb.put(user.getId(), user);
    }

    public User update(User user) {
        return null;
    }

    public User delete(Integer id) {
        return userDb.remove(id);
    }

    public List<User> findAll() {
        return new ArrayList<User>(userDb.values());
    }
}

因为LogAspect的存在，将导致后续代码在执行controller里面的所有公有方法的时候都会在之前进行方法参数打印，以及方法后返回值的输出。这就是AOP面向切面编程思想所带来的好处。

LogAspect类：

package demo.aop;

import java.util.Arrays;

import javax.servlet.http.HttpServletRequest;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

/**
 * @author yushan.ldq
 * @date 2018/04/24
 */
@Aspect
@Component
public class LogAspect {
    @Pointcut("execution(public * demo.controller.*.*(..))") //切点表达式
    public void log(){}

    @Before("log()")
    public void doBefore(JoinPoint joinPoint) throws Throwable {
        // 接收到请求，记录请求内容
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        // 记录下请求内容
        System.out.println("URL : " + request.getRequestURL().toString());
        System.out.println("HTTP_METHOD : " + request.getMethod());
        System.out.println("IP : " + request.getRemoteAddr());
        System.out.println("CLASS_METHOD : " + joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
    }

    @AfterReturning(returning = "ret", pointcut = "log()")
    public void doAfterReturning(Object ret) {
        // 处理完请求，返回内容
        System.out.println("方法的返回值 : " + ret);
    }
}

接下来将与大家分享WebMVC这种架构模式的使用，首先需要理解MVC中的M、V、C分别都代表什么。M指的是Model，也就是数据模型。如下图所示的User类，Model就是数据的载体。

User 类：

package demo.model;

/**
 * @author yushan.ldq
 * @date 2018/04/22
 */
public class User {
    private Integer id;
    private String name;
    private Integer age;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    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;
    }
}

V指的是View视图，在这里的视图是templates文件夹下定义的两个html模板文件，这些模板文件最终将由引入的依赖Thymeleaf模板引擎进行读。在这里其实可以将模板文件理解为Java的一个类。

userCreate.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>创建用户</title>
</head>
<body>
<form th:action="@{/users}" method="post" >

    <div>
        <label for="user_name" class="col-sm-2 control-label">用户名:</label>
        <input type="text" id="user_name" name="name" th:field="*{user.name}"/>
    </div>
    <div >
        <label for="user_age" >年龄:</label>
        <input type="text" id="user_age" name="age" th:field="*{user.age}"/>
    </div>
    <div >
        <input type="submit" value="提交"/>
    </div>
</form>

</body>
</html>

user.html

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <title>Users</title>
</head>
<body>
<table>

    <thead>
    <tr>
        <th>用户id</th>
        <th>名字</th>
        <th>年龄</th>
    </tr>
    </thead>
    <tbody>
    <tr th:each="user : ${userList}">
        <th scope="row" th:text="${user.id}"></th>
        <td th:text="${user.name}"></td>
        <td th:text="${user.age}"></td>
        <td><a th:href="@{/users/{id}/delete(id=${user.id})}">删除</a></td>
    </tr>
    </tbody>
</table>

<div><a href="/users/add" >新增用户</a></div>
</body>
</html>

/**
 *
 * @author yushan.ldq
 * @date 2018/04/22
 */
@Controller
@RequestMapping(value = "/users")
public class UserController {

    @Autowired
    @Qualifier("userServiceImpl")
    private UserService userService;

    @RequestMapping(method = RequestMethod.GET)
    public String getUsersPage(ModelMap modelMap) {
        modelMap.addAttribute("userList", userService.findAll());
        return "users";
    }

    @RequestMapping(value = "/add", method = RequestMethod.GET)
    public String createUserPage(ModelMap modelMap) {
        modelMap.addAttribute("user", new User());
        return "userCreate";
    }

    @RequestMapping(method = RequestMethod.POST)
    public String createUser(@ModelAttribute User user) {
        userService.create(user);
        return "redirect:/users";
    }


    @RequestMapping(value = "/{id}/delete", method = RequestMethod.GET)
    public String deleteUser(@PathVariable Integer id) {
        userService.delete(id);
        return "redirect:/users";
    }
}

其实在整个过程中都是在定义一个类，通过注解进行配置，在整个过程中并没有通过类实例化一个对象，这些都是因为控制反转的缘故交由IOC处理了。由于Spring Boot的缘故，也无需定义一个Tomcat，Spring Boot已经默认定义好了一个Tomcat来对外提供服务，这就是Spring Boot所带来的好处，可以帮助我们非常快速地开发Web的应用。

本文由云栖志愿小组贾子甲整理，编辑百见