AOP+自定义注解+策略模式 记录操作日志，避免过多的if else

演示案例代码

首先看下业务需求：

如图所示，就是将用户的操作行为记录到日志表中,而且有些内容是动态的，如图是六种操作，但是后期肯定是要增加的，也就是说就这六种需要记录到日志表中，日志表所对应的对象是AnalysisMessage,标题，内存，接收时间，对应对象中字段名为title,content,create_time；看到需求的第一眼就想到AOP来实现；但是只是使用AOP的会写一些if else,后期如果要增加一些是不是要增加if else,后期维护起来是相当麻烦，我就想到了使用策略模式；

这里有个前提就是必须这些操作是成功之后才可以入库，所以我选择了使用@Around，在切入点前后切入内容;因为这样可以在调用接口结束之后拿到接口返回的参数，从而判断接口是否调用成功；下面就用代码来实现一下

首先我会将这个操作以key value 的形式存放到json文件中，以url 为key,操作title为value;
在项目的resources目录下有个test.json文件，内容如下：

{
  "/user/addUser": "账号添加",
  "/user/isLock": "账号禁用",
  "/user/delUser": "账号删除"
}

这里只列举三种操作，之所以存放到json文件中，目的是想让本案例更简化，不想涉及到数据库，所以这个演示案例只放到了json文件中；在生成环境中是配置在数据库中的；
在项目启动的时候将json文件中的内容以key value 的形式加载到map中；
代码实现如下：

@Component
@Slf4j
public class MessageInitHandler implements CommandLineRunner {

    /**
     * 文件名
     */
    private static String fileName = "test.json";

    /**
     * 初始化 Map
     */
    private Map<String, String> initMap = Maps.newHashMap();

    @Override
    public void run(String... args) throws Exception {

        JSONObject jsonObject = loadingJSONFile();
        log.info("json Data are as follows:{}", jsonObject);
       //使用Gson将json转成map
        Gson gson = new Gson();
        initMap = gson.fromJson(jsonObject.toJSONString(), Map.class);
       //将initMap赋值给MapCacheUtils.mapCaheInit
        MapCacheUtils.mapCaheInit = initMap;
    }

    private JSONObject loadingJSONFile() {

        log.info("开始加载resources/test.json");

        Enumeration<URL> resources;
        JSONObject jsonObject = new JSONObject();
        try {
            resources = getClassLoader().getResources(fileName);
        } catch (IOException e) {
            log.warn("getJsonResource fail {}", fileName, e);
            return jsonObject;
        }
        while (resources.hasMoreElements()) {
            URL url = resources.nextElement();
            try {
                String json = Resources.toString(url, Charsets.UTF_8);
                jsonObject.putAll(JSON.parseObject(json)); // 有多个的时候，后面的覆盖前面的
            } catch (IOException e) {
                log.warn("addJsonFile fail url:{}", url, e);
            }
        }
        return jsonObject;
    }

    private static ClassLoader getClassLoader() {
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        if (classLoader != null) {
            return classLoader;
        }
        return MessageInitHandler.class.getClassLoader();
    }
}

MessageIntiHandler实现CommandLineRuner,并实现run方法；
这样MapCacheUtils.mapCaheInit中就有三条数据；初始化工作完成；

然后自定义一个注解@MessageLog,标注在需要aop拦截的接口上；也就是上图中需要存库的操作接口上；例如 账号添加，账号删除…等

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MessageLog {
}

然后编写接口：包括账号添加，账号删除，等。。接口，并标识MessageLog注解，

@RestController
@RequestMapping("user")
public class UserController {

    @Autowired
    private AnalysisUserService analysisUserService;

    /**
     * 添加用户
     */
    @RequestMapping("addUser")
    @MessageLog
    public String addUser(@RequestParam("roleId") Long roleId, AnalysisUser user){
        return analysisUserService.addUser(roleId,user);
    }

    /**
     * 删除用户
     * 需要参数：userid username realname
     * 因为这里把用户删除之后在策略类中就查询不到该用户的信息
     */
    @RequestMapping("delUser")
    @MessageLog
    public String delUser(@RequestBody AnalysisUser analysisUser){
        return analysisUserService.delUser(analysisUser.getId());
    }

    /**
     * 锁定用户这里就不模拟了。。。
     */
}

然后编写策略类
首先 定义个StrategyBase接口

//策略父类
public interface StrategyBase {
    
    String run(Object[] args);

}

接下来就是StrategyBase的子类：

账号添加策略

@Component(value="/user/addUser")
public class MessageAddUserStrategy implements StrategyBase {

    @Autowired
    private AnalysisRoleService analysisRoleService;
    @Override
    public String run(Object[] args) {
        Long roleId = null;
        AnalysisUser analysisUser = null;
        for (Object arg : args) {
            if (arg instanceof Long) {
                roleId = (Long) arg;
            } else if (arg instanceof AnalysisUser) {
                analysisUser = (AnalysisUser) arg;
            } else {
                return null;
            }
        }
        String username = analysisUser.getUsername();
        AnalysisRole role = analysisRoleService.findByRoleId(roleId);
       return "添加了账号" + username + "(" + role.getName() + ")";
    }
}

账号删除策略

@Component("/user/delUser")
public class MessageDelUserStrategy implements StrategyBase {

    @Override
    public String run(Object[] args) {

        for (Object arg : args) {
            if (arg instanceof AnalysisUser) {
                AnalysisUser analysisUser = (AnalysisUser) arg;
              return "删除了账号" + analysisUser.getUsername() + "(" + analysisUser.getRealname() + ")";
            }
        }
        return null;
    }
}

禁用账号策略

@Component("/user/isLock")
public class MessageIsLockStrategy implements StrategyBase {

    @Autowired
    private AnalysisUserService analysisUserService;

    @Override
    public String run(Object[] args) {
        AnalysisUser analysisUser = null;
        for (Object arg : args) {
            if (arg instanceof AnalysisUser) {
                analysisUser = (AnalysisUser) arg;
                if (analysisUser.getStatus().equals((byte) 1)) {
                    analysisUser = analysisUserService.selectById(analysisUser.getId());
                    return "启用了账号" + analysisUser.getUsername() + " (" + analysisUser.getRealname() + ")";
                } else if (analysisUser.getStatus().equals((byte) 2)) {
                    analysisUser = analysisUserService.selectById(analysisUser.getId());
                    return "禁用了账号" + analysisUser.getUsername() + " (" + analysisUser.getRealname() + ")";
                }
            }
        }
        return null;
    }
}

这里稍微的注意一下@Component注解中的value值，

策略控制器

@Component
public class DataSourceContextAware {

    @Autowired
    private final Map<String, StrategyBase> strategyMap = new ConcurrentHashMap<>(3);

    public StrategyBase getStrategyInstance(String dsType) {
        StrategyBase strategyBase = strategyMap.get(dsType);
        return strategyBase;
    }
}

这里定义一个ConcurrentHashMap,这个类的作用就是将策略名(@Component注解中的value值),和实现StrategyBase的类，以key,value的形式保存到了ConcurrentHashMap中；

到了这里@MessageLog注解只是定义出来了，还没有正式的用上，下面该轮到@MessageLog和aop上场了。

定义切面

• 使用@Aspect注解将一个java类定义为切面类
• 使用@Pointcut定义一个切入点，可以是一个规则表达式，比如某个package下的所有函数，也可以是一个注解等。
• 根据需要在切入点不同位置的切入内容
  • 使用@Before在切入点开始处切入内容
  • 使用@After在切入点结尾处切入内容
  • 使用@AfterReturning在切入点return内容之后切入内容（可以用来对处理返回值做一些加工处理）
    • 使用@Around在切入点前后切入内容，并自己控制何时执行切入点自身的内容
    • 使用@AfterThrowing用来处理当切入内容部分抛出异常之后的处理逻辑

上面也说到了，就是必须这些操作是成功之后才可以入库，所以我选择了使用@Around，在切入点前后切入内容;因为这样可以在调用接口结束之后拿到接口返回的参数，从而判断接口是否调用成功；

@Aspect
@Component
public class MessageMonitorHandler {

    private Logger logger = LoggerFactory.getLogger(MessageMonitorHandler.class);

    @Autowired
    private AnalysisMessageService messageService;

    @Autowired
    private MessageStrategyService messageStrategyService;
    
    @Autowired
    private StringHttpMessageConverter converter;


    @Pointcut("@annotation(cn.haoxy.strategy.aop.annotation.MessageLog)")
    public void checkMessageHandler() {

    }

    @Around("checkMessageHandler()")
    public void doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {

        logger.info("start run doAround.....");
        Object obj = proceedingJoinPoint.proceed();//调用执行目标方法
        //返回客户端结果
        HttpServletResponse response = getHttpServletResponse();
        HttpOutputMessage outputMessage = new ServletServerHttpResponse(response);
        //converter.write(obj, MediaType.APPLICATION_JSON, outputMessage);
        converter.write(obj.toString(),null, outputMessage);
        shutdownResponse(response);
        //判断调用是否成功
        //省略判断  ......
        //如果调用成功
        processOutPutObj(proceedingJoinPoint);
    }

    private void processOutPutObj(ProceedingJoinPoint proceedingJoinPoint) {

       Object[] args = proceedingJoinPoint.getArgs();
        //得到HttpServletRequest
        HttpServletRequest request = getHttpServletRequest();
        //得到请求url
        String url = request.getServletPath();
        //根据url从MapCacheUtils.mapCaheInit中取出操作title,
        //这里是从test.json文件中读取的，当然也可以配置在数据库中
        String operatorLog = MapCacheUtils.mapCaheInit.get(url);
        //根据url取出对应的策略类,这里的url也就是和策略类上@Component注解的value值
        StrategyBase messageChild = messageStrategyService.run(url);
        //拿到策略类执行相应的策略方法
        String content = messageChild.run(args);
        AnalysisMessage analysisMessage = new AnalysisMessage();
        analysisMessage.setId(1L);
        analysisMessage.setTitle(operatorLog);
        analysisMessage.setContent(content);
        //在这里模拟存库
        messageService.insert(analysisMessage);

       logger.info("  end  run doAround....." + content);
    }


    /**
     * 获取 HttpServletRequest
     */
    private HttpServletRequest getHttpServletRequest() {
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) requestAttributes;
        return servletRequestAttributes.getRequest();
    }
    
    /**
     * 获取 HttpServletResponse
     */
    private HttpServletResponse getHttpServletResponse() {
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) requestAttributes;
        return servletRequestAttributes.getResponse();
    }
    
    /**
     * 关流
     * @param response
     * @throws IOException
     */
     private void shutdownResponse(HttpServletResponse response) throws IOException {
         response.getOutputStream().close();
     }
}

这里@Pointcut是使用注解的方式；在检测接口上含有@MessageLog注解时就会被AOP拦截；

这里贴一下MessageStrategyService类：

@Component
public class MessageStrategyService {

    @Autowired
    private DataSourceContextAware dataSourceContextAware;

    public StrategyBase run(String dsType) {
         //这里调用策略控制器中的getStrategyInstance方法，来获取对应的策略类
        StrategyBase strategyInstance = dataSourceContextAware.getStrategyInstance(dsType);
        return strategyInstance;
    }
}

下面进行测试

使用postman 测试账号添加：

账号添加测试结果打印：

账号删除测试结果打印：

打印content结果缺少主语（当前登陆的用户），需求是：xxx添加了账号xxx(角色名)；这里有很多种方式可以拿到当前用户，如果使用token的话，可以从token中解析出当前用户的id,我这里使用的是shrio,从而也很方便的拿到当前用户，为了减少本演示案例的复杂度就没去引入，这里只突出主要部分；

到这里就结束了，是不是避免很多的 if else，如果有更好的方式欢迎探讨。

演示案例代码