自定义注解+反射

需求：在做权限平台的时候，需要写一个查询审计记录列表的接口。这个需求看起来非常简单，就是从数据库单表里面查出数据，返回json格式。然而，数据库里有两列，修改前和修改后的json。需要翻译成字符串整个返回。

数据库的source字段的json长这样：

{
  "id": "qfangyang3268A8C5DCD79003AE0530A101229ABA1",
  "user_id": "fangyang3",
  "permission_id": "268A8C5DCD79003AE0530A101229ABA1",
  "dimension_detail_id": "[{\"1\":[\"25BE5B44EA4D05FCE0530A10122994D6\",\"25BE5CA451FA0742E0530A1012271A15\"]}]",
  "status": "USED",
  "end_date": "",
  "is_delete": false
}

其中dimension_detail_id的翻译是这个需求的难点，我想了好久。这是一个维度和维度明细的组合id，“1”为维度表的id，"25BE5B44EA4D05FCE0530A10122994D6","25BE5CA451FA0742E0530A1012271A15"为维度明细表的id。

我需要通过这串id组合翻译成这样。因为格式会根据策略而改变，所以要做到通用。

解决方案：

1.自定义审计格式化的注解AuditFormatter

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.TYPE})
public @interface AuditFormatter {
    AuditType type() default AuditType.String;

    /**
     * 字段中文名
     */
    String name() default "";

    /**
     * 格式化
     *
     * @return
     */
    String formatter() default "";
}

public enum AuditType {

    Bean,String,Date,Json
    
}

 

2.创建一个CommonAudit的抽象类

@Component
public abstract class CommonAudit {

}

2.因为现在只是先做用户权限策略（userPermissionStrategy），所以先以用户权限策略为例，创建UserPermissionAudit类继承CommonAudit。

@Component
@AuditFormatter(name="用户权限",type=AuditType.Bean)
public class UserPermissionAudit extends CommonAudit {

    @AuditFormatter(name = "用户")
    private String userId;
    @AuditFormatter(name = "权限",formatter="select name_$i18n from $appId_permission where id=? ")
    private String permission_id;
    @AuditFormatter(name = "开始时间", type=AuditType.Date, formatter="yyyy-MM")
    private Date start_date;
    @AuditFormatter(name = "结束时间", type=AuditType.Date, formatter="yyyy-MM")
    private Date end_date;
    //只用来临时放数据
    private String dimension_detail_id;
    @AuditFormatter(name = "",type=AuditType.Bean)
    private List<UserPermissionDimensionAudit> dimensions;


    public String getUserId() {
        return userId;
    }
    public void setUserId(String userId) {
        this.userId = userId;
    }
    public String getPermission_id() {
        return permission_id;
    }
    public void setPermission_id(String permission_id) {
        this.permission_id = permission_id;
    }
    public Date getStart_date() {
        return start_date;
    }
    public void setStart_date(Date start_date) {
        this.start_date = start_date;
    }
    public Date getEnd_date() {
        return end_date;
    }
    public void setEnd_date(Date end_date) {
        this.end_date = end_date;
    }
    public String getDimension_detail_id() {
        return dimension_detail_id;
    }
    public void setDimension_detail_id(String dimension_detail_id) {
        this.dimension_detail_id = dimension_detail_id;
        if(StringUtil.isNotEmpty(dimension_detail_id)) {
            List<Map<String,List<String>>> list = JsonUtil.json2Bean(dimension_detail_id, new TypeReference<List<Map<String,List<String>>>>(){});
            if(null!=list&&list.size()>0) {
                List<UserPermissionDimensionAudit> dimensions = new ArrayList<UserPermissionDimensionAudit>();
                for(Map<String,List<String>> map : list) {
                    for(String id : map.keySet()) {
                        UserPermissionDimensionAudit dimension = new UserPermissionDimensionAudit();
                        dimension.setId(id);
                        List<String> details = map.get(id);
                        List<UserPermissionDimensionDetailAudit> dimensionDetails = new ArrayList<UserPermissionDimensionDetailAudit>();
                        for(String detail : details) {
                            UserPermissionDimensionDetailAudit dimensionDetail = new UserPermissionDimensionDetailAudit();
                            dimensionDetail.setId(detail);
                            dimensionDetails.add(dimensionDetail);
                        }
                        dimension.setDetails(dimensionDetails);
                        dimensions.add(dimension);
                    }
                }
                setDimensions(dimensions);
            }
        }
    }
    public List<UserPermissionDimensionAudit> getDimensions() {
        return dimensions;
    }
    public void setDimensions(List<UserPermissionDimensionAudit> dimensions) {
        this.dimensions = dimensions;
    }

}

3.但是UserPermissionAudit中的dimension_detail_id存的只是一串id呀，我要的应该是id对应的对象，所以，接着创建用户权限维度类，同样继承CommonAudit

@Component
@AuditFormatter(name="维度",type=AuditType.Bean)
public class UserPermissionDimensionAudit extends CommonAudit {

    @AuditFormatter(name = "维度名称", formatter="select name_$i18n from $appId_dimension where id=? ")
    private String id;
    @AuditFormatter(name = "",type=AuditType.Bean)
    private List<UserPermissionDimensionDetailAudit> details;
    
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public List<UserPermissionDimensionDetailAudit> getDetails() {
        return details;
    }

    public void setDetails(List<UserPermissionDimensionDetailAudit> details) {
        this.details = details;
    }
    
}

4.维度里面又有维度明细，继续往下创建

@Component
@AuditFormatter
public class UserPermissionDimensionDetailAudit extends CommonAudit {

    @AuditFormatter(name = "维度明细名称", formatter="select name_$i18n from $appId_dimension_detail where id=? ")
    private String id;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

5.接下来就是写接口的逻辑了

@Service
public class SystemAuditService {

    @Autowired
    private ApplicationDao applicationDao;
    @Autowired
    private SystemAuditDao systemAuditDao;
    @Autowired
    private JdbcDao jdbcDao;

    /**
     * 查询权限审计列表
     *
     * @param authzLogSearchParam
     * @return
     */
    public JsonResult queryAuthzLog(AuthzLogSearchParam authzLogSearchParam) {
        // 条件查询时,应用id为必填项
        if (StringUtils.isNotEmpty(authzLogSearchParam.getSearch())
                && StringUtils.isEmpty(authzLogSearchParam.getApplicationId())) {
            return JsonResultEnum.PARAM_IS_EMP.jsonResult();
        }
        Page<AuthzLogVo> authzLogVoPage = systemAuditDao.queryAuthzLog(authzLogSearchParam);
        List<AuthzLogVo> data = authzLogVoPage.getData();
        for (AuthzLogVo authzLogVo : data) {
            String strategyId = authzLogVo.getStrategyId();
            String appId = authzLogVo.getApplicationId();
            // 处理修改前
            String source = authzLogVo.getSource();
            if (StringUtils.isNotEmpty(source)) {
                authzLogVo.setShowSource(formatter(appId, strategyId, source));
            }
            // 处理修改后
            String target = authzLogVo.getTarget();
            if (StringUtils.isNotEmpty(target)) {
                authzLogVo.setShowTarget(formatter(appId, strategyId, target));
            }
            // 来源详情直接展示bussinessId
            // 处理对象列
            String type = authzLogVo.getType();
            // 数据回收类型的对象列展示应用名称
            if (type.equals(AuthzLogTypeEnum.RECYCLE)) {
                ApplicationEntity application = applicationDao.findApplicationById(authzLogVo.getApplicationId());
                if (null != application) {
                    authzLogVo.setObj(application.getName());
                }
            } else if (type.equals(AuthzLogTypeEnum.REQUESTNOTE)) {
                // 申请单类型的对象列展示用户id
                if (StringUtils.isNotEmpty(target)) {
                    Map<String, String> map = JsonUtil.json2Bean(target, new TypeReference<Map<String, String>>() {});
                    if (map.containsKey("user_id") || map.containsKey("user_id")) {
                        String userId = map.get("user_id");
                        authzLogVo.setObj(userId);
                    }
                }
            }
        }
        return JsonResultEnum.SUCCESS.jsonResult(authzLogVoPage);
    }

    public String formatter(String appId, String strategyId, String source) {
        StringBuilder sb = new StringBuilder();
        String type = strategyId.replaceAll("Strategy", "Audit");
        CommonAudit common = SpringUtil.getBean(type, CommonAudit.class);
        common = JsonUtil.json2Bean(source, common.getClass());
        AuditFormatter annotation = common.getClass().getAnnotation(AuditFormatter.class);
        excute(sb,annotation,common,appId);
        return sb.toString();
    }

    public void excute(StringBuilder sb, AuditFormatter annotation, Object value,String appId) {
        // bean类型，继续递归
        if (annotation.type().equals(AuditType.Bean)) {
            //如果是CommonAudit对象
            if(value instanceof CommonAudit) {
                if(StringUtil.isNotEmpty(annotation.name()))
                    sb.append(annotation.name() + ":<br/>");
                Field[] fields = value.getClass().getDeclaredFields();
                for (Field field : fields) {
                    if (field.isAnnotationPresent(AuditFormatter.class)) {
                        field.setAccessible(true);
                        AuditFormatter anno = field.getAnnotation(AuditFormatter.class);
                        try {
                            Object v = field.get(value);
                            excute(sb, anno, v, appId);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            }else if(value instanceof List) {
                //还有可能是List
                List<?> list = (List<?>)value;
                for(Object t : list) {
                    excute(sb, annotation, t,appId);
                }
            }
        } else if (annotation.type().equals(AuditType.String)) {
            if(StringUtil.isNotEmpty(annotation.name()))
                sb.append(annotation.name() + ":");
            if(StringUtil.isNotEmpty(annotation.formatter())) {
                Map<String,Object> map = jdbcDao.query(translation(annotation.formatter(),appId), value);
                sb.append(map.values().iterator().next() + "<br/>");
            }else {
                sb.append(value + "<br/>");
            }
        } else if (annotation.type().equals(AuditType.Date)) {
            if(StringUtil.isNotEmpty(annotation.name()))
                sb.append(annotation.name() + ":");
            if(value instanceof Date) {
                sb.append(DateUtils.formatDate((Date)value, annotation.formatter()) + "<br/>");
            }else {
                sb.append(value + "<br/>");
            }
        }
    }

    /**
     * 以后可能会拓展成多参数翻译
     * @param value
     * @param params
     * @return
     */
    private String translation(String value,String appId) {
        value = value.replaceAll("\\$appId",appId);
        value = value.replaceAll("\\$i18n", jdbcDao.getI18n());
        return value;
    }

}

主要的翻译处理逻辑在formatter和excute里面。主要用到了自定义注解+反射来完成这次需求。

通过这次看似简单的需求，却不简单，这也反应出了我在技术上的不足。毕业一年了，之前在工作中完全没用过自定义注解和反射。所以一开始做这个需求的时候，我几乎是硬编码写完的。我的大佬给了我方向让我去做，在做的过程，还去了解了一些设计模式，学习了策略模式和适配器模式。