✨这里是第七人格的博客✨小七，欢迎您的到来~✨
🍅系列专栏：【架构思想】🍅
✈️本篇内容: 从0到1带你实现一个业务日志组件（二）✈️
🍱本篇收录完整代码地址：gitee.com/diqirenge/b…
楔子
上一篇（从0到1带你实现一个业务日志组件（一）需求分析篇）小七对需求进行了拆分，并且实现了业务日志的基本架构，这一篇小七将会继续带着大家，实现相关核心代码，废话少说，开干！
设计思路
再次回顾一下我们的设计思路
定义组件
从以上设计思路，我们完成了对注解的定义，并编写了一个待实现逻辑的aop切面。这一章我们先完成组件的核心代码——解析，为了更好地实现功能，小七提供了以下思维导图
1、parser-解析模块
该模块下主要是对业务日志进行解析。
小七这里计划参考org.springframework.cache.interceptor.CacheOperationExpressionEvaluator实现。
2、model-实体模块
抽象实体，这里放一些，组件自己内部使用的实体，比如业务日志实体、业务操作日志实体、方法执行结果实体。
3、config-配置模块
初始化一些组件必须要用到的bean，单独写这么一个配置类，是为了方便以后抽取成spring-boot-starter。
4、exception-统一异常模块
封装的组件统一异常。
5、constant-常量模块
组件用到的一些常量，比如"#"就可以定义到里面。
6、interface-接口模块
我们需要暴露的一些接口就要写到这里。说白了，就是我们提供给组件使用方的一些拓展点，暂时定义两个：
（1）用于创建自定义函数的接口
（2）用于创建自定义日志记录的接口
分支名称
231013-52javaee.com-BizLogDefinition
仓库地址
gitee.com/diqirenge/b…
分支描述
编写业务日志组件相关定义代码。
代码实现
constant模块
BizLogConsts
/**
* 业务日志常量
* 关注公众号【奔跑的码畜】，一起进步不迷路
*
* @author 第七人格
* @date 2023/10/13
*/
public final class BizLogConsts {
/**
* #号键值，用于替换参数
*/
public static final String POUND_KEY = "#";
/**
* 内置参数：错误信息
*/
public static final String ERR_MSG = "_errMsg";
/**
* 内置参数：结果
*/
public static final String RESULT = "_result";
}
model模块
BizLogInfo
/**
* 日志信息
* 关注公众号【奔跑的码畜】，一起进步不迷路
*
* @author 第七人格
* @date 2023/10/13
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class BizLogInfo {
/**
* 系统
*/
private String system;
/**
* 操作者
*/
private String operator;
/**
* 业务id
*/
private String bizNo;
/**
* 模块
*/
private String module;
/**
* 操作类型
*/
private String type;
/**
* 成功操作内容
*/
private String content;
/**
* 操作时间 时间戳单位：ms
*/
private Long operateTime;
/**
* 操作花费的时间 单位：ms
*/
private Long executeTime;
/**
* 是否调用成功
*/
private Boolean success;
/**
* 执行后返回的json字符串
*/
private String result;
/**
* 错误信息
*/
private String errorMsg;
/**
* 详细
*/
private String details;
}
BizLogOps
/**
* 业务日志选项
* 关注公众号【奔跑的码畜】，一起进步不迷路
*
* @author 第七人格
* @date 2023/10/13
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class BizLogOps {
private String system;
private String operator;
private String bizNo;
private String module;
private String type;
private String success;
private String fail;
private String details;
private String condition;
}
MethodExecuteResult
/**
* 方法的执行结果
* 关注公众号【奔跑的码畜】，一起进步不迷路
*
* @author 第七人格
* @date 2023/10/13
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class MethodExecuteResult {
private boolean success;
private Throwable throwable;
private String errMsg;
private Long operateTime;
private Long executeTime;
public MethodExecuteResult(boolean success) {
this.success = success;
this.operateTime = System.currentTimeMillis();
}
public void exception(Throwable throwable) {
this.success = false;
this.executeTime = System.currentTimeMillis() - this.operateTime;
this.throwable = throwable;
this.errMsg = throwable.getMessage();
}
}
exception模块
BizLogException
/**
* 业务日志异常
* 关注公众号【奔跑的码畜】，一起进步不迷路
*
* @author 第七人格
* @date 2023/10/13
*/
public class BizLogException extends RuntimeException {
public BizLogException(String message) {
super(message);
}
}
interface模块
ICustomFunctionService
/**
* 用于创建自定义函数的接口
* 关注公众号【奔跑的码畜】，一起进步不迷路
*
* @author 第七人格
* @date 2023/10/13
*/
public interface ICustomFunctionService {
/**
* true：前置函数，false：后置函数
*
* 该拓展点主要是为了解决取数时机问题，比如：
* 有些数据在目标方法执行之前就可以拿到，那么自定义函数这个值就应该为true
* 有些数据要目标方法执行之后才能拿得到，那么自定义函数这个值就应该为false
*
* @return 是否执行前的函数
*/
boolean executeBefore();
/**
* 获取自定义函数名称
*
* @return 自定义函数名
*/
String functionName();
/**
* 应用自定义函数
*
* @param param 参数
* @return 执行结果
*/
String apply(Object param);
}
ILogRecordService
/**
* 日志记录接口
* 关注公众号【奔跑的码畜】，一起进步不迷路
*
* @author 第七人格
* @date 2023/10/13
*/
public interface ILogRecordService {
/**
* 保存 log
*
* @param bizLogInfo 日志实体
*/
void record(BizLogInfo bizLogInfo);
}
为了方便获取自定义函数，我们可以搞一个工厂把自定义函数缓存起来
/**
* 自定义函数工厂
* 关注公众号【奔跑的码畜】，一起进步不迷路
*
* @author 第七人格
* @date 2023/10/13
*/
public class CustomFunctionFactory {
/**
* 自定义函数map
* 项目启动时，将自定义函数注册到map中（因为启动时就添加好了，所以不需要考虑线程安全问题，这里使用HashMap就可以了）
*/
private static final Map CUSTOM_FUNCTION_MAP = new HashMap();
public CustomFunctionFactory(List customFunctions) {
for (ICustomFunctionService customFunction : customFunctions) {
CUSTOM_FUNCTION_MAP.put(customFunction.functionName(), customFunction);
}
}
/**
* 通过函数名获取对应自定义函数
*
* @param functionName 函数名
* @return 自定义函数
*/
public ICustomFunctionService getFunction(String functionName) {
return CUSTOM_FUNCTION_MAP.get(functionName);
}
}
然后再抽象一层IFunctionService，针对内部使用。与ICustomFunctionService区分开来，ICustomFunctionService给组件外部使用。
/**
* 函数服务
* 关注公众号【奔跑的码畜】，一起进步不迷路
*
* @author 第七人格
* @date 2023/10/13
*/
public interface IFunctionService {
/**
* 执行函数
*
* @param functionName 函数名
* @param value 参数
* @return 执行结果
*/
String apply(String functionName, Object value);
/**
* 是否在拦截的方法执行前执行
*
* @param functionName 函数名
* @return boolean
*/
boolean executeBefore(String functionName);
}
parser模块
BizLogEvaluationContext
/**
* 基于方法的上下文，主要作用：将方法参数放入到上下文中
* 关注公众号【奔跑的码畜】，一起进步不迷路
*
* @author 第七人格
* @date 2023/10/13
*/
public class BizLogEvaluationContext extends MethodBasedEvaluationContext {
public BizLogEvaluationContext(Method method, Object[] arguments, ParameterNameDiscoverer parameterNameDiscoverer) {
super(null, method, arguments, parameterNameDiscoverer);
}
/**
* 将方法执行结果放入上下文中
*
* @param errMsg 错误信息
* @param result 返回结果
*/
public void putResult(String errMsg, Object result) {
super.setVariable(BizLogConsts.ERR_MSG, errMsg);
super.setVariable(BizLogConsts.RESULT, result);
}
}
BizLogCachedExpressionEvaluator
/**
* 缓存表达式求值器
* 关注公众号【奔跑的码畜】，一起进步不迷路
* 参考 {@link org.springframework.cache.interceptor.CacheOperationExpressionEvaluator}
*
* @author 第七人格
* @date 2023/10/13
*/
public class BizLogCachedExpressionEvaluator extends CachedExpressionEvaluator {
/**
* 缓存key
*/
private final Map keyCache = new ConcurrentHashMap(64);
public BizLogCachedExpressionEvaluator() {
}
/**
* 创建上下文
*
* @param method 方法
* @param args 参数
* @param beanFactory bean工厂
* @param errMsg 错误信息
* @param result 结果
* @return {@link EvaluationContext} 返回结果
*/
public EvaluationContext createEvaluationContext(Method method, Object[] args, BeanFactory beanFactory, String errMsg, Object result) {
BizLogEvaluationContext evaluationContext = new BizLogEvaluationContext(method, args, this.getParameterNameDiscoverer());
evaluationContext.putResult(errMsg, result);
if (beanFactory != null) {
// setBeanResolver 主要用于支持SpEL模板中调用指定类的方法，如：@XXService.x(#root)
evaluationContext.setBeanResolver(new BeanFactoryResolver(beanFactory));
}
return evaluationContext;
}
public Object parseExpression(String expression, AnnotatedElementKey methodKey, EvaluationContext evalContext) {
return this.getExpression(this.keyCache, methodKey, expression).getValue(evalContext);
}
void clear() {
this.keyCache.clear();
}
}
BizLogParser
/**
* 业务日志解析器
* 关注公众号【奔跑的码畜】，一起进步不迷路
*
* @author 第七人格
* @date 2023/10/13
*/
public class BizLogParser implements BeanFactoryAware {
/**
* 实现BeanFactoryAware以获取容器中的 beanFactory对象,
* 拿到beanFactory后便可以获取容器中的bean,用于SpEl表达式的解析
*/
private BeanFactory beanFactory;
/**
* 这个正则表达式的含义为：
* 匹配一个包含在花括号中的字符串，其中花括号中可以包含任意数量的空白字符（包括空格、制表符、换行符等），
* 并且花括号中至少包含一个单词字符（字母、数字或下划线）。
* =================================================
* 具体来说，该正则表达式由两部分组成：
* {s*(w*)s*}：表示匹配一个左花括号，后面跟随零个或多个空白字符，然后是一个单词字符（字母、数字或下划线）零个或多个空白字符，最后是一个右花括号。这部分用括号括起来，以便提取匹配到的内容。
* (.*?)：表示匹配任意数量的任意字符，但尽可能少地匹配。这部分用括号括起来，以便提取匹配到的内容。
* =================================================
* 因此，整个正则表达式的意思是：
* 匹配一个包含在花括号中的字符串，
* 其中花括号中可以包含任意数量的空白字符（包括空格、制表符、换行符等），
* 并且花括号中至少包含一个单词字符（字母、数字或下划线），并提取出花括号中的内容。
* =================================================
*/
private static final Pattern PATTERN = Pattern.compile("\{\s*(\w*)\s*\{(.*?)}}");
/**
* 自定义函数服务
*/
@Resource
private IFunctionService customFunctionService;
/**
* 缓存表达式求值器
*/
private final BizLogCachedExpressionEvaluator cachedExpressionEvaluator = new BizLogCachedExpressionEvaluator();
/**
* 处理前置函数
*
* @param templates 模版
* @param method 方法
* @param args 参数
* @param targetClass 目标类
* @return {@link Map} 返回结果
*/
public Map processBeforeExec(List templates, Method method, Object[] args, Class targetClass) {
HashMap map = new HashMap();
AnnotatedElementKey elementKey = new AnnotatedElementKey(method, targetClass);
EvaluationContext evaluationContext = cachedExpressionEvaluator.createEvaluationContext(method, args, beanFactory, null, null);
for (String template : templates) {
if (!template.contains("{")) {
continue;
}
Matcher matcher = PATTERN.matcher(template);
while (matcher.find()) {
String paramName = matcher.group(2);
if (paramName.contains(BizLogConsts.POUND_KEY + BizLogConsts.ERR_MSG) || paramName.contains(BizLogConsts.POUND_KEY + BizLogConsts.RESULT)) {
continue;
}
String funcName = matcher.group(1);
if (customFunctionService.executeBefore(funcName)) {
Object value = cachedExpressionEvaluator.parseExpression(paramName, elementKey, evaluationContext);
String apply = customFunctionService.apply(funcName, value == null ? null : value.toString());
map.put(getFunctionMapKey(funcName, paramName), apply);
}
}
}
return map;
}
/**
* 处理后置函数
*
* @param expressTemplate 待解析的模板
* @param funcValBeforeExecMap 自定义前置函数
* @param method 方法
* @param args 参数
* @param targetClass 目标类
* @param errMsg 错误信息
* @param result 结果
* @return {@link Map} 返回结果
*/
public Map processAfterExec(List expressTemplate, Map funcValBeforeExecMap, Method method, Object[] args, Class targetClass, String errMsg, Object result) {
HashMap map = new HashMap();
AnnotatedElementKey elementKey = new AnnotatedElementKey(method, targetClass);
EvaluationContext evaluationContext = cachedExpressionEvaluator.createEvaluationContext(method, args, beanFactory, errMsg, result);
for (String template : expressTemplate) {
if (template.contains("{")) {
Matcher matcher = PATTERN.matcher(template);
StringBuffer parsedStr = new StringBuffer();
while (matcher.find()) {
String paramName = matcher.group(2);
Object value = cachedExpressionEvaluator.parseExpression(paramName, elementKey, evaluationContext);
String funcName = matcher.group(1);
String param = value == null ? "" : value.toString();
String functionVal = ObjectUtils.isEmpty(funcName) ? param : getFuncVal(funcValBeforeExecMap, funcName, paramName, param);
matcher.appendReplacement(parsedStr, functionVal);
}
matcher.appendTail(parsedStr);
map.put(template, parsedStr.toString());
} else {
Object value;
try {
value = cachedExpressionEvaluator.parseExpression(template, elementKey, evaluationContext);
} catch (Exception e) {
throw new BizLogException(method.getDeclaringClass().getName() + "." + method.getName() + "下 BizLog 解析失败: [" + template + "], 请检查是否符合SpEl表达式规范！");
}
map.put(template, value == null ? "" : value.toString());
}
}
return map;
}
/**
* 获取前置函数映射的 key
*
* @param funcName 方法名
* @param param 参数
* @return {@link String} 返回结果
*/
private String getFunctionMapKey(String funcName, String param) {
return funcName + param;
}
/**
* 获取自定义函数值
*
* @param funcValBeforeExecutionMap 执行之前的函数值
* @param funcName 函数名
* @param paramName 函数参数名称
* @param param 函数参数
* @return {@link String} 返回结果
*/
public String getFuncVal(Map funcValBeforeExecutionMap, String funcName, String paramName, String param) {
String val = null;
if (!CollectionUtils.isEmpty(funcValBeforeExecutionMap)) {
val = funcValBeforeExecutionMap.get(getFunctionMapKey(funcName, paramName));
}
if (ObjectUtils.isEmpty(val)) {
val = customFunctionService.apply(funcName, param);
}
return val;
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
this.beanFactory = beanFactory;
}
}
config模块
/**
* 日志基础配置，这个类初始化了一些组件必须要用到的bean
*
* 为什么要单独写一个配置类呢？
* 1、以后可以引入业务日志组件的全局配置
* 2、方便抽取成start
* 关注公众号【奔跑的码畜】，一起进步不迷路
*
* @author 第七人格
* @date 2023/10/13
*/
@Configuration
public class BizLogAutoConfiguration {
/**
* 自定义函数拓展点
*
* @return {@link ICustomFunctionService} 注入ICustomFunctionService
*/
@Bean
@ConditionalOnMissingBean(ICustomFunctionService.class)
@Role(BeanDefinition.ROLE_APPLICATION)
public ICustomFunctionService customFunction() {
// todo 这里需要组件实现一下默认的处理器
return new DefaultCustomFunctionHandler();
}
/**
* 自定义函数工厂，项目启动时Spring会自动注入这些bean
*
* @param iCustomFunctionServiceList 实现了{@link ICustomFunctionService}的bean的集合
* @return {@link CustomFunctionFactory} 注入CustomFunctionFactory
*/
@Bean
public CustomFunctionFactory CustomFunctionRegistrar(List iCustomFunctionServiceList) {
return new CustomFunctionFactory(iCustomFunctionServiceList);
}
/**
* 自定义函数
*
* @param customFunctionFactory 自定义函数工厂
* @return {@link IFunctionService} 注入IFunctionService
*/
@Bean
public IFunctionService customFunctionService(CustomFunctionFactory customFunctionFactory) {
// todo 这里需要组件实现一下默认的处理器
return new DefaultFunctionHandler(customFunctionFactory);
}
/**
* 日志解析器
*
* @return {@link BizLogParser} 注入BizLogParser
*/
@Bean
public BizLogParser bizLogParser() {
return new BizLogParser();
}
/**
* 日志记录拓展点，如果需要拓展日志记录，可以实现该接口
*
* @return {@link ILogRecordService} 注入ILogRecordService
*/
@Bean
@ConditionalOnMissingBean(ILogRecordService.class)
@Role(BeanDefinition.ROLE_APPLICATION)
public ILogRecordService recordService() {
// todo 这里需要组件实现一下默认的处理器
return new DefaultLogRecordHandler();
}
}
// 如果实现缺失才会走这里
@ConditionalOnMissingBean
// 用户定义的Bean的优先级需要高于默认的Bean，所以这里需要加上这个注解
@Role(BeanDefinition.ROLE_APPLICATION)
默认handler实现
/**
* 自定义函数的默认实现，增加一层是为了屏蔽底层与上层直接接触（也就是说这个类是给组件内部玩的）
* 日志组件都操作IFunctionService的基础服务对象
* 关注公众号【奔跑的码畜】，一起进步不迷路
*
* @author 第七人格
* @date 2023/10/13
*/
public class DefaultFunctionHandler implements IFunctionService {
private final CustomFunctionFactory customFunctionFactory;
public DefaultFunctionHandler(CustomFunctionFactory customFunctionFactory) {
this.customFunctionFactory = customFunctionFactory;
}
@Override
public String apply(String functionName, Object value) {
ICustomFunctionService function = customFunctionFactory.getFunction(functionName);
if (function == null) {
return value.toString();
}
return function.apply(value);
}
@Override
public boolean executeBefore(String functionName) {
ICustomFunctionService function = customFunctionFactory.getFunction(functionName);
return function != null && function.executeBefore();
}
}
/**
* 默认实现类，用于创建自定义函数
* 关注公众号【奔跑的码畜】，一起进步不迷路
*
* @author 第七人格
* @date 2023/10/13
*/
public class DefaultCustomFunctionHandler implements ICustomFunctionService {
@Override
public boolean executeBefore() {
return false;
}
@Override
public String functionName() {
return "defaultName";
}
@Override
public String apply(Object value) {
return null;
}
}
/**
* 默认业务日志记录处理器
* 注：自己实现的过滤器需要加上@Service等注解，并实现ILogRecordService接口
* 关注公众号【奔跑的码畜】，一起进步不迷路
*
* @author 第七人格
* @date 2023/10/13
*/
public class DefaultLogRecordHandler implements ILogRecordService {
public static Logger log = LoggerFactory.getLogger(DefaultLogRecordHandler.class);
@Override
public void record(BizLogInfo bizLogInfo) {
log.info("[触发默认业务日志记录]=====>log={}", JSON.toJSONString(bizLogInfo));
}
}
最终整理代码目录如下：
编写切面
如果说上一章定义组件是给业务日志组件塑造身体的话，那么这一章编写切面就是给业务组件注入灵魂了。
还记得这一张图吗？照着他写就可以了~
分支名称
231013-52javaee.com-BizLogAOP
仓库地址
gitee.com/diqirenge/b…
分支描述
编写业务日志组件相关定义代码。
代码实现
/**
* 业务日志切面
* 关注公众号【奔跑的码畜】，一起进步不迷路
*
* @author 第七人格
* @date 2023/10/13
*/
@Aspect
@Component
public class BizLogAspect {
/**
* 系统日志记录器
*/
public static Logger log = LoggerFactory.getLogger(BizLogAspect.class);
private final ILogRecordService logRecordService;
private final BizLogParser bizLogParser;
@Resource
private Environment environment;
// 参数的2个类，已经在启动时通过框架的配置类，交予了Spring管理
public BizLogAspect(ILogRecordService logRecordService, BizLogParser bizLogParser) {
this.logRecordService = logRecordService;
this.bizLogParser = bizLogParser;
}
/**
* 定义切点
* 切入包含BizLog和BizLogs注解的方法
*/
@Pointcut("@annotation(com.run2code.log.annotation.BizLog) || @annotation(com.run2code.log.annotation.BizLogs)")
public void pointCut() {
}
/**
* 环绕通知
*
* @param joinPoint 切点
* @return {@link Object} 返回结果
*/
@Around("pointCut()")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
// 获取方法签名
MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
// 获取方法
Method method = methodSignature.getMethod();
// 获取方法参数
Object[] args = joinPoint.getArgs();
Object target = joinPoint.getTarget();
Class targetClass = AopUtils.getTargetClass(target);
// 获取所有的日志注解
BizLog[] bizLogs = method.getAnnotationsByType(BizLog.class);
// 将注解参数解析之后放入到实体内，这里是个集合
List bizLogOpsList = new ArrayList();
for (BizLog bizLog : bizLogs) {
bizLogOpsList.add(parseLogAnnotation(bizLog));
}
// 获取不为空的待解析模板
List expressTemplate = getExpressTemplate(bizLogOpsList);
// 获取前置自定义函数值
Map customFunctionExecResultMap = bizLogParser.processBeforeExec(expressTemplate, method, args, targetClass);
Object result = null;
MethodExecuteResult executeResult = new MethodExecuteResult(true);
// 执行目标方法
try {
result = joinPoint.proceed();
} catch (Throwable e) {
executeResult.exception(e);
}
boolean existsNoFailTemp = bizLogOpsList.stream().anyMatch(bizLogOps -> ObjectUtils.isEmpty(bizLogOps.getFail()));
if (!executeResult.isSuccess() && existsNoFailTemp) {
log.warn("[{}] 方法执行失败，@BizLog注解中 失败模板没有配置", method.getName());
} else {
// 解析SpEl表达式
Map templateMap = bizLogParser.processAfterExec(expressTemplate, customFunctionExecResultMap, method, args, targetClass, executeResult.getErrMsg(), result);
// 发送日志
sendLog(bizLogOpsList, result, executeResult, templateMap);
}
// 这里要把目标方法的结果抛出来，不然会吞掉异常
if (!executeResult.isSuccess()) {
throw executeResult.getThrowable();
}
return result;
}
/**
* 发送日志
*
* @param bizLogOps
* @param result
* @param executeResult
* @param templateMap
*/
private void sendLog(List bizLogOps, Object result, MethodExecuteResult executeResult, Map templateMap) {
List bizLogInfos = createBizLogInfo(templateMap, bizLogOps, executeResult);
if (!CollectionUtils.isEmpty(bizLogInfos)) {
bizLogInfos.forEach(bizLogInfo -> {
bizLogInfo.setResult(JSON.toJSONString(result));
// 发送日志（这里其实可以追加参数，判断是否多线程执行，目前是交由子类判断）
logRecordService.record(bizLogInfo);
});
}
}
/**
* 创建操作日志实体
*
* @param templateMap
* @param bizLogOpsList
* @return
*/
private List createBizLogInfo(Map templateMap, List bizLogOpsList, MethodExecuteResult executeResult) {
return Optional.ofNullable(bizLogOpsList)
.orElse(new ArrayList())
.stream()
.filter(bizLogOps -> !"false".equalsIgnoreCase(templateMap.get(bizLogOps.getCondition())))
.map(bizLogOps -> BizLogInfo.builder()
.system(bizLogOps.getSystem() == null || bizLogOps.getSystem().isEmpty() ? environment.getProperty("spring.application.name") : bizLogOps.getSystem())
.module(bizLogOps.getModule())
.type(bizLogOps.getType())
.operator(templateMap.get(bizLogOps.getOperator()))
.bizNo(templateMap.get(bizLogOps.getBizNo()))
.details(templateMap.get(bizLogOps.getDetails()))
.content(executeResult.isSuccess() ? templateMap.get(bizLogOps.getSuccess()) : templateMap.get(bizLogOps.getFail()))
.success(executeResult.isSuccess())
.errorMsg(executeResult.getErrMsg())
.executeTime(executeResult.getExecuteTime())
.operateTime(executeResult.getOperateTime())
.build())
.collect(Collectors.toList());
}
/**
* 将注解转为实体
*
* @param bizLog bizlog注解
* @return {@link BizLogOps} BizLogOps-日志操作对象
*/
private BizLogOps parseLogAnnotation(BizLog bizLog) {
return BizLogOps.builder()
.system(bizLog.system())
.module(bizLog.module())
.type(bizLog.type())
.operator(bizLog.operator())
.bizNo(bizLog.bizNo())
.success(bizLog.success())
.details(bizLog.detail())
.fail(bizLog.fail())
.condition(bizLog.condition())
.build();
}
/**
* 获取不为空的待解析模板
* 从这个List里面我们也可以知道，哪些参数需要符合SpEl表达式
*
* @param bizLogOpsList
* @return
*/
private List getExpressTemplate(List bizLogOpsList) {
Set set = new HashSet();
for (BizLogOps bizLogOps : bizLogOpsList) {
set.addAll(Arrays.asList(bizLogOps.getBizNo(), bizLogOps.getDetails(),
bizLogOps.getOperator(), bizLogOps.getSuccess(), bizLogOps.getFail(),
bizLogOps.getCondition()));
}
return set.stream().filter(s -> !ObjectUtils.isEmpty(s)).collect(Collectors.toList());
}
}
测试
编写测试的web例子
BizController
@RestController
@RequestMapping("/http")
@Slf4j
public class BizController {
@GetMapping("/testBizGet/{param}")
@BizLog(
module = "测试模块",
type = "查询",
operator = "{{#_result}}",
success = "[{{#_result}}]请求get测试接口，参数内容为[{{#param}}]，请求后的内容参数为[{getAfterResultDemo{#param}}]"
)
public String testBizGet(@PathVariable(value = "param") String param){
log.info("入参：{}",param);
return "第七人格";
}
@PostMapping("/testBizPost")
@BizLog(
module = "测试模块",
type = "查询",
bizNo = "{{#param.param}}",
operator = "{{#param.operator}}",
success = "用户：[{{#param.operator}}-{{#param.operator}}]，请求post测试接口，参数内容为[{{#param.param}}]",
condition = "{{#param.operator == '第七人格'}}"
)
public String testBizPost(@RequestBody BizTestParamDto param){
String result = JSON.toJSONString(param);
log.info("入参：{}", result);
return "这是post的返回结果："+result;
}
}
BizTestParamDto
@Data
public class BizTestParamDto {
private String operator;
private String param;
}
GetAfterResultDemo
这个类实现了ICustomFunctionService表明他是biz-log的自定义函数。executeBefore的false，表明他是后置函数；他的函数名称为getAfterResultDemo；他执行的操作是，返回一个" after result demo"的字符串。
@Service
public class GetAfterResultDemo implements ICustomFunctionService {
@Override
public boolean executeBefore() {
return false;
}
@Override
public String functionName() {
return "getAfterResultDemo";
}
@Override
public String apply(Object param) {
return " after result demo";
}
}
http-test-api.http
#### 测试get请求 * 关注公众号【奔跑的码畜】，一起进步不迷路
GET http://localhost:8089/http/testBizGet/测试get请求-公众号【奔跑的码畜】
### 测试post请求，会纪录日志 * 关注公众号【奔跑的码畜】，一起进步不迷路
POST http://localhost:8089/http/testBizPost
Accept: application/json
Content-Type: application/json
{
"operator": "第七人格",
"param": "业务编号"
}
执行Get方法，输出：
[触发默认业务日志记录]=====>log=
{
"content": "[第七人格]请求get测试接口，参数内容为[测试get请求-公众号【奔跑的码畜】]，请求后的内容参数为[ after result demo]",
"module": "测试模块",
"operateTime": 1697442822021,
"operator": "第七人格",
"result": ""第七人格"",
"success": true,
"type": "查询"
}
执行Post方法，输出
[触发默认业务日志记录]=====>log=
{
"bizNo": "业务编号",
"content": "用户：[第七人格-第七人格]，请求post测试接口，参数内容为[业务编号]",
"module": "测试模块",
"operateTime": 1697443561724,
"operator": "第七人格",
"result": ""这是post的返回结果：{\"operator\":\"第七人格\",\"param\":\"业务编号\"}"",
"success": true,
"type": "查询"
}
通过以上结果简单测试，表明我们的@BizLog已经实现了基本功能。
总结
本文通过需求分析和设计思路，完成了业务日志组件核心代码的编写，并且通过测试小例表明该组件已经可以实现，我们所需要的功能。
附录
从0到1带你实现一个业务日志组件（一）需求分析篇
