Springboot 自定义注解AOP实现时间参数格式转换

2022-06-13 423

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： Springboot 自定义注解AOP实现时间参数格式转换

前言

场景：

前端传过来的时间参数，我们后端自定义时间格式转化使用，想转成什么就转成什么。

不同业务场景，跟前端对接，一种控件基本时间参数是固定格式的，为了避免前端去转换时间参数的格式，跟前端约定好，让他们固定传递一种格式，后端自己看需求转换格式使用即可。

效果：

① 从 yyyy-MM-dd HH:mm:ss 转换成 yyyy-MM-dd 使用：

② 从 yyyyMMddHHmmss 转换成 yyyy-MM-dd HH:mm:ss 使用：

③不再举例，其实就是自己想怎么转就怎么转。

正文

实战

pom.xml (aop依赖、lombok依赖)：

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjtools</artifactId>
            <version>1.9.5</version>
        </dependency>
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.0</version>
        </dependency>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.3.0</version>
        </dependency>

核心（自定义注解+拦截器）：

自定义注解一：

DateField.java

用途：用于标记哪个字段需要进行时间格式转换，配置旧格式，新格式（都可写默认值）。

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 * @Author: JCccc
 * @Date: 2022-4-11 18:45
 * @Description:
 */
@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface DateField {
    String oldPattern() default DateUtil.YYYY_MM_DD_HH_MM_SS;
    //新格式可以写默认也可以不写，如果业务比较固定，那么新时间格式和旧时间格式都可以固定写好
    String newPattern() default "";
}

自定义注解二：

NeedDateFormatConvert.java

用途：用于标记哪个接口需要进行AOP方式时间格式转换。

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 * @Author: JCccc
 * @Date: 2022-4-11 18:44
 * @Description:
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface NeedDateFormatConvert {
}

拦截器：

DateFormatAspect.java

用途：核心转换实现逻辑。

import com.jctest.dotestdemo.util.DateUtil;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import java.lang.reflect.Field;
import java.util.Objects;
/**
 * @Author: JCccc
 * @Date: 2022-4-11 18:57
 * @Description:
 */
@Aspect
@Component
public class DateFormatAspect {
    private static Logger log = LoggerFactory.getLogger(DateFormatAspect.class);
    @Pointcut("@annotation(com.jctest.dotestdemo.aop.dateFormat.NeedDateFormatConvert)")
    public void pointCut() {
    }
    @Around("pointCut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        //转换
        dateFormat(joinPoint);
        return joinPoint.proceed();
    }
    public void dateFormat(ProceedingJoinPoint joinPoint) {
        Object[] objects = null;
        try {
            objects = joinPoint.getArgs();
            if (objects.length != 0) {
                for (int i = 0; i < objects.length; i++) {
                    //当前只支持判断对象类型参数
                    convertObject(objects[i]);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("参数异常");
        }
    }
    /**
     * 转换对象里面的值
     *
     * @param obj
     * @throws IllegalAccessException
     */
    private void convertObject(Object obj) throws IllegalAccessException {
        if (Objects.isNull(obj)) {
            log.info("当前需要转换的object为null");
            return;
        }
        Field[] fields = obj.getClass().getDeclaredFields();
        for (Field field : fields) {
            boolean containFormatField = field.isAnnotationPresent(DateField.class);
            if (containFormatField) {
                //获取访问权
                field.setAccessible(true);
                DateField annotation = field.getAnnotation(DateField.class);
                String oldPattern = annotation.oldPattern();
                String newPattern = annotation.newPattern();
                Object dateValue = field.get(obj);
                if (Objects.nonNull(dateValue) && StringUtils.hasLength(oldPattern) && StringUtils.hasLength(newPattern)) {
                    String newDateValue = DateUtil.strFormatConvert(String.valueOf(dateValue), oldPattern, newPattern);
                    if (Objects.isNull(newDateValue)){
                        log.info("当前需要转换的日期数据转换失败 dateValue = {}",dateValue.toString());
                        throw new RuntimeException("参数转换异常");
                    }
                    field.set(obj, newDateValue);
                }
            }
        }
    }
}