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;

    //@MessageLog
    @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，若是有更好的方式欢迎探讨。

演示案例代码