spring boot 小案例

1. SpringBoot

1.1. 概要

在传统的SSM框架应用过程中，存在大量的配置文件，及相关的配置项，例如：

1. DispatcherServlet
2. CharacterEncodingFilter
3. <mvc:component-scan />
4. <mvc:annotation-driven />
5. <bean class="...InternalResourceViewResolver" />
6. <util:properties />
7. <bean class="...BasicDataSource" />
8. <bean class="...MapperScannerConfigurer" />
9. <bean class="...SqlSessionFactoryBean" />

这些配置在每个基于SSM框架的应用中都是需要的，每次开发时却改动很小，甚至某些配置是不需要改动的，所以，出现了SpringBoot框架！

可以把SpringBoot理解为框架的集合体，默认就添加了大量的常用依赖，并且完成了绝大部分通用的配置，从而简化了项目的创建过程。

在其它方面，SpringBoot也有很多的简化，在学习中再慢慢体会。

1.2. 使用SpringBoot

访问https://start.spring.io/，通过该页面创建项目，主要填写必要的参数，点击Switch to the full version展开详细配置，在下方勾选所需要的jar包，然后生成项目。

下载生成的项目的压缩包，解压缩后，将项目文件夹复制或剪切到Workspace中，在Eclipse中，通过Import > Existing Maven Projects功能导入，然后等待项目更新完成（务必保证此过程中电脑是可以正常连接到Maven服务器的）。　

1.3. HelloWorld

首先，SpringBoot默认并不推荐服务器端的开发任务中包含页面的开发，即服务器端依然只提供JSON数据即可，而不应该通过转发或重定向等方式处理页面（当然，功能方面还是支持的）。

由于创建项目时，Group值为cn.tedu.boot，Artifact值为sample，所以，在项目中默认存在cn.tedu.boot.sample包，这个包也是组件扫描的包，则本项目中，所有需要被Spring管理的组件都必须在这个包或它的子孙包中！

在cn.tedu.boot.sample.controller中创建HelloController：

@RestController
@RequestMapping("/hello")
public class HelloController {

    // 请求路径：/hello/index
    @GetMapping("/index")
    public String showIndex() {
        return "hello, spring boot.";
    }

}

以上@RestController是@Controller与@ResponseBody的组合应用方式，当使用这个注解时，当前类中所有处理请求的方法相当于都添加了@ResponseBody，同时，也意味着当前控制器中处理请求时不支持转发或重定向，而全部是响应正文，如果一定需要转发或重定向，只能使用@Controller注解。

SpringBoot默认添加了许多常用的依赖，且相关的jar包都是较高的稳定版本，所以，简单的项目中可以不必自行添加依赖，如果需要添加依赖，大多数依赖是不推荐自定义版本号的。

在SpringBoot中，配置了StringHttpMessageConverter的配置，使得响应头的ContentType使用的字符编码是utf-8，所以，即使使用String类型的返回值响应正文，也是支持中文的！（默认是使用的ISO-8859-1）

并且，SpringBoot默认完成了关于DispatcherServlet的配置（事实上在SpringBoot项目中根本就不存在web.xml文件），并且映射的路径是/*，所以，在配置映射路径时，并不要求资源名以.do作为后缀。

在执行时，直接运行根包下的XXXApplication.java文件中的main()方法即可，SpringBoot中内置Tomcat，所以，在启动之前，务必保证默认端口8080没有被占用，并且，成功启动后，在没有停止之前，不可以启动第２次，否则将导致端口冲突，第２次启动会失败！

由SpringBoot部署的项目，在URL中没有项目名称，所以，以上配置的请求，可以通过http://localhost:8080/hello/index直接访问。

1.4. 设计注册页面

基于前后端分离的思想，页面并不需要是JSP页面，只需要是HTML页面即可。

在SpringBoot中，推荐将静态资源（HTML页面、CSS、JS、图片等）放在src/main/resources/static目录下。

所以，在static下创建reg.html页，完成后，通过http://localhost:8080/reg.html即可直接访问。

1.5. 创建实体类

package cn.tedu.boot.sample.entity;

import java.io.Serializable;

public class User implements Serializable {

    private static final long serialVersionUID = 1414039275087351434L;

    private Integer id;
    private String username;
    private String password;
    private Integer age;
    private String phone;
    private String email;

    // ...
}

1.6. 持久层

在SpringBoot项目中，使用MyBatis时，无须配置MapperScannerConfiguere和SqlSessionFactoryBean，可以直接开始编写代码，例如先创建cn.tedu.boot.sample.mapper.UserMapper接口：

public interface UserMapper {

    Integer addnew(User user);

}

然后，在resources下创建mappers文件夹，并在该文件夹下添加UserMapper.xml文件（从其它项目中复制粘贴过来）：

<mapper namespace="cn.tedu.boot.sample.mapper.UserMapper">

    <insert id="addnew">
    INSERT INTO t_user (
        username, password,
        age, phone,
        email
    ) VALUES (
        #{username}, #{password},
        #{age}, #{phone},
        #{email}
    )
    </insert>

</mapper>

即使不用再配置比较繁琐的内容，也不代表完全没有配置，为了保证项目能扫描得到持久层接口，需要在接口文件之前添加@Mapper注解，同时，还需要指定持久层映射的XML文件的位置，在application.properties文件中：

mybatis.mapper-locations=classpath:mappers/*.xml

编码完成后，应该及时执行单元测试，以检查功能是否正常，应该在src/test/java中的根包下创建测试类，所有测试类都应该添加@RunWith(SpringRunner.class)和@SpringBootTest注解，相当于加载Spring配置文件以获取Spring容器，甚至完成其它的初始化配置，然后，所需要的Bean可以直接声明并添加@Autowired通过自动装配来得到值，接下来，编写测试方法即可：

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

    @Autowired
    UserMapper userMapper;

    @Test
    public void addnew() {
        User user = new User();
        user.setUsername("boot");
        user.setPassword("8888");
        Integer rows = userMapper.addnew(user);
        System.err.println("rows=" + rows);
    }

}

通常，注册功能中，要求“用户名必须是唯一的”，所以，为了保证注册功能的完整性，还应该提供“根据用户名查询用户数据是否存在”的查询功能！对应的抽象方法可以是：

User findByUsername(String username);

匹配的映射是：

<select id="findByUsername"
    resultType="cn.tedu.boot.sample.entity.User">
    SELECT
        id
    FROM
        t_user
    WHERE
        username=#{username}
</select>

注意：由于这个查询功能应用于“注册时检查用户名是否被占用”，所以，并不关心查询到的数据的各属性值是多少，那么，在查询时，应该只查询必要的字段，如果所有字段都不关心，则只选取其中任一字段即可。

功能完成后，还是应该及时的编写测试：

@Test
public void findByUsername() {
    String username = "boot";
    User user
        = userMapper.findByUsername(username);
    System.err.println(user);
}

public void deGet() {
    // 接收用户提交的用户名等参数
    // Dao > 检查用户名是否被占用
    // 是：被占用 > 提示错误
    // 否：没有被占用 > Dao > 插入数据
    // -- 提示成功
}

1.7. 业务层

通常，业务层应该由业务接口和业务实现类来共同组成，例如创建cn.tedu.boot.sample.service.IUserService

package cn.tedu.boot.sample.service;

public interface IUserService {

}

然后，创建cn.tedu.boot.sample.service.impl.UserServiceImpl类实现该接口：

package cn.tedu.boot.sample.service.impl;

import cn.tedu.boot.sample.service.IUserService;

public class UserServiceImpl
    implements IUserService {

}

接下来，应该在接口中声明抽象方法，该方法表示向外提供的功能，例如注册、登录、修改密码等，此次需要完成的是注册，则：

void reg(User user); // throws 用户名被占用异常, XX异常;

注意：设计抽象方法时，仅以“成功”为前提来考虑方法的返回值类型！如果失败，使用抛出异常的方式来表现。

try {

} catch (用户名被占用异常 e) {

} catch (XXX异常 e) {

}

然后，在实现类中，声明持久层对象private UserMapper userMapper;并添加@Autowired注解，当前类也应该添加@Service注解，然后，实现以上方法：

@Service
public class UserServiceImpl
    implements IUserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public void reg(User user) {
        // 根据user.getUsername()查询数据
        String username = user.getUsername();
        User data = userMapper.findByUsername(username);
        // 判断数据是否为null
        if (data == null) {
            // 是：为null，即：用户名未被使用，则插入数据
            userMapper.addnew(user);
        } else {
            // 否：非null，即：用户名被占用，则抛出异常
            throw new RuntimeException(
                "注册失败！您尝试注册的用户名(" + username + ")已经被占用！");
        }
    }

}

最后，执行单元测试：

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

    @Autowired
    IUserService userService;

    @Test
    public void reg() {
        try {
            User user = new User();
            user.setUsername("service");
            user.setPassword("8866");
            userService.reg(user);
            System.err.println("注册成功！");
        } catch (RuntimeException e) {
            System.err.println(e.getMessage());
        }
    }

}

1.8. 控制器层

先创建控制器类cn.tedu.boot.sample.controller.UserController，添加@RestController和@RequestMapping("/user")：

@RestController
@RequestMapping("/user")
public class UserController {

}

控制器类本身并不完成实际功能的处理，主要作用是接收请求、给予响应结果，所以，在功能的处理方面，它会依赖于业务层private IUserService userService;并通过@Autowired注入值：

@Autowired
private IUserService userService;

接下来，应该设计所需要处理的请求，此次的请求是用户将提交注册相关数据，尝试执行注册，所以，请求的类型应该是POST，请求的参数应该是包括注册的所有数据，例如用户名、密码、年龄等，在SpringMVC中，可以使用User对象接收这些参数，在响应时，仍推荐使用JSON数据进行响应，所以，应该提前创建好ResponseResult类，作用处理请求的方法的返回值：

package cn.tedu.boot.sample.util;

import java.io.Serializable;

public class ResponseResult<T> implements Serializable {

    private static final long serialVersionUID = -5015220243507112803L;

    private Integer state;
    private String message;
    private T data;

    // SET/GET

}

然后，在控制器类中添加处理请求的方法：

@RequestMapping("/reg")
public ResponseResult<Void> handleReg(User user) {

}

最原始的处理方式为：

@RequestMapping("/reg")
public ResponseResult<Void> handleReg(User user) {
    ResponseResult<Void> rr = new ResponseResult<Void>();

    try {
        userService.reg(user);
        rr.setState(1);
        rr.setMessage("注册成功");
        return rr;
    } catch (RuntimeException e) {
        rr.setState(2);
        rr.setMessage(e.getMessage);
        return rr;
    }
}

为了快速的创建ResponseResult并确定state和message属性的值，简化以上代码，所以，可以在ResponseResult类中添加新的构造方法：

public ResponseResult(Integer state, String message) {
    super();
    this.state = state;
    this.message = message;
}

public ResponseResult(Integer state, Exception e) {
    super();
    this.state = state;
    this.message = e.getMessage();
}

所以，原有的控制器中的代码可以调整为：

@RequestMapping("/reg")
public ResponseResult<Void> handleReg(User user) {
    try {
        userService.reg(user);
        return new ResponseResult<Void>(1, "注册成功");
    } catch (RuntimeException e) {
        return new ResponseResult<Void>(2, e);
    }
}

为了便于统一处理异常，应该添加专门的方法进行处理：

@ExceptionHandler(RuntimeException.class)
public ResponseResult<Void>
    handleException(Exception e) {
    return new ResponseResult<>(2, e);
}

则控制器中不必再处理异常：

@RequestMapping("/reg")
public ResponseResult<Void> handleReg(User user) {
    // 执行注册
    userService.reg(user);
    // 注册成功，确定返回值
    return new ResponseResult<>(1, "注册成功！");
}

全部完成后，可以在浏览器的地址栏中输入http://localhost:8080/user/reg?username=exception&password=666进行测试（如果有更多非空字段的设计，请添加更多参数），测试完成后，将以上处理请求的方法的注解修改为@PostMapping。