【SpringBoot框架篇】3.优化代码,让代码更简洁高效

痛定思痛。 2023-03-14 10:41 15阅读 0赞

### 文章目录 ###

*  简介
 *  lombok插件
 *   *  idea安装lombok插件
     *  在pom.xml文件中引入依赖
     *  实体类注解
     *   *  @Getter
         *  @Setter
         *  @ToString
         *  @Data
         *  @Slf4j
 *  优化toString方法
 *   *  引入依赖
     *  定义一个基类
     *  继承基类
 *  定义全局异常处理类
 *   *  @ControllerAdvice
     *  @ExceptionHandler
     *  应用如下
 *  优化接口日志打印
 *   *  AOP描述
     *  引入依赖
     *  相关注解描述
     *  应用实在
     *   *  编写切面类代码
         *  编写测试的web接口
         *  模拟postman调用接口
         *  运行结果如下
 *  项目配套代码

# 简介 #

该文章主要教大家如何去除重复性的代码,减少代码的行数

# lombok插件 #

Lombok是一个可以通过简单的注解形式来帮助我们简化消除一些必须有但显得很臃肿的Java代码的工具，通过使用对应的注解，可以在编译源码的时候生成对应的方法。

## idea安装lombok插件 ##

![在这里插入图片描述][20200517141239580.png]  
![在这里插入图片描述][20200517141213414.png]  
下载完成 重新下idea就能生效了

## 在pom.xml文件中引入依赖 ##

<dependency>
           <groupId>org.projectlombok</groupId>
           <artifactId>lombok</artifactId>
      </dependency>

## 实体类注解 ##

### @Getter ###

@Getter可以自动生成get方法

### @Setter ###

@Setter可以自动生成set方法

### @ToString ###

@ToString可以重写toString方法,打印对象拥有的属性信息

如果不重写toString方法,实体类对象的toString方法只会输出对象内存地址信息,  
![在这里插入图片描述][20200517145552323.png]  
一般我们会手动重写toString方法，把对象的属性信息打印出来,代码如下，使用@ToString注解,下面的代码就可以删掉了。

@Override
        public String toString(){ 
                return "User{" +
                        "username='" + username + '\'' +
                        ", password='" + password + '\'' +
                        ", age='" + age + '\'' +
                        '}';
        }

### @Data ###

@Data注解包含@Getter,@Setter,@ToString这3个注解的功能  
我一般都用@Data注解  
代码应用如下

@Data
    public class User  { 
    
        public User(){  }
    
        public User(String username,String password,Integer age){ 
            this.setUsername(username);
            this.setPassword(password);
            this.setAge(age);
            System.out.println(this);
        }
    
        private String username;
        private String password;
        private Integer age;
    
        public static void main(String[] args) { 
            new User("Dominick Li","123456",25);
        }
    }

运行main函数结果如下  
![在这里插入图片描述][20200517145439567.png]  
我们可以查看编译后的源码文件![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70]

### @Slf4j ###

@Slf4j可以去除log对象的声明  
我们一般在需要打印日志的类里都要写下面代码

public class LogTest { 
        
        public static final Logger logger= LoggerFactory.getLogger(LogTest.class);
        public static void main(String[] args) { 
            logger.info("打印info级别日志");
        }
    }

优化后的代码如下

@Slf4j
    public class LogTest { 
        public static void main(String[] args) { 
            log.info("打印info级别日志");
        }
    }

# 优化toString方法 #

如果项目不允许使用lombok插件,那我们可以通过使用commons.lang3包下的ToStringBuilder类实现重写toString方法

## 引入依赖 ##

<dependency>
           <groupId>org.apache.commons</groupId>
           <artifactId>commons-lang3</artifactId>
           <version>3.7</version>
     </dependency>

## 定义一个基类 ##

通常我们会在基类定义一些通用属性,如记录的id,创建时间,修改时间  
我们把重写toString的方法在基类中定义

public  class BaseModel implements Serializable { 
    
        private static final long serialVersionUID = 2863256929817929825L;
        private Integer id;
        private Date createTime;
        private Date lastmodifiedTime;
    	//省略 get set方法
        /** * 把对象转换成json字符 * 默认toString方法打印的是对象内存地址 */
        @Override
        public String toString() { 
            return ToStringBuilder.reflectionToString(this, ToStringStyle.SHORT_PREFIX_STYLE);
        }
    }

ToStringStyle的样式有很多种,大家可以自己试试别的样式,如JSON\_STYLE。  
![在这里插入图片描述][20200517152313884.png]

## 继承基类 ##

在构造方法中打印了当前对象信息

public class Role  extends BaseModel{ 
    
        public Role(){ }
    
        public Role(String roleName, Date createDate){ 
            this.roleName=roleName;
            this.setCreateTime(createDate);
            System.out.println(this);
        }
        private String roleName;
        public String getRoleName() { 
            return roleName;
        }
        public void setRoleName(String roleName) { 
            this.roleName = roleName;
        }
    
        public static void main(String[] args) { 
            new Role("admin",new Date());
        }
    
    }

运行结果如下  
![在这里插入图片描述][2020051715115618.png]

# 定义全局异常处理类 #

## @ControllerAdvice ##

使用@ControllerAdvice注解接收全局信息

## @ExceptionHandler ##

可以在@ExceptionHandler注解中指定处理的异常类

## 应用如下 ##

如果接口代码中没有try catch 异常的话,Exception类型的异常信息则会被ExceptionHndler方法处理

@ControllerAdvice
    @Slf4j
    public class GlobalExceptionController { 
        private static final String ERROR_MESSAGE = "系统内部错误,请联系管理员！";
    
        @ExceptionHandler(value = Exception.class)
        @ResponseBody
        public String ExceptionHndler(Exception e) { 
            if (e instanceof FileNotFoundException) { 
                //可以自定义根据不同的异常类型,做一些代码处理
            }
            log.error("global error:{}", e);
            return ERROR_MESSAGE;
        }
    }

# 优化接口日志打印 #

我们可以通过aop来打印接口请求参数,返回结果,处理时间等信息.

## AOP描述 ##

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术.AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

## 引入依赖 ##

<properties>
           <aspectj.version>1.9.5</aspectj.version>
       </properties>
           <dependency>
               <groupId>org.aspectj</groupId>
               <artifactId>aspectjrt</artifactId>
               <version>${aspectj.version}</version>
           </dependency>
    
           <dependency>
               <groupId>org.aspectj</groupId>
               <artifactId>aspectjweaver</artifactId>
               <version>${aspectj.version}</version>
           </dependency>

## 相关注解描述 ##

<table> 
 <thead> 
  <tr> 
   <th>注解</th> 
   <th>功能描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>@Aspect</td> 
   <td>作用是把当前类标识为一个切面供容器读取</td> 
  </tr> 
  <tr> 
   <td>@Pointcut</td> 
   <td>Pointcut是植入Advice的触发条件。每个Pointcut的定义包括2部分，一是表达式，二是方法签名。方法签名必须是 public及void型。可以将Pointcut中的方法看作是一个被Advice引用的助记符，因为表达式不直观，因此我们可以通过方法签名的方式为 此表达式命名。因此Pointcut中的方法只需要方法签名，而不需要在方法体内编写实际代码。</td> 
  </tr> 
  <tr> 
   <td>@Around</td> 
   <td>环绕增强，相当于MethodInterceptor</td> 
  </tr> 
  <tr> 
   <td>@AfterReturning</td> 
   <td>后置增强，相当于AfterReturningAdvice，方法正常退出时执行</td> 
  </tr> 
  <tr> 
   <td>@Before</td> 
   <td>标识一个前置增强方法，相当于BeforeAdvice的功能，相似功能的还有</td> 
  </tr> 
  <tr> 
   <td>@AfterThrowing</td> 
   <td>异常抛出增强，相当于ThrowsAdvice</td> 
  </tr> 
  <tr> 
   <td>@After</td> 
   <td>final增强，不管是抛出异常或者正常退出都会执行</td> 
  </tr> 
 </tbody> 
</table>

本文用到了@Aspect ,@Pointcut,@Around,@AfterThrowing|这4个注解.

## 应用实在 ##

### 编写切面类代码 ###

编写一个切面类,然后通关@Pointcut注解指定要切入的方法  
下面代码中用到了lombok插件,如果你没有使用的话,需要手动声明get set方法,还有log对象

@Aspect
    @Slf4j
    @Component
    public class LogPointcut { 
    
        /** * 对controller包下的所有类里的方法进行代理 */
        @Pointcut("execution(public * com.ljm.boot.simplifycode.controller.*.*(..)))")
        public  void requestServer(){ 
    
        }
    
        /** * 环绕增强通知 */
        @Around("requestServer()")
        public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable { 
            long start = System.currentTimeMillis();
            ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            HttpServletRequest request = attributes.getRequest();
            Object result = proceedingJoinPoint.proceed();
            RequestInfo requestInfo = new RequestInfo();
            requestInfo.setIp(request.getRemoteAddr());
            requestInfo.setUrl(request.getRequestURL().toString());
            requestInfo.setHttpMethod(request.getMethod());
            requestInfo.setClassMethod(String.format("%s.%s", proceedingJoinPoint.getSignature().getDeclaringTypeName(),
                    proceedingJoinPoint.getSignature().getName()));
            requestInfo.setRequestParams(getRequestParamsByProceedingJoinPoint(proceedingJoinPoint));
            requestInfo.setResult(result);
            requestInfo.setTimeCost(System.currentTimeMillis() - start);
            log.info("Request Info : {}", requestInfo);
            return result;
        }
    
        /** * 异常抛出增强 */
        @AfterThrowing(pointcut = "requestServer()", throwing = "e")
        public void doAfterThrow(JoinPoint joinPoint, RuntimeException e) { 
            ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            HttpServletRequest request = attributes.getRequest();
            RequestErrorInfo requestErrorInfo = new RequestErrorInfo();
            requestErrorInfo.setIp(request.getRemoteAddr());
            requestErrorInfo.setUrl(request.getRequestURL().toString());
            requestErrorInfo.setHttpMethod(request.getMethod());
            requestErrorInfo.setClassMethod(String.format("%s.%s", joinPoint.getSignature().getDeclaringTypeName(),
                    joinPoint.getSignature().getName()));
            requestErrorInfo.setRequestParams(getRequestParamsByJoinPoint(joinPoint));
            requestErrorInfo.setException(e);
            log.info("Error Request Info : {}", requestErrorInfo);
        }
    
        /** * 获取入参 * @param proceedingJoinPoint * */
        private Map<String, Object> getRequestParamsByProceedingJoinPoint(ProceedingJoinPoint proceedingJoinPoint) { 
            //参数名
            String[] paramNames = ((MethodSignature)proceedingJoinPoint.getSignature()).getParameterNames();
            //参数值
            Object[] paramValues = proceedingJoinPoint.getArgs();
            return buildRequestParam(paramNames, paramValues);
        }
    
        private Map<String, Object> getRequestParamsByJoinPoint(JoinPoint joinPoint) { 
            //参数名
            String[] paramNames = ((MethodSignature)joinPoint.getSignature()).getParameterNames();
            //参数值
            Object[] paramValues = joinPoint.getArgs();
            return buildRequestParam(paramNames, paramValues);
        }
    
        private Map<String, Object> buildRequestParam(String[] paramNames, Object[] paramValues) { 
            Map<String, Object> requestParams = new HashMap<>(paramNames.length);
            for (int i = 0; i < paramNames.length; i++) { 
                Object value = paramValues[i];
                //如果是文件对象
                if (value instanceof MultipartFile) { 
                    MultipartFile file = (MultipartFile) value;
                    value = file.getOriginalFilename();  //获取文件名
                }
                requestParams.put(paramNames[i], value);
            }
            return requestParams;
        }
        
        @Data
        public class RequestInfo implements Serializable { 
            private String ip; //ip地址
            private String url; //请求路径
            private String httpMethod; //方法类型
            private String classMethod; //类和方法名称
            private Object requestParams; //请求参数
            private Object result; //返回的结果
            private Long timeCost; //执行时长
        }
    
        @Data
        public class RequestErrorInfo implements Serializable  { 
            private String ip;
            private String url;
            private String httpMethod;
            private String classMethod;
            private Object requestParams;
            private RuntimeException exception; //异常类型
        }
    }

### 编写测试的web接口 ###

@RestController
    public class TestController { 
        @RequestMapping("/login")
        public String  login(@RequestBody User user){ 
            if(user.getUsername().equals("admin") && user.getPassword().equals("123")){ 
                return "登录成功";
            }
            return "登录失败";
        }
    }

### 模拟postman调用接口 ###

public class TestPrint { 
        public static void main(String[] args) { 
            RestTemplate restTemplate=new RestTemplate();
            HashMap param=new HashMap();
            param.put("username","admin");
            param.put("password","123");
            String result=restTemplate.postForObject("http://localhost:8003/login",param,String.class);
            System.out.println(result);
        }
    }

### 运行结果如下 ###

![在这里插入图片描述][20200517160034445.png]  
日志的完整json格式数据如下

RequestInfo: 
    LogPointcut.RequestInfo(
    ip=127.0.0.1,
    url=http: //localhost:8003/login,
    httpMethod=POST,
    classMethod=com.ljm.boot.simplifycode.controller.TestController.login,
    requestParams={
      user=User(username=admin,
      password=123,
      age=null)
    },
    result=登录成功,
    timeCost=7
    )

# 项目配套代码 #

[github地址][github]

创作不易,要是觉得我写的对你有点帮助的话,麻烦在github上帮我点下 **Star**

【SpringBoot框架篇】其它文章如下,后续会继续更新。

*  [1.搭建第一个springboot项目][1._springboot]
 *  [2.Thymeleaf模板引擎实战][2.Thymeleaf]
 *  [3.优化代码,让代码更简洁高效][3.]
 *  [4.集成jta-atomikos实现分布式事务][4._jta-atomikos]
 *  [5.分布式锁的实现方式][5.]
 *  [6.docker部署,并挂载配置文件到宿主机上面][6.docker]
 *  [7.项目发布到生产环境][7.]
 *  [8.搭建自己的spring-boot-starter][8._spring-boot-starter]
 *  [9.dubbo入门实战][9.dubbo]
 *  [10.API接口限流实战][10.API]
 *  [11.Spring Data Jpa实战][11.Spring Data Jpa]
 *  [12.使用druid的monitor工具查看sql执行性能][12._druid_monitor_sql]
 *  [13.使用springboot admin对springboot应用进行监控][13._springboot admin_springboot]
 *  [14.mybatis-plus实战][14.mybatis-plus]
 *  [15.使用shiro对web应用进行权限认证][15._shiro_web]
 *  [16.security整合jwt实现对前后端分离的项目进行权限认证][16.security_jwt]
 *  [17.使用swagger2生成RESTful风格的接口文档][17._swagger2_RESTful]
 *  [18.使用Netty加websocket实现在线聊天功能][18._Netty_websocket]
 *  [19.使用spring-session加redis来实现session共享][19._spring-session_redis_session]
 *  [20.自定义@Configuration配置类启用开关][20._Configuration]
 *  [21.对springboot框架编译后的jar文件瘦身][21._springboot_jar]
 *  [22.集成RocketMQ实现消息发布和订阅][22._RocketMQ]

[20200517141239580.png]: /images/20230312/5b59bd9d30da4243bbd5bb27047bc285.png
[20200517141213414.png]: /images/20230312/fc3ea56c4b1b41e48e5a2015cc68fe11.png
[20200517145552323.png]: /images/20230312/6c9c428d4f084db9a0302d0ab72635d3.png
[20200517145439567.png]: /images/20230312/4724513251e24e29ab518cdc2d18599f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70]: /images/20230312/a1928dba550e4d589e8a66257b31c238.png
[20200517152313884.png]: /images/20230312/114af2e15d424160a98abf95b1dbcd53.png
[2020051715115618.png]: /images/20230312/95364cfa878041c186d44bf697161229.png
[20200517160034445.png]: /images/20230312/58a5a5a7405b41dda0aaba19002cd6d8.png
[github]: https://github.com/Dominick-Li/springboot-master
[1._springboot]: https://blog.csdn.net/ming19951224/article/details/106159309
[2.Thymeleaf]: https://blog.csdn.net/ming19951224/article/details/106160322
[3.]: https://blog.csdn.net/ming19951224/article/details/106173840
[4._jta-atomikos]: https://blog.csdn.net/ming19951224/article/details/105753333
[5.]: https://blog.csdn.net/ming19951224/article/details/106205332
[6.docker]: https://blog.csdn.net/ming19951224/article/details/105923548
[7.]: https://blog.csdn.net/ming19951224/article/details/106212271
[8._spring-boot-starter]: https://blog.csdn.net/ming19951224/article/details/106224172
[9.dubbo]: https://blog.csdn.net/ming19951224/article/details/106225928
[10.API]: https://blog.csdn.net/ming19951224/article/details/106227451
[11.Spring Data Jpa]: https://blog.csdn.net/ming19951224/article/details/106308544
[12._druid_monitor_sql]: https://blog.csdn.net/ming19951224/article/details/106317893
[13._springboot admin_springboot]: https://blog.csdn.net/ming19951224/article/details/107138845
[14.mybatis-plus]: https://blog.csdn.net/ming19951224/article/details/107145780
[15._shiro_web]: https://blog.csdn.net/ming19951224/article/details/107192585
[16.security_jwt]: https://blog.csdn.net/ming19951224/article/details/107733689
[17._swagger2_RESTful]: https://blog.csdn.net/ming19951224/article/details/107741541
[18._Netty_websocket]: https://blog.csdn.net/ming19951224/article/details/108555917
[19._spring-session_redis_session]: https://blog.csdn.net/ming19951224/article/details/112758560
[20._Configuration]: https://blog.csdn.net/ming19951224/article/details/112759717
[21._springboot_jar]: https://dominick-li.blog.csdn.net/article/details/119024251
[22._RocketMQ]: https://dominick-li.blog.csdn.net/article/details/119523197