Spring Boot -- 认识Spring Boot

在前面我们已经学习过Srping MVC框架，我们需要配置web.xml、spring mvc配置文件，tomcat，是不是感觉配置较为繁琐。那我们今天不妨来试试使用Spring Boot，Spring Boot让我们的Spring应用变的更轻量化。比如：你可以仅仅依靠一个Java类来运行一个Spring引用。你也可以打包你的应用为jar并通过使用java -jar来运行你的Spring Web应用。

一 Spring Boot简介

1.1、Spring Boot特点

开箱即用，提供各种默认配置来简化项目配置；
内嵌式容器简化Web项目；
没有冗余代码生成和XML配置的要求；

1.2、Spring Boot和Spring MVC区别

Spring Boot 是一个快速开发的框架，能够快速的整合第三方常用框架(Maven继承方式)，简化XML配置，全部采用注解形式，Spring Boot项目中没有web.xml，内置Http服务器(Tomcat、Jetty)，默认嵌入Tomcat服务器，最终是以Java应用程序运行。Spring Boot的Web组件默认集成的是Spring MVC框架，Spring MVC是控制层。

注意：Spring Boot使用注解方式启动Spring MVC，详情参考博客：Spring MVC -- 基于注解的控制器。

1.3、Spring Boot和Spring Cloud区别

Spring Cloud依赖Spring Boot组件，使用Spring Boot编写Http协议接口，Spring Cloud是一套目前完整的微服务框架，功能非常强大。注册中心、客户端调用工具、服务治理(负载均衡、断路器、分布式配置中心、网关、服务链路、消息总线等)。

二、创建第一个Spring Boot项目

环境要求：Java1.8及以上、Spring Framework 4.1.5及以上。

开发工具：IDEA 2019。

2.1、新建项目

点击File->New Project->选择Maven，点击Next，填写如下信息：

2.2、pom文件引入依赖

<!--  spring-boot-starter-parent  整合第三方常用框架依赖信息（各种依赖信息）-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.2.RELEASE</version>
    </parent>

    <!--  spring-boot-starter-web  整合Spring MVC Web  -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <!--  为什么不需要版本号，在parent里面已经封装好了版本号 -->
        </dependency>
    </dependencies>

spring-boot-starter-parent作用：在pom.xml中引入spring-boot-starter-parent，spring官方的解释叫什么stater poms，它可以提供dependency management，也就是说依赖管理，引入以后再引入其它dependency的时候就不需要version了；
spring-boot-starter-web作用：Spring Web 核心组件，整合了Spring MVC所用到的jar，主要包括spring-aop、spring-beans、spring-context、spring-core、spring-web、spring-webmvc；

这里主要是利用的maven的父子依赖关系实现的。

2.3、简单demo

创建一个包 com.zy.example.member.controller，新增MemberController.java代码：

package com.zy.example.member.controller;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * Spring Boot2.0第一个案例
 *
 * @author zy
 * @since 2020-2-2
 */
@RestController
@EnableAutoConfiguration
public class MemberController {
    //@RestController注解表示该类中所有方法返回json格式  等价于@Controller+@ReponseBody
    //Spring Boot启动原理：Spring MVC注解方式启动，不需要web.xml文件 默认内置tomcat服务器
    @RequestMapping("/memberIndex")
    public String memberIndex(){
        return "Spring Boot2.0全新版本教程!";
    }

    public static void main(String[] args){
        //整个程序入口 启动Spring Boot项目
        SpringApplication.run(MemberController.class,args);
    }
}

在上面代码中，我们使用到了如下注解：

@RestController：表示修饰该Controller所有的方法返回JSON格式,直接可以编写Restful接口；
@EnableAutoConfiguration注解：作用在于让 Spring Boot 根据应用所声明的依赖来对 Spring 框架进行自动配置，这个注解告诉Spring Boot根据pom中添加的jar依赖猜测你想如何配置Spring。由于spring-boot-starter-web添加了Tomcat和Spring MVC，所以auto-configuration将假定你正在开发一个web应用并相应地对Spring进行设置。

启动主程序，打开浏览器访问http://localhost:8080//memberIndex，可以看到页面输出Spring Boot2.0全新版本教程!

注意：每个请求处理方法可以有多个不同类型的参数，以及一个多种类型的返回结果，具体可以参考编写请求处理方法。以memberIndex()函数为例，返回值为String类型、由于使用了@RestController注解，表示返回的是json字符串，如果将注解修改为@Controller，则返回的是代表逻辑视图名的String。

2.4、其它启动方式

小节3中的启动方式，默认只扫描当前包，如果存在多个控制器，是无法扫描到的，我们可以通过@ComponentScan实现，修改MemberController.java文件如下：

package com.zy.example.member.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * Spring Boot2.0第一个案例
 *
 * @author zy
 * @since 2020-2-2
 */
@RestController
public class MemberController {
    //@RestController注解表示该类中所有方法返回json格式  等价于@Controller+@ReponseBody
    //Spring Boot启动原理：Spring MVC注解方式启动，不需要web.xml文件 默认内置tomcat服务器
    @RequestMapping("/memberIndex")
    public String memberIndex(){
        return "Spring Boot2.0全新版本教程!";
    }
}

创建启动文件App.java：

package com.zy.example.member.controller;

import org.springframework.boot.SpringApplication;
import org.springframework.context.annotation.ComponentScan;

/**
 * 启动代码
 *
 * @author zy
 * @since 2020-2-2
 */
@ComponentScan("com.zy.example.member.controller")
public class App {
    public static void main(String[] args){
        //整个程序入口 启动Spring Boot项目
        SpringApplication.run(MemberController.class,args);
    }
}

2.5、SpringBootApplication注解使用

如果我们此时再创建一个包 com.zy.example.order.controller，新增OrderController.java代码：

package com.zy.example.order.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author zy
 * @since 2020-2-2
 */
@RestController
public class OrderController {
    @RequestMapping("/orderIndex")
    public  String orderIndex(){
        return "orderIndex";
    }
}

此时需要修改扫包范围：

@ComponentScan(basePackages = {"com.zy.example.member.controller","com.zy.example.order.controller"})

当包很多的时候，这种写法无疑是麻烦的，此时我们可以使用@SpringBootApplication。

@SpringBootApplication 被 @Configuration、@EnableAutoConfiguration、@ComponentScan 注解所修饰，换言之 Springboot 提供了统一的注解来替代以上三个注解。

扫包范围：在启动类上加上@SpringBootApplication注解,当前包下或者子包下所有的类都可以扫到。

由于App.Java文件位于包 com.zy.example.member.controller，因此使用@SpringBootApplication注解无法扫描到包 com.zy.example.order.controller，需要将App.java文件移动到包 com.zy.example中，并修改其代码如下：

package com.zy.example;

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

/**
 * 启动代码
 * @author zy
 * @since 2020-2-2
 */

@SpringBootApplication
public class App {
    public static void main(String[] args){
        //整个程序入口 启动Spring Boot项目
        SpringApplication.run(App.class,args);
    }
}

三、Web开发

这里主要介绍一下在Spring Boot中如何访问静态页面，以及如何动态渲染Web页面，然而随着前后端分离技术的成熟，因此在Spring Boot中渲染Web页面基本不会再使用了。

3.1、静态资源访问

在我们开发Web应用的时候，需要引入大量的js、css、图片等静态资源。

Spring Boot默认提供静态资源目录位置需置于classpath下，目录名需符合如下规则：

/static
/public
/resources
/META-INF/resources

举例：我们可以在src/main/resources/目录下创建static，在该位置放置一个图片文件。启动程序后，尝试访问http://localhost:8080/cjk.jpg。如能显示图片，配置成功。

3.2、渲染Web页面

在之前的示例中，我们都是通过@RestController来处理请求，所以返回的内容为json对象，那么如果需要渲染html页面的时候，要如何实现呢？

在动态HTML实现上Spring Boot仍然可以完美胜任，并且提供了多种模板引擎的默认配置支持，所以在推荐的模板殷勤下，我们可以很快的上手开发动态网站。

Spring Boot提供了默认配置的模板引擎主要有以下几种：

Thymeleaf
FreeMarker
Velocity
Groovy
Mustache

Spring Boot建议使用这些模板引擎，避免使用JSP，若一定要使用JSP将无法实现Spring Boot的多种特性，具体可见后文：支持JSP的配置；
当你使用上述模板引擎中的任何一个，它们默认的模板配置路径为：src/main/resources/templates。当然也可以修改这个路径，具体如何修改，可在后续各模板引擎的配置属性中查询并修改。

3.3、使用Freemarker模板引擎渲染Web视图

pom文件引入依赖包：

<!--   引入freemarker的依赖包   -->
<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-freemarker</artifactId>
</dependency>

在src/main/resources/创建一个templates文件夹，新建index.ftl文件：

<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8" />
    <title></title>
</head>
<body>
    ${name}
</body>
</html>

创建包com.zy.example.template.controller，新建FTLIndexController.java：

package com.zy.example.template.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.Map;

/**
 * 使用Freemarker模板引擎渲染web视图
 *
 * @author zy
 * @since 2020-2-3
 */
@Controller
public class FTLIndexController {
    @RequestMapping("/index")
    public String index(Map<String, Object> map) {
        map.put("name","美丽的天使...");
        return "index";
    }
}

在src/main/resources下新建freemarker配置文件application.properties：

## Freemarker 配置
##模版存放路径（默认为 classpath:/templates/）
spring.freemarker.template-loader-path=classpath:/templates/
##是否生成缓存，生成环境建议开启（默认为true）
spring.freemarker.cache=false
##编码
spring.freemarker.charset=UTF-8
spring.freemarker.check-template-location=true
##content-type类型(默认为test/html)
spring.freemarker.content-type=text/html
## 设定所有request的属性在merge到模板的时候，是否要都添加到model中（默认为false）
spring.freemarker.expose-request-attributes=false
##设定所有HttpSession的属性在merge到模板的时候，是否要都添加到model中.(默认为false)
spring.freemarker.expose-session-attributes=false
##RequestContext属性的名称（默认为-）
spring.freemarker.request-context-attribute=request
##模板后缀(默认为.ftl)
spring.freemarker.suffix=.ftl

运行程序，访问http://localhost:8080/index：

3.4、使用jsp渲染Web视图

Spring Boot官方不推荐的jsp，因此这里就不过多介绍如何在Spring Boot中使用jsp，具体可以查找相关博客。

其中有两点需要注意：

创建Spring Boot整合JSP，一定要为war类型项目，否则会找不到页面.；
不要把JSP页面存放在resources/jsp下，因为该路径下不能被访问到；

3.5、全局捕获异常

创建包com.zy.example.error.controller，新建ErrorController.java文件：

package com.zy.example.error.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * 全局捕获异常
 *
 * @author zy
 * @since 2012-2-3
 */
@RestController
public class ErrorController {
    @RequestMapping("/getUser")
    public String getUser(@RequestParam int i){
        int j = 1/i;
        return "success" + j;
    }
}

当我们访问http://localhost:8080/getUser?i=1，返回结果如下：

当我们访问http://localhost:8080/getUser?i=0，将会抛出异常：

针对这种情况，我们可以捕获异常，但是当有很多路由处理函数时，一一捕获效率很低。此时我们可以采用全局捕获异常、使用AOP技术，采用异常通知。

在包com.zy.example.error下，新建GlobalExceptionHandler.java，代码如下：

package com.zy.example.error;

import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.HashMap;
import java.util.Map;

/**
 * 全局捕获异常：使用AOP技术，采用异常通知
 * 1、捕获返回json格式
 * 2、捕获返回页面
 *
 * @author zy
 * @since 2020-2-3
 */
@ControllerAdvice(basePackages = "com.zy.example")
public class GlobalExceptionHandler {
    //@ResponseBody：返回json格式
    //ModelAndView：返回视图页面
    @ExceptionHandler(RuntimeException.class)
    @ResponseBody
    public Map<String,Object> errorResult(){
        //实际开发中 将错误记录在日志中
        Map<String,Object> errorResultMap = new HashMap<>();
        errorResultMap.put("errorCode","500");
        errorResultMap.put("errorMsg","系统错误");

        return errorResultMap;
    }
}

再次访问http://localhost:8080/getUser?i=0，返回信息如下：

在上面代码中，我们使用到了如下注解：

@ExceptionHandler：表示拦截异常；
@ControllerAdvice 是 controller 的一个辅助类，最常用的就是作为全局异常处理的切面类，@ControllerAdvice 可以指定扫描范围，@ControllerAdvice 约定了几种可行的返回值：

如果是直接返回 model 类的话，需要使用 @ResponseBody 进行 json 转换；
返回 String，表示跳到某个 view；
返回 ModelAndView；

四、日志管理

4.1、使用log4j2记录日志

在src/main/resources下新建log4j2.xml：

<?xml version="1.0" encoding="UTF-8"?>
<!-- https://www.jianshu.com/p/8ded6531ef76 -->
<!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
<!--Configuration后面的status，这个用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，你会看到log4j2内部各种详细输出-->
<!--monitorInterval：Log4j能够自动检测修改配置 文件和重新配置本身，设置间隔秒数-->
<configuration status="WARN" monitorInterval="30">
    <!--先定义所有的appender-->
    <appenders>
        <!--这个输出控制台的配置-->
        <console name="Console" target="SYSTEM_OUT">
            <!--输出日志的格式-->
            <PatternLayout pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>
        </console>

        <!--文件会打印出所有信息，这个log每次运行程序会自动清空，由append属性决定，这个也挺有用的，适合临时测试用-->
        <File name="log" fileName="./logs/test.log" append="false">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/>
        </File>

        <!-- 这个会打印出所有的info及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileInfo" fileName="./logs/info.log"
                     filePattern="./logs/$${date:yyyy-MM}/info-%d{yyyy-MM-dd}-%i.log">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>
            <Policies>
                <TimeBasedTriggeringPolicy/>
                <SizeBasedTriggeringPolicy size="100 MB"/>
            </Policies>
        </RollingFile>

        <RollingFile name="RollingFileWarn" fileName="./logs/warn.log"
                     filePattern="./logs/$${date:yyyy-MM}/warn-%d{yyyy-MM-dd}-%i.log">
            <ThresholdFilter level="warn" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>
            <Policies>
                <TimeBasedTriggeringPolicy/>
                <SizeBasedTriggeringPolicy size="100 MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件，这里设置了20 -->
            <DefaultRolloverStrategy max="20"/>
        </RollingFile>

        <RollingFile name="RollingFileError" fileName="./logs/error.log"
                     filePattern="./logs/$${date:yyyy-MM}/error-%d{yyyy-MM-dd}-%i.log">
            <ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>
            <Policies>
                <TimeBasedTriggeringPolicy/>
                <SizeBasedTriggeringPolicy size="100 MB"/>
            </Policies>
        </RollingFile>

    </appenders>

    <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效-->
    <loggers>
        <!--过滤掉spring和mybatis的一些无用的DEBUG信息-->
        <logger name="org.springframework" level="INFO"></logger>
        <logger name="org.mybatis" level="INFO"></logger>
        <root level="INFO">
            <appender-ref ref="Console"/>
            <appender-ref ref="RollingFileInfo"/>
            <appender-ref ref="RollingFileWarn"/>
            <appender-ref ref="RollingFileError"/>
        </root>
    </loggers>
</configuration>

添加pom依赖：

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <exclusions>
                <!-- 排除自带的logback依赖 -->
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j2</artifactId>
            <version>2.2.2.RELASE</version>
        </dependency>

修改GlobalExceptionHandler.java：

package com.zy.example.error;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.HashMap;
import java.util.Map;

/**
 * 全局捕获异常：使用AOP技术，采用异常通知
 * 1、捕获返回json格式
 * 2、捕获返回页面
 *
 * @author zy
 * @since 2020-2-3
 */
@ControllerAdvice(basePackages = "com.zy.example")
public class GlobalExceptionHandler {

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

    //@ResponseBody：返回json格式
    //ModelAndView：返回视图页面
    @ExceptionHandler(RuntimeException.class)
    @ResponseBody
    public Map<String,Object> errorResult(){
        //实际开发中 将错误记录在日志中
        Map<String,Object> errorResultMap = new HashMap<>();
        errorResultMap.put("errorCode","500");
        errorResultMap.put("errorMsg","系统错误");

        //打印错误消息
        logger.error("服务器内部错误");

        return errorResultMap;
    }
}

再次访问http://localhost:8080/getUser?i=0，将会输出error信息，该信息日志会输出到当前项目./logs./error/error.log文件中：

2020-02-03 18:22 [http-nio-8080-exec-1] [com.zy.example.error.GlobalExceptionHandler] [ERROR] - 服务器内部错误

上面这种方法需要在需要打印日志的类中，创建一个日志写入器对象，然后在每个类中输出日志，那有没有一种统一处理日志的方式，当然有，下面我们将会介绍。

4.2、使用AOP统一处理Web请求日志

我们将所有控制器合并，要想使用AOP统一处理Web请求日志，首先需要添加aop依赖：

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

创建包com.zy.example.aop，新建WebLogAspect.java：

package com.zy.example.aop;

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.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.Enumeration;

/**
 * 使用AOP统一处理Web请求日志
 *
 * @author zy
 * @since 2020-2-4
 */
@Aspect
@Component
public class WebLogAspect {
    private static final Logger logger = LoggerFactory.getLogger(WebLogAspect.class);

    // 拦截包com.zy.example.controller下所有类中的所有方法
    @Pointcut("execution(public *  com.zy.example.controller.*.*(..))")
    public void webLog() {
    }

    /**
     * 使用AOP前置通知拦截请求参数信息
     * @param joinPoint
     * @throws Throwable
     */
    @Before("webLog()")
    public void doBefore(JoinPoint joinPoint) throws Throwable {
        // 接收到请求，记录请求内容  一般最多记录半年，然后进行数据迁移、云备份
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();

        // 记录下请求内容
        logger.info("URL : " + request.getRequestURL().toString());
        logger.info("HTTP_METHOD : " + request.getMethod());
        logger.info("IP : " + request.getRemoteAddr());
        Enumeration<String> enu = request.getParameterNames();
        while (enu.hasMoreElements()) {
            String name = (String) enu.nextElement();
            logger.info("name:{},value:{}", name, request.getParameter(name));
        }
    }

    /**
     * 后置通知
     * @param ret
     * @throws Throwable
     */
    @AfterReturning(returning = "ret", pointcut = "webLog()")
    public void doAfterReturning(Object ret) throws Throwable {
        // 处理完请求，返回内容
        logger.info("RESPONSE : " + ret);
    }
}

运行程序，访问http://localhost:8080/getUser?i=1，将会打印日志信息：

2020-02-04 09:22:48 [http-nio-8080-exec-4] [com.zy.example.aop.WebLogAspect] [INFO] - URL : http://localhost:8080/getUser
2020-02-04 09:22:48 [http-nio-8080-exec-4] [com.zy.example.aop.WebLogAspect] [INFO] - HTTP_METHOD : GET
2020-02-04 09:22:48 [http-nio-8080-exec-4] [com.zy.example.aop.WebLogAspect] [INFO] - IP : 0:0:0:0:0:0:0:1
2020-02-04 09:22:48 [http-nio-8080-exec-4] [com.zy.example.aop.WebLogAspect] [INFO] - name:i,value:1
2020-02-04 09:22:48 [http-nio-8080-exec-4] [com.zy.example.aop.WebLogAspect] [INFO] - RESPONSE : success1

五、Spring Boot中使用lombok

5.1、lombok的简单使用

Lombok能以简单的注解形式来简化java代码，提高开发人员的开发效率。例如开发中经常需要写的javabean，都需要花时间去添加相应的getter/setter，也许还要去写构造器、equals等方法，而且需要维护，当属性多时会出现大量的getter/setter方法，这些显得很冗长也没有太多技术含量，一旦修改属性，就容易出现忘记修改对应方法的失误。

Lombok能通过注解的方式，在编译时自动为属性生成构造器、getter/setter、equals、hashcode、toString方法。出现的神奇就是在源码中没有getter和setter方法，但是在编译生成的字节码文件中有getter和setter方法。这样就省去了手动重建这些代码的麻烦，使代码看起来更简洁些。接下来我们来分析Lombok中注解的具体用法。

@NonNull : 让你不在担忧并且爱上NullPointerException；
@CleanUp : 自动资源管理：不用再在finally中添加资源的close方法；
@Setter/@Getter : 自动生成set和get方法；
@ToString : 自动生成toString方法；
@EqualsAndHashcode : 从对象的字段中生成hashCode和equals的实现；
@NoArgsConstructor/@RequiredArgsConstructor/@AllArgsConstructor : 自动生成构造方法；
@Data : 自动生成set/get方法，toString方法，equals方法，hashCode方法，不带参数的构造方法；
@Value : 用于注解final类；
@Builder : 产生复杂的构建器api类；
@SneakyThrows : 异常处理（谨慎使用）；
@Synchronized : 同步方法安全的转化；
@Getter(lazy=true) :；
@Log : 支持各种logger对象，使用时用对应的注解，如：@Slf4j；其内部具体实现和4.1节中介绍的一样，配置文件是log4j.properties；

下面将会演示下面我们主要演示一个@Getter、@Setter的使用，更多使用可以参考博客：Lombok介绍、使用方法和总结。

首先安装lombok插件，点击File->Setting->Plugins->搜索Lombok：

Lombok的使用跟引用jar包一样，可以在官网（https://projectlombok.org/download）下载jar包，也可以使用maven添加依赖：

<!--  lombok使用     -->
<dependency>
   <groupId>org.projectlombok</groupId>
   <artifactId>lombok</artifactId>
    <version>1.16.20</version>
    <scope>provided</scope>
</dependency>

创建包com.zy.example.entity，新建UserEntity.java：

package com.zy.example.entity;

import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;

/**
 * User实体类  lombok使用
 * lombok底层使用字节码技术 ASM 修改字节码文件，生成get和set方法
 * 
 * @author zy
 * @since  2020-2-4
 */
@Slf4j
@Getter
@Setter
public class UserEntity  {

    private String userName;

    private Integer age;

    @Override
    public String toString() {
        return "UserEntity [userName=" + userName + ", age=" + age + "]";
    }

    /**
     * 测试
     * @param args
     */
    public static void main(String[] args) {
        UserEntity userEntity = new UserEntity();
        userEntity.setUserName("zhangsan");
        userEntity.setAge(20);
        System.out.println(userEntity.toString());
        log.info("####我是日志##########");
    }
}

5.2、Lombok工作原理分析

会发现在Lombok使用的过程中，只需要添加相应的注解，无需再为此写任何代码。自动生成的代码到底是如何产生的呢？

核心之处就是对于注解的解析上。JDK5引入了注解的同时，也提供了两种解析方式。

运行时解析

运行时能够解析的注解，必须将@Retention设置为RUNTIME，这样就可以通过反射拿到该注解。java.lang,reflect反射包中提供了一个接口AnnotatedElement，该接口定义了获取注解信息的几个方法，Class、Constructor、Field、Method、Package等都实现了该接口，对反射熟悉的朋友应该都会很熟悉这种解析方式。

编译时解析

编译时解析有两种机制，分别简单描述下：

1）Annotation Processing Tool

apt自JDK5产生，JDK7已标记为过期，不推荐使用，JDK8中已彻底删除，自JDK6开始，可以使用Pluggable Annotation Processing API来替换它，apt被替换主要有2点原因：

api都在com.sun.mirror非标准包下
没有集成到javac中，需要额外运行

2）Pluggable Annotation Processing API

JSR 269自JDK6加入，作为apt的替代方案，它解决了apt的两个问题，javac在执行的时候会调用实现了该API的程序，这样我们就可以对编译器做一些增强，这时javac执行的过程如下：

Lombok本质上就是一个实现了“JSR 269 API”的程序。在使用javac的过程中，它产生作用的具体流程如下：

javac对源代码进行分析，生成了一棵抽象语法树（AST）；
运行过程中调用实现了“JSR 269 API”的Lombok程序；
此时Lombok就对第一步骤得到的AST进行处理，找到@Data注解所在类对应的语法树（AST），然后修改该语法树（AST），增加getter和setter方法定义的相应树节点；
javac使用修改后的抽象语法树（AST）生成字节码文件，即给class增加新的节点（代码块）；

在Lombok源码中，对应注解的实现都在HandleXXX中，比如@Getter注解的实现是HandleGetter.handle()。还有一些其它类库使用这种方式实现，比如Google Auto、Dagger等等。

5.3. Lombok的优缺点

优点：

能通过注解的形式自动生成构造器、getter/setter、equals、hashcode、toString等方法，提高了一定的开发效率；
让代码变得简洁，不用过多的去关注相应的方法；
属性做修改时，也简化了维护为这些属性所生成的getter/setter方法等；

缺点：

不支持多种参数构造器的重载；
虽然省去了手动创建getter/setter方法的麻烦，但大大降低了源代码的可读性和完整性，降低了阅读源代码的舒适度；

5.4. 总结

Lombok虽然有很多优点，但Lombok更类似于一种IDE插件，项目也需要依赖相应的jar包。Lombok依赖jar包是因为编译时要用它的注解，为什么说它又类似插件？因为在使用时，eclipse或IntelliJ IDEA都需要安装相应的插件，在编译器编译时通过操作AST（抽象语法树）改变字节码生成，变向的就是说它在改变java语法。它不像spring的依赖注入或者mybatis的ORM一样是运行时的特性，而是编译时的特性。这里我个人最感觉不爽的地方就是对插件的依赖！因为Lombok只是省去了一些人工生成代码的麻烦，但IDE都有快捷键来协助生成getter/setter等方法，也非常方便。

知乎上有位大神发表过对Lombok的一些看法：

这是一种低级趣味的插件，不建议使用。JAVA发展到今天，各种插件层出不穷，如何甄别各种插件的优劣？能从架构上优化你的设计的，能提高应用程序性能的 ，
实现高度封装可扩展的...， 像lombok这种，像这种插件，已经不仅仅是插件了，改变了你如何编写源码，事实上，少去了代码你写上去又如何？ 
如果JAVA家族到处充斥这样的东西，那只不过是一坨披着金属颜色的屎，迟早会被其它的语言取代。

虽然话糙但理确实不糙，试想一个项目有非常多类似Lombok这样的插件，个人觉得真的会极大的降低阅读源代码的舒适度。

虽然非常不建议在属性的getter/setter写一些业务代码，但在多年项目的实战中，有时通过给getter/setter加一点点业务代码，能极大的简化某些业务场景的代码。所谓取舍，也许就是这时的舍弃一定的规范，取得极大的方便。

我现在非常坚信一条理念，任何编程语言或插件，都仅仅只是工具而已，即使工具再强大也在于用的人，就如同小米加步枪照样能赢飞机大炮的道理一样。结合具体业务场景和项目实际情况，无需一味追求高大上的技术，适合的才是王道。

Lombok有它的得天独厚的优点，也有它避之不及的缺点，熟知其优缺点，在实战中灵活运用才是王道。

六、源码下载

源码放置在https://gitee.com/zyly2033/spring-boot-helloworld;

参考文章：

[1] Lombok介绍、使用方法和总结(部分转载)

[2] spring中注解的实现原理

posted @ 2020-02-02 18:43 大奥特曼打小怪兽阅读(431) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

大奥特曼打小怪兽