2.快速开始 | Next-gen Tech Edu

DevTools

Mon, 01 Jan 0001 00:00:00 +0000

SpringBoot DevTools

SpringBoot Dev Tools 为我们提供了便捷的开发时辅助功能，其主要包含了以下特性：

Property defaults
Automatic Restart
Live Reload
Global settings
Remote applications

在 Spring 项目中如果需要引入 SpringBoot DevTools 也非常的方便，如其他依赖一样添加到 POM 或者 build.gradle 文件中即可：

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-devtools</artifactId>
</dependency>

常用注解

Mon, 01 Jan 0001 00:00:00 +0000

常用注解

应用上下文

AutoWired

把配置好的 Bean 拿来用，完成属性、方法的组装，它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作；当加上（required=false）时，就算找不到 bean 也不报错；

@Bean

相当于 XML 中的,放在方法的上面，而不是类，意思是产生一个 bean,并交给 spring 管理。

@ComponentScan

组件扫描。个人理解相当于，如果扫描到有@Component @Controller @Service 等这些注解的类，则把这些类注册为 bean*；

@Configuration

指出该类是 Bean 配置的信息源，相当于 XML 中的，一般加在主类上；

@Component

泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。

@EnableAutoConfiguration

让 Spring Boot 根据应用所声明的依赖来对 Spring 框架进行自动配置，一般加在主类上。

@Qualifier

当有多个同一类型的 Bean 时，可以用@Qualifier(“name”)来指定。与@Autowired 配合使用。

@Repository

用于标注数据访问组件，即 DAO 组件。

@Resource(name=”name”,type=”type”)

没有括号内内容的话，默认 byName。与@Autowired 干类似的事。

@SpringBootApplication

包含@Configuration、@EnableAutoConfiguration、@ComponentScan 通常用在主类上；

请求响应与服务

@Controller & @RestController

用于标注是控制层组件，需要返回页面时请用@Controller 而不是@RestController。@RestController 则用于标注控制层组件(如 struts 中的 action)，包含 @Controller 和 @ResponseBody。

@RequestMapping

RequestMapping 是一个用来处理请求地址映射的注解，可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

params: 指定 request 中必须包含某些参数值是，才让该方法处理。
headers: 指定 request 中必须包含某些指定的 header 值，才能让该方法处理请求。
value: 指定请求的实际地址，指定的地址可以是 URI Template 模式
method: 指定请求的 method 类型，GET、POST、PUT、DELETE 等
consumes: 指定处理请求的提交内容类型（Content-Type），如 application/json,text/html;
produces: 指定返回的内容类型，仅当 request 请求头中的(Accept)类型中包含该指定类型才返回。

其关联注解还有 @GetMapping、@PostMapping 等，相当于 @RequestMapping（value=”/”，method=RequestMethod.GetPostPutDelete) 等。是个组合注解；

@RequestParam & @PathVariable & @RequestBody

@RequestParam 用在方法的参数前面。相当于 request.getParameter；@RequestBody 参数前加上这个注解之后，认为该参数必填。表示接受 json 字符串转为对象 List 等。@PathVariable 则是路径变量：

// RequestMapping(“user/get/mac/{macAddress}”)；
public String getByMacAddress(
@PathVariable(“macAddress”) String macAddress){
 //do something;
}

参数与大括号里的名字相同的话，注解后括号里的内容可以不填。

@ResponseBody

表示该方法的返回结果直接写入 HTTP response body 中，一般在异步获取数据时使用，在使用@RequestMapping 后，返回值通常解析为跳转路径，加上 @ResponseBody 后返回结果不会被解析为跳转路径，而是直接写入 HTTP response body 中；比如异步获取 Json 数据，加上 @ResponseBody 后，会直接返回 json 数据。

@Service

用于标注业务层组件。

数据访问

Jpa

@Entity & @Table(name=”“)

表明这是一个实体类。一般用于 Jpa，这两个注解一般一块使用，但是如果表名和实体类名相同的话，@Table 可以省略。

@MappedSuperClass

用在确定是父类的 entity 上。父类的属性子类可以继承。

@NoRepositoryBean

一般用作父类的 repository，有这个注解，Spring 不会去实例化该 repository；

@Column & @Id

如果字段名与列名相同，则可以省略。@Id 表示该属性为主键。

@GeneratedValue(strategy=GenerationType.SEQUENCE,generator = “repair_seq”)

表示主键生成策略是 sequence（可以为 Auto、IDENTITY、native 等，Auto 表示可在多个数据库间切换），指定 sequence 的名字是 repair_seq。

@SequenceGeneretor(name = “repair_seq”, sequenceName = “seq_repair”, allocationSize = 1)

name 为 sequence 的名称，以便使用，sequenceName 为数据库的 sequence 名称，两个名称可以一致。

@Transient

表示该属性并非一个到数据库表的字段的映射,ORM 框架将忽略该属性。如果一个属性并非数据库表的字段映射,就务必将其标示为@Transient，否则 ORM 框架默认其注解为 @Basic。@Basic(fetch=FetchType.LAZY) 标记可以指定实体属性的加载方式。

@JsonIgnore

作用是 Json 序列化时将 Java Bean 中的一些属性忽略掉，序列化和反序列化都受影响。

@JoinColumn(name=”loginId”)

Spring Cloud

@SpringCloudApplication

包含 @SpringBootApplication、@EnableDiscovertyClient、@EnableCircuitBreaker，分别是 SpringBoot 注解、注册服务中心 Eureka 注解、断路器注解。对于 SpringCloud 来说，这是每一微服务必须应有的三个注解，所以才推出了@SpringCloudApplication 这一注解集合。

@EnableEurekaServer

用在 Spring Boot 启动类上，表示这是一个 Eureka 服务注册中心。

@EnableDiscoveryClient

用在 Spring Boot 启动类上，表示这是一个服务，可以被注册中心找到。

@LoadBalanced

开启负载均衡能力。

@EnableCircuitBreaker

用在启动类上，开启断路器功能。

@HystrixCommand(fallbackMethod=”backMethod”)

用在方法上，fallbackMethod 指定断路回调方法

@EnableConfigServer

用在启动类上，表示这是一个配置中心，开启 Config Server。

@EnableZuulProxy

开启 zuul 路由，用在启动类上。

其他

服务与异常处理

@ControllerAdvice

包含 @Component。可以被扫描到。统一处理异常。

@ExceptionHandler(Exception.class)

用在方法上面表示遇到这个异常就执行以下方法。

简单全链路应用

Mon, 01 Jan 0001 00:00:00 +0000

Spring Boot 快速开始

Spring Boot 是 Spring 平台上有一定约束的，基于约定的配置的补充，对于以最小的努力入门和创建独立的生产级应用程序非常有用。通过 Spring Boot CLI 能够直接运行如下的代码：

@RestController
@EnableAutoConfiguration
public class Example {
 @RequestMapping("/")
 String home() {
 return "Hello World!";
 }

 public static void main(String[] args) throws Exception {
 SpringApplication.run(Example.class, args);
 }
}

我们可以在 Spring Initializr 站点中快速生成 Spring Boot 项目模板，或者使用 Spring Boot CLI 来直接运行本地代码，而不需要关心具体的 Spring 项目配置。创建之后的项目会依赖于 Boot 父项目：

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

初始化的依赖如下：

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
 <groupId>com.h2database</groupId>
 <artifactId>h2</artifactId>
</dependency>

应用配置

我们可以先创建简单的主应用类：

@SpringBootApplication
public class Application {

 public static void main(String[] args) {
 SpringApplication.run(Application.class, args);
 }
}

很多时候，也可以在配置文件中引入 XML 的配置文件：

@SpringBootApplication
@EnableConfigurationProperties(ServiceProperties.class)
@ImportResource("integration-context.xml")
public class SampleIntegrationApplication {

 public static void main(String[] args) throws Exception {
 SpringApplication.run(SampleIntegrationApplication.class, args);
 }

}

@SpringBootApplication 等价于 @Configuration, @EnableAutoConfiguration, 以及 @ComponentScan 的综合体。最后，我们可以定义简单的应用属性文件 application.properties：

server.port=8081

更多 Spring 内置的配置参数项可以参考 Spring Boot properties available。

MVC

接下来我们可以通过 Thymeleaf 来添加基础的 MVC 特性，我们可以添加 spring-boot-starter-thymeleaf 依赖：

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

然后在 application.properties 文件中进行环境配置：

spring.thymeleaf.cache=false
spring.thymeleaf.enabled=true
spring.thymeleaf.prefix=classpath:/templates/
spring.thymeleaf.suffix=.html

spring.application.name=Bootstrap Spring Boot

然后我们定义简单的 Controller，它会返回主页：

@Controller
public class SimpleController {
 @Value("${spring.application.name}")
 String appName;

 @GetMapping("/")
 public String homePage(Model model) {
 model.addAttribute("appName", appName);
 return "home";
 }
}

最终输出的模板 home.html 文件定义如下：

<html>
 <head>
 <title>Home Page</title>
 </head>
 <body>
 <h1>Hello !</h1>
 <p>Welcome to <span th:text="${appName}">Our App</span></p>
 </body>
</html>

现代开发中很多的不是直接返回页面，而是以接口方式与前端进行交互，譬如这里简单的 BookController 能够支持对 Book 这个对象的 CRUD 操作：

@RestController
@RequestMapping("/api/books")
public class BookController {
 @Autowired
 private BookRepository bookRepository;

 @GetMapping
 public Iterable findAll() {
 return bookRepository.findAll();
 }

 @GetMapping("/title/{bookTitle}")
 public List findByTitle(@PathVariable String bookTitle) {
 return bookRepository.findByTitle(bookTitle);
 }

 @GetMapping("/{id}")
 public Book findOne(@PathVariable Long id) {
 return bookRepository.findById(id).orElseThrow(BookNotFoundException::new);
 }

 @PostMapping
 @ResponseStatus(HttpStatus.CREATED)
 public Book create(@RequestBody Book book) {
 return bookRepository.save(book);
 }

 @DeleteMapping("/{id}")
 public void delete(@PathVariable Long id) {
 bookRepository.findById(id).orElseThrow(BookNotFoundException::new);
 bookRepository.deleteById(id);
 }

 @PutMapping("/{id}")
 public Book updateBook(@RequestBody Book book, @PathVariable Long id) {
 if (book.getId() != id) {
 throw new BookIdMismatchException();
 }
 bookRepository.findById(id).orElseThrow(BookNotFoundException::new);
 return bookRepository.save(book);
 }
}

鉴于应用程序的这一方面是 API，我们在这里使用 @RestController 注解，等同于 @Controller 和 @ResponseBody，以便每个方法将返回的资源封送给 HTTP 响应。

Security（安全）

接下来我们可以为我们的应用添加安全控制，首先需要将 spring-boot-starter-security 添加到项目依赖中；

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

该依赖添加完毕后，所有端点都将使用 httpBasic 或 formLogin 进行保护。这就是为什么，如果我们在类路径上有启动器，通常应该通过扩展 WebSecurityConfigurerAdapter 类来定义自己的自定义安全性配置：

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

 @Override
 protected void configure(HttpSecurity http) throws Exception {
 http.authorizeRequests().anyRequest().permitAll().and().csrf().disable();
 }
}

简单持久化（Persistence）

我们可以利用 Spring Data 进行快速地持久化操作：

@Entity
public class Book {
 @Id
 @GeneratedValue(strategy = GenerationType.AUTO)
 private long id;

 @Column(nullable = false, unique = true)
 private String title;

 @Column(nullable = false)
 private String author;
}

然后直接继承来自 Spring Data 的 CrudRepository：

public interface BookRepository extends CrudRepository<Book, Long> {
 List<Book> findByTitle(String title);
}

最后我们还需要配置持久化扫描层的加载与扫描：

@EnableJpaRepositories("com.baeldung.persistence.repo")
@EntityScan("com.baeldung.persistence.model")
@SpringBootApplication
public class Application {
 ...
}

这里我们可以使用内存数据库 H2 作为测试用数据库，一旦在配置文件中添加了 H2 数据库的配置，则 Spring Boot 会自动帮助我们构建持久化层：

spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.url=jdbc:h2:mem:bootapp;DB_CLOSE_DELAY=-1
spring.datasource.username=sa
spring.datasource.password=

异常处理（Error Handling）

在基础应用之上，我们还需要为应用添加异常处理的能力，这里基于 @ControllerAdvice 提供了中心化的异常处理：

@ControllerAdvice
public class RestExceptionHandler extends ResponseEntityExceptionHandler {

 @ExceptionHandler({ BookNotFoundException.class })
 protected ResponseEntity<Object> handleNotFound(
 Exception ex,
 WebRequest request
 ) {
 return handleExceptionInternal(
 ex,
 "Book not found",
 new HttpHeaders(),
 HttpStatus.NOT_FOUND,
 request
 );
 }

 @ExceptionHandler(
 {
 BookIdMismatchException.class,
 ConstraintViolationException.class,
 DataIntegrityViolationException.class
 }
 )
 public ResponseEntity<Object> handleBadRequest(
 Exception ex,
 WebRequest request
 ) {
 return handleExceptionInternal(
 ex,
 ex.getLocalizedMessage(),
 new HttpHeaders(),
 HttpStatus.BAD_REQUEST,
 request
 );
 }
}

这里的异常类型是允许我们进行业务化定制的：

public class BookNotFoundException extends RuntimeException {

 public BookNotFoundException(String message, Throwable cause) {
 super(message, cause);
 }
// ...
}

Spring Boot 还内置了一个名为 /error 的异常结果映射路径，我们也可以通过创建 error.html 文件来对其进行自定义：

<html lang="en">
 <head>
 <title>Error Occurred</title>
 </head>
 <body>
 <h1>Error Occurred!</h1>
 <b
 >[<span th:text="${status}">status</span>]
 <span th:text="${error}">error</span>
 </b>
 <p th:text="${message}">message</p>
 </body>
</html>

也可以通过系统内置的属性，修改默认的错误位置：

server.error.path=/error2

Testing（测试）

最后我们可以测试新的 Books 接口，这里主要使用 @SpringBootTest 来加载应用上下文：

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

 private MockMvc mvc;

 @Before
 public void setUp() throws Exception {
 mvc = MockMvcBuilders.standaloneSetup(new HelloController()).build();
 }

 @Test
 public void getHello() throws Exception {
 mvc.perform(MockMvcRequestBuilders.get("/hello").accept(MediaType.APPLICATION_JSON))
 .andExpect(status().isOk())
 .andExpect(content().string(equalTo("Hello World")));
 }

}

也可以单独使用 JUnit 来以黑盒方式测试 API：

public class SpringBootBootstrapLiveTest {
 private static final String API_ROOT = "http://localhost:8081/api/books";

 private Book createRandomBook() {
 Book book = new Book();
 book.setTitle(randomAlphabetic(10));
 book.setAuthor(randomAlphabetic(15));
 return book;
 }

 private String createBookAsUri(Book book) {
 Response response = RestAssured
 .given()
 .contentType(MediaType.APPLICATION_JSON_VALUE)
 .body(book)
 .post(API_ROOT);
 return API_ROOT + "/" + response.jsonPath().get("id");
 }

 @Test
 public void whenGetAllBooks_thenOK() {
 Response response = RestAssured.get(API_ROOT);

 assertEquals(HttpStatus.OK.value(), response.getStatusCode());
 }

 @Test
 public void whenGetBooksByTitle_thenOK() {
 Book book = createRandomBook();
 createBookAsUri(book);
 Response response = RestAssured.get(API_ROOT + "/title/" + book.getTitle());

 assertEquals(HttpStatus.OK.value(), response.getStatusCode());
 assertTrue(response.as(List.class).size() > 0);
 }

 @Test
 public void whenCreateNewBook_thenCreated() {
 Book book = createRandomBook();
 Response response = RestAssured
 .given()
 .contentType(MediaType.APPLICATION_JSON_VALUE)
 .body(book)
 .post(API_ROOT);

 assertEquals(HttpStatus.CREATED.value(), response.getStatusCode());
 }

 @Test
 public void whenDeleteCreatedBook_thenOk() {
 Book book = createRandomBook();
 String location = createBookAsUri(book);
 Response response = RestAssured.delete(location);

 assertEquals(HttpStatus.OK.value(), response.getStatusCode());

 response = RestAssured.get(location);
 assertEquals(HttpStatus.NOT_FOUND.value(), response.getStatusCode());
 }
}

打包部署

实际项目架构

Mon, 01 Jan 0001 00:00:00 +0000

实际项目中的 Spring 架构

从零开始搭建一个环境，主要要考虑几点：统一封装的数据结构、可调式的接口、json 的处理、模板引擎的使用（本文不写该项，因为现在大部分项目都前后端分离了，但是考虑到也还有非前后端分离的项目，所以我在源代码里也加上了 thymeleaf）、持久层的集成、拦截器（这个也是可选的）和全局异常处理。一般包括这些东西的话，基本上一个 Spring Boot 项目环境就差不多了，然后就是根据具体情况来扩展了。

统一的数据封装

由于封装的 json 数据的类型不确定，所以在定义统一的 json 结构时，我们需要用到泛型。统一的 json 结构中属性包括数据、状态码、提示信息即可，构造方法可以根据实际业务需求做相应的添加即可，一般来说，应该有默认的返回结构，也应该有用户指定的返回结构。如下：

public class JsonResult<T> {
 private T data;
 private String code;
 private String msg;
 /**
 * 若没有数据返回，默认状态码为0，提示信息为：操作成功！
 */
 public JsonResult() {
 this.code = "0";
 this.msg = "操作成功！";
 }
 /**
 * 若没有数据返回，可以人为指定状态码和提示信息
 * @param code
 * @param msg
 */
 public JsonResult(String code, String msg) {
 this.code = code;
 this.msg = msg;
 }
 /**
 * 有数据返回时，状态码为0，默认提示信息为：操作成功！
 * @param data
 */
 public JsonResult(T data) {
 this.data = data;
 this.code = "0";
 this.msg = "操作成功！";
 }
 /**
 * 有数据返回，状态码为0，人为指定提示信息
 * @param data
 * @param msg
 */
 public JsonResult(T data, String msg) {
 this.data = data;
 this.code = "0";
 this.msg = msg;
 }

 /**
 * 使用自定义异常作为参数传递状态码和提示信息
 * @param msgEnum
 */
 public JsonResult(BusinessMsgEnum msgEnum) {
 this.code = msgEnum.code();
 this.msg = msgEnum.msg();
 }
 // 省去get和set方法
}

大家可以根据自己项目中所需要的一些东西，合理的修改统一结构中的字段信息。

Json 的处理

Json 处理工具很多，比如阿里巴巴的 fastjson，不过 fastjson 对有些未知类型的 null 无法转成空字符串，这可能是 fastjson 自身的缺陷，可扩展性也不是太好，但是使用起来方便，使用的人也蛮多的。这节课里面我们主要集成 Spring Boot 自带的 jackson。主要是对 jackson 做一下对 null 的配置即可，然后就可以在项目中使用了。

@Configuration
public class JacksonConfig {
 @Bean
 @Primary
 @ConditionalOnMissingBean(ObjectMapper.class)
 public ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder) {
 ObjectMapper objectMapper = builder.createXmlMapper(false).build();
 objectMapper.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>() {
 @Override
 public void serialize(Object o, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
 jsonGenerator.writeString("");
 }
 });
 return objectMapper;
 }
}

Swagger2 在线可调式接口

有了 swagger，开发人员不需要给其他人员提供接口文档，只要告诉他们一个 Swagger 地址，即可展示在线的 API 接口文档，除此之外，调用接口的人员还可以在线测试接口数据，同样地，开发人员在开发接口时，同样也可以利用 Swagger 在线接口文档测试接口数据，这给开发人员提供了便利。使用 swagger 需要对其进行配置：

@Configuration
@EnableSwagger2
public class SwaggerConfig {
 @Bean
 public Docket createRestApi() {
 return new Docket(DocumentationType.SWAGGER_2)
 // 指定构建api文档的详细信息的方法：apiInfo()
 .apiInfo(apiInfo())
 .select()
 // 指定要生成api接口的包路径，这里把controller作为包路径，生成controller中的所有接口
 .apis(RequestHandlerSelectors.basePackage("com.test.controller"))
 .paths(PathSelectors.any())
 .build();
 }
 /**
 * 构建api文档的详细信息
 * @return
 */
 private ApiInfo apiInfo() {
 return new ApiInfoBuilder()
 // 设置页面标题
 .title("Spring Boot 搭建实际项目中开发的架构")
 // 设置接口描述
 .description("xxx")
 // 设置联系方式
 .contact("xxx")
 // 设置版本
 .version("1.0")
 // 构建
 .build();
 }
}

到这里，可以先测试一下，写一个 Controller，弄一个静态的接口测试一下上面集成的内容。


@RestController
@Api(value = "用户信息接口")
public class UserController {

 @Resource
 private UserService userService;

 @GetMapping("/getUser/{id}")
 @ApiOperation(value = "根据用户唯一标识获取用户信息")
 public JsonResult<User> getUserInfo(@PathVariable @ApiParam(value = "用户唯一标识") Long id) {
 User user = new User(id, "xxx", "123456");
 return new JsonResult<>(user);
 }
}

然后启动项目，在浏览器中输入 localhost:8080/swagger-ui.html 即可看到 swagger 接口文档页面，调用一下上面这个接口，即可看到返回的 json 数据。

持久层集成

每个项目中是必须要有持久层的，与数据库交互，这里我们主要来集成 mybatis，集成 mybatis 首先要在 application.yml 中进行配置。

# 服务端口号
server:
 port: 8080

# 数据库地址
datasource:
 url: localhost:3306/blog_test

spring:
 datasource: # 数据库配置
 driver-class-name: com.mysql.jdbc.Driver
 url: jdbc:mysql://${datasource.url}?useSSL=false&useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&autoReconnect=true&failOverReadOnly=false&maxReconnects=10
 username: root
 password: 123456
 hikari:
 maximum-pool-size: 10 # 最大连接池数
 max-lifetime: 1770000

mybatis:
 # 指定别名设置的包为所有entity
 type-aliases-package: com.test.entity
 configuration:
 map-underscore-to-camel-case: true # 驼峰命名规范
 mapper-locations: # mapper映射文件位置
 - classpath:mapper/*.xml

配置好了之后，接下来我们来写一下 dao 层，实际中我们使用注解比较多，因为比较方便，当然也可以使用 xml 的方式，甚至两种同时使用都行，这里我们主要使用注解的方式来集成，关于 xml 的方式，大家可以查看前面课程，实际中根据项目情况来定。

public interface UserMapper {

 @Select("select * from user where id = #{id}")
 @Results({
 @Result(property = "username", column = "user_name"),
 @Result(property = "password", column = "password")
 })
 User getUser(Long id);

 @Select("select * from user where id = #{id} and user_name=#{name}")
 User getUserByIdAndName(@Param("id") Long id, @Param("name") String username);

 @Select("select * from user")
 List<User> getAll();
}

关于 Service 层我就不在文章中写代码了，大家可以结合我的源代码学习，这一节主要带领大家来搭建一个 Spring Boot 空架构。最后别忘了在启动类上添加注解扫描 @MapperScan(“com.test.dao”)

拦截器

拦截器在项目中使用的是非常多的（但不是绝对的），比如拦截一些置顶的 url，做一些判断和处理等等。除此之外，还需要将常用的静态页面或者 swagger 页面放行，不能将这些静态资源给拦截了。首先先自定义一个拦截器。


public class MyInterceptor implements HandlerInterceptor {

 private static final Logger logger = LoggerFactory.getLogger(MyInterceptor.class);

 @Override
 public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

 logger.info("执行方法之前执行(Controller方法调用之前)");
 return true;
 }

 @Override
 public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
 logger.info("执行完方法之后进执行(Controller方法调用之后)，但是此时还没进行视图渲染");
 }

 @Override
 public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
 logger.info("整个请求都处理完咯，DispatcherServlet也渲染了对应的视图咯，此时我可以做一些清理的工作了");
 }
}

然后将自定义的拦截器加入到拦截器配置中。


@Configuration
public class MyInterceptorConfig implements WebMvcConfigurer {
 @Override
 public void addInterceptors(InterceptorRegistry registry) {
 // 实现WebMvcConfigurer不会导致静态资源被拦截
 registry.addInterceptor(new MyInterceptor())
 // 拦截所有url
 .addPathPatterns("/**")
 // 放行swagger
 .excludePathPatterns("/swagger-resources/**");
 }
}

在 Spring Boot 中，我们通常会在如下目录里存放一些静态资源：

classpath:/static classpath:/public classpath:/resources classpath:/META-INF/resources

上面代码中配置的 /** 是对所有 url 都进行了拦截，但我们实现了 WebMvcConfigurer 接口，不会导致 Spring Boot 对上面这些目录下的静态资源实施拦截。但是我们平时访问的 swagger 会被拦截，所以要将其放行。swagger 页面在 swagger-resources 目录下，放行该目录下所有文件即可。

然后在浏览器中输入一下 swagger 页面，若能正常显示 swagger，说明放行成功。同时可以根据后台打印的日志判断代码执行的顺序。

全局异常处理

全局异常处理是每个项目中必须用到的东西，在具体的异常中，我们可能会做具体的处理，但是对于没有处理的异常，一般会有一个统一的全局异常处理。在异常处理之前，最好维护一个异常提示信息枚举类，专门用来保存异常提示信息的。如下：


public enum BusinessMsgEnum {
 /** 参数异常 */
 PARMETER_EXCEPTION("102", "参数异常!"),
 /** 等待超时 */
 SERVICE_TIME_OUT("103", "服务调用超时！"),
 /** 参数过大 */
 PARMETER_BIG_EXCEPTION("102", "输入的图片数量不能超过50张!"),
 /** 500 : 发生异常 */
 UNEXPECTED_EXCEPTION("500", "系统发生异常，请联系管理员！");

 /**
 * 消息码
 */
 private String code;
 /**
 * 消息内容
 */
 private String msg;

 private BusinessMsgEnum(String code, String msg) {
 this.code = code;
 this.msg = msg;
 }

 public String code() {
 return code;
 }

 public String msg() {
 return msg;
 }

}

在全局统一异常处理类中，我们一般会对自定义的业务异常最先处理，然后去处理一些常见的系统异常，最后会来一个一劳永逸（Exception 异常）。


@ControllerAdvice
@ResponseBody
public class GlobalExceptionHandler {

 private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);

 /**
 * 拦截业务异常，返回业务异常信息
 * @param ex
 * @return
 */
 @ExceptionHandler(BusinessErrorException.class)
 @ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR)
 public JsonResult handleBusinessError(BusinessErrorException ex) {
 String code = ex.getCode();
 String message = ex.getMessage();
 return new JsonResult(code, message);
 }

 /**
 * 空指针异常
 * @param ex NullPointerException
 * @return
 */
 @ExceptionHandler(NullPointerException.class)
 @ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR)
 public JsonResult handleTypeMismatchException(NullPointerException ex) {
 logger.error("空指针异常，{}", ex.getMessage());
 return new JsonResult("500", "空指针异常了");
 }

 /**
 * 系统异常 预期以外异常
 * @param ex
 * @return
 */
 @ExceptionHandler(Exception.class)
 @ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR)
 public JsonResult handleUnexpectedServer(Exception ex) {
 logger.error("系统异常：", ex);
 return new JsonResult(BusinessMsgEnum.UNEXPECTED_EXCEPTION);
 }

}

其中，BusinessErrorException 是自定义的业务异常，继承一下 RuntimeException 即可。在 UserController 中有个 testException 方法，用来测试全局异常的，打开 swagger 页面，调用一下该接口，可以看出返回用户提示信息：”系统发生异常，请联系管理员！“。当然了，实际情况中，需要根据不同的业务提示不同的信息。

2.快速开始 | Next-gen Tech Edu

DevTools

SpringBoot DevTools

常用注解

常用注解

应用上下文

AutoWired

@Bean

@ComponentScan

@Configuration

@Component

@EnableAutoConfiguration

@Qualifier

@Repository

@Resource(name=”name”,type=”type”)

@SpringBootApplication

请求响应与服务

@Controller & @RestController

@RequestMapping

@RequestParam & @PathVariable & @RequestBody

@ResponseBody

@Service

数据访问

Jpa

@Entity & @Table(name=”“)

@MappedSuperClass

@NoRepositoryBean

@Column & @Id

@GeneratedValue(strategy=GenerationType.SEQUENCE,generator = “repair_seq”)

@SequenceGeneretor(name = “repair_seq”, sequenceName = “seq_repair”, allocationSize = 1)

@Transient

@JsonIgnore

@JoinColumn(name=”loginId”)

Spring Cloud

@SpringCloudApplication

@EnableEurekaServer

@EnableDiscoveryClient

@LoadBalanced

@EnableCircuitBreaker

@HystrixCommand(fallbackMethod=”backMethod”)

@EnableConfigServer

@EnableZuulProxy

其他

服务与异常处理

@ControllerAdvice

@ExceptionHandler(Exception.class)

Links

简单全链路应用

Spring Boot 快速开始

应用配置

MVC

Security（安全）

简单持久化（Persistence）

异常处理（Error Handling）

Testing（测试）

打包部署

Links

实际项目架构

实际项目中的 Spring 架构

统一的数据封装

Json 的处理

Swagger2 在线可调式接口

持久层集成

拦截器

全局异常处理