• spring boot 使用AOP+自定义注解+反射实现操作日志记录修改前数据和修改后对比数据，并保存至日志表

    一、添加aop starter依赖

    1. <dependency>
    2.     <groupId>org.springframework.boot</groupId>
    3.     <artifactId>spring-boot-starter-aop</artifactId>
    4. </dependency>

    二：自定义字段翻译注解。（修改功能时，需要显示如某字段修改前为张三，修改后为李四，name字段对应的中文注释）

    1. package com.test.common.annotation;
    2.  
    3. import java.lang.annotation.*;
    4.  
    5. /**
    6.  * 写入日志表时，字段对应的中文注释
    7.  */
    8. @Retention(RetentionPolicy.RUNTIME) // 注解会在class字节码文件中存在，在运行时可以通过反射获取到
    9. @Target({ElementType.FIELD,ElementType.METHOD})//定义注解的作用目标**作用范围字段、枚举的常量/方法
    10. @Documented                 //说明该注解将被包含在javadoc中
    11. public @interface FieldMeta {
    12.     /**
    13.      * 汉字全称
    14.      * @return
    15.      */
    16.     String value();
    17. }

    使用FieldMeta自定义注解,看个人业务自行觉得是否需要重新定义实体

    1. package com.test.customer.domain;
    2.  
    3. import java.math.BigDecimal;
    4. import java.util.Date;
    5. import java.util.List;
    6. import java.util.Map;
    7.  
    8. import com.test.common.annotation.FieldMeta;
    9. import org.apache.commons.lang3.builder.ToStringBuilder;
    10. import org.apache.commons.lang3.builder.ToStringStyle;
    11. import com.test.common.core.domain.BaseEntity;
    12.  
    13.  
    14. public class TestDangAnDetail extends BaseEntity {
    15.     private static final long serialVersionUID = 1L;
    16.  
    17.     /**
    18.      * 次数
    19.      */
    20.    
    21.     @FieldMeta("总次数")
    22.     private Long CountNum;
    23.     
    24. }

    parseClass调用查询方法的类（查询数据工具类）

    1. //抽象类
    2. public interface ContentParser {
    3.     
    4.         /**
    5.          * 获取信息返回查询出的对象
    6.          *
    7.          * @param joinPoint       查询条件的参数
    8.          * @param dbAccessLogger 注解
    9.          * @return 获得的结果
    10.          */
    11.         Object getOldResult(JoinPoint joinPoint, DBAccessLogger dbAccessLogger,String sqlSessionFactoryName);
    12.     
    13.         /**
    14.          * 获取信息返回查询出的对象
    15.          *
    16.          * @param joinPoint       查询条件的参数
    17.          * @param dbAccessLogger 注解
    18.          * @return 获得的结果
    19.          */
    20.         Object getNewResult(JoinPoint joinPoint, DBAccessLogger dbAccessLogger,String sqlSessionFactoryName);
    21.     
    22.     }
    23.

    实现类 ：通过该实现类获取更新前后的数据。
    该实现类的实现原理为：获取入参出入的id值，获取sqlSessionFactory,通过sqlSessionFactory获取selectByPrimaryKey（）该方法，执行该方法可获取id对应数据更新操作前后的数据。

    1.     @Component
    2.     public class DefaultContentParse implements ContentParser {
    3.         /**
    4.          * 获取更新方法的第一个参数解析其id
    5.          * @param joinPoint       查询条件的参数
    6.          * @param enableModifyLog 注解类容
    7.          * @return
    8.          */
    9.         @Override
    10.         public Object getOldResult(JoinPoint joinPoint, DBAccessLogger enableModifyLog,String sqlSessionFactoryName) {
    11.             Object info = joinPoint.getArgs()[0];
    12.             Object id = ReflectionUtils.getFieldValue(info, "id");
    13.             Assert.notNull(id,"未解析到id值，请检查入参是否正确");
    14.             Class<?> aClass = enableModifyLog.serviceClass();
    15.             Object result = null;
    16.             try {
    17.                 SqlSessionFactory sqlSessionFactory = SpringUtil.getBean(sqlSessionFactoryName);
    18.                 Object instance = Proxy.newProxyInstance(
    19.                         aClass.getClassLoader(),
    20.                         new Class[]{aClass},
    21.                         new MyInvocationHandler(sqlSessionFactory.openSession().getMapper(aClass))
    22.                 );
    23.                 Method selectByPrimaryKey = aClass.getDeclaredMethod("selectByPrimaryKey", Long.class);
    24.                 //调用查询方法
    25.                 result = selectByPrimaryKey.invoke(instance, id);
    26.             } catch (Exception e) {
    27.                 e.printStackTrace();
    28.             }
    29.             return  result;
    30.         }
    31.     
    32.         @Override
    33.         public Object getNewResult(JoinPoint joinPoint, DBAccessLogger enableModifyLog,String sqlSessionFactoryName) {
    34.             return getOldResult(joinPoint,enableModifyLog,sqlSessionFactoryName);
    35.         }
    36.     
    37.     }

    三：定义AOP切面

    注意：如不返回操作是否成功状态可能会导致前端出现警告，JSON为空不能被解析

    1. import com.test.common.annotation.FieldMeta;
    2. import com.test.common.core.domain.entity.SysUser;
    3. import com.test.common.enums.BusinessStatus;
    4. import com.test.common.enums.OperatorType;
    5. import com.test.common.utils.*;
    6. import com.test.customer.domain.UserDataOperationLogs;
    7. import com.test.customer.service.IUserDataOperationLogsService;
    8. import com.test.framework.service.OperateLog;
    9. import com.test.common.enums.BusinessType;
    10. import com.test.framework.service.ContentParser;
    11. import com.test.system.domain.SysOperLog;
    12. import com.test.system.service.ISysOperLogService;
    13. import lombok.extern.slf4j.Slf4j;
    14. import com.alibaba.fastjson.JSON;
    15. import com.fasterxml.jackson.databind.DeserializationFeature;
    16. import com.fasterxml.jackson.databind.ObjectMapper;
    17. import com.fasterxml.jackson.databind.SerializationFeature;
    18. import org.aspectj.lang.ProceedingJoinPoint;
    19. import org.aspectj.lang.annotation.Around;
    20. import org.aspectj.lang.annotation.Aspect;
    21. import org.aspectj.lang.reflect.MethodSignature;
    22. import org.springframework.beans.factory.annotation.Autowired;
    23. import org.springframework.context.ApplicationContext;
    24. import org.springframework.stereotype.Component;
    25. import org.springframework.web.bind.annotation.RequestMethod;
    26. import org.springframework.web.context.request.RequestContextHolder;
    27. import org.springframework.web.context.request.ServletRequestAttributes;
    28. import javax.servlet.http.HttpServletRequest;
    29. import java.lang.reflect.Field;
    30. import java.lang.reflect.Method;
    31. import java.util.Date;
    32. import java.util.HashMap;
    33. import java.util.Map;
    34.  
    35. /**
    36.  * 拦截@EnableGameleyLog注解的方法
    37.  * 将具体修改存储到数据库中
    38.  */
    39. @Aspect
    40. @Component
    41. @Slf4j
    42. public class OperateAspect {
    43.  
    44.     @Autowired
    45.     private IUserDataOperationLogsService iUserDataOperationLogsService;
    46.  
    47.     @Autowired
    48.     private DefaultContentParse defaultContentParse;
    49.  
    50.     @Autowired
    51.     private ApplicationContext applicationContext;
    52.  
    53.  
    54.     // 环绕通知
    55.     @Around("@annotation(operateLog)")
    56.     public Object around(ProceedingJoinPoint joinPoint, OperateLog operateLog) throws Throwable{
    57.         Map<String, Object> oldMap=new HashMap<>();
    58.         UserDataOperationLogs lg = new UserDataOperationLogs();
    59.         ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
    60.         HttpServletRequest request = attributes.getRequest();
    61.         // 当不传默认operateType时 根据Method类型自动匹配
    62.         setAnnotationType(request, operateLog);
    63.  
    64.         // fixme 1.0.9开始不再提供自动存入username功能,请在存储实现类中自行存储
    65.         // 从切面织入点处通过反射机制获取织入点处的方法
    66.         MethodSignature signature = (MethodSignature) joinPoint.getSignature();
    67.  
    68.         Object[] args=joinPoint.getArgs(); // 请求参数
    69.  
    70.         // 获取当前的用户
    71.         SysUser currentUser = ShiroUtils.getSysUser();
    72.  
    73.         lg.setCreateBy(currentUser.getLoginName());
    74.         lg.setStatus(0l);
    75.         lg.setUpdateTime(new Date());
    76.         if (OperateType.UPDATE.equals(operateLog.operateType())) {
    77.             try {
    78.                ContentParser contentParser=(ContentParser) applicationContext.getBean(operateLog.parseclass());
    79.                 Object oldObject = contentParser.getResult(joinPoint, operateLog);
    80.                 if (operateLog.needDefaultCompare()) {
    81.                     oldMap = (Map<String, Object>) objectToMap(oldObject); // 存储修改前的对象
    82.                     lg.setStoreId((Long) oldMap.get("storeId"));
    83.                     lg.setItemId((Long) oldMap.get("itemId"));
    84.                 }
    85.             } catch (Exception e) {
    86.                e.printStackTrace();
    87.                 log.error("service加载失败:", e);
    88.             }
    89.         }
    90.         // joinPoint.proceed()执行前是前置通知，执行后是后置通知
    91.         Object object=joinPoint.proceed();
    92.         if (OperateType.UPDATE.equals(operateLog.operateType())) {
    93.             ContentParser contentParser;
    94.             try {
    95.                String responseParams=JSON.toJSONString(object);
    96.                contentParser=(ContentParser) applicationContext.getBean(operateLog.parseclass());
    97.                 object = contentParser.getResult(joinPoint, operateLog);
    98.             } catch (Exception e) {
    99.                log.error("service加载失败:", e);
    100.             }
    101.             // 默认不进行比较，可以自己在logService中自定义实现，降低对性能的影响
    102.             if (operateLog.needDefaultCompare()) {
    103.                lg.setContent(defaultDealUpdate(object, oldMap));
    104.             }
    105.             // 如果使用默认缓存 则需要更新到最新的数据
    106.             if(operateLog.defaultCache()
    107.                   && operateLog.parseclass().equals(DefaultContentParse.class)){
    108.                 defaultContentParse.updateCache(joinPoint, operateLog,object);
    109.             }
    110.         } else{
    111.            String responseParams=JSON.toJSONString(object);
    112.         }
    113.         //保存当前日志到数据库中
    114.         int logs = iUserDataOperationLogsService.insertUserDataOperationLogs(lg);
    115.         log.info("新增用户操作数据日志成功");
    116.         //返回用户的操作是否成功
    117.         AjaxResult ajaxResult = logs > 0 ? success() : error();
    118.         return ajaxResult;
    119.     }
    120.  
    121.     private String defaultDealUpdate(Object newObject, Map<String, Object> oldMap){
    122.         try {
    123.             Map<String, Object> newMap = (Map<String, Object>) objectToMap(newObject);
    124.             StringBuilder str = new StringBuilder();
    125.             Object finalNewObject = newObject;
    126.             oldMap.forEach((k, v) -> {
    127.                 Object newResult = newMap.get(k);
    128.                 if (null!=v && !v.equals(newResult)) {
    129.                     Field field = ReflectionUtils.getAccessibleField(finalNewObject, k);
    130.                     FieldMeta dataName = field.getAnnotation(FieldMeta.class);
    131.                     SysUser currentUser = ShiroUtils.getSysUser();
    132.                     if (null!=dataName) {
    133.                         str.append("【"+currentUser.getLoginName()+"】").append("修改了【").append(dataName.value() +"】").append("将【").append(v).append("】").append(" 改为：【").append(newResult).append("】。\n");
    134.                     }
    135.                 }
    136.             });
    137.             return str.toString();
    138.         } catch (Exception e) {
    139.             log.error("比较异常", e);
    140.             throw new RuntimeException("比较异常",e);
    141.         }
    142.     }
    143.  
    144.     private Map<?, ?> objectToMap(Object obj) {
    145.         if (obj == null) {
    146.             return null;
    147.         }
    148.         ObjectMapper mapper = new ObjectMapper();
    149.         mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
    150.         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    151.         // 如果使用JPA请自己打开这条配置
    152.         // mapper.addMixIn(Object.class, IgnoreHibernatePropertiesInJackson.class);
    153.         Map<?, ?> mappedObject = mapper.convertValue(obj, Map.class);
    154.         return mappedObject;
    155.     }
    156.  
    157.     private void setAnnotationType(HttpServletRequest request,OperateLog modifyLog){
    158.         if(!modifyLog.operateType().equals(OperateType.NONE)){
    159.             return;
    160.         }
    161.         String method=request.getMethod();
    162.         if(RequestMethod.GET.name().equalsIgnoreCase(method)){
    163.             ReflectAnnotationUtil.updateValue(modifyLog, "operateType", OperateType.SELECT);
    164.         } else if(RequestMethod.POST.name().equalsIgnoreCase(method)){
    165.             ReflectAnnotationUtil.updateValue(modifyLog, "operateType", OperateType.ADD);
    166.         } else if(RequestMethod.PUT.name().equalsIgnoreCase(method)){
    167.             ReflectAnnotationUtil.updateValue(modifyLog, "operateType", OperateType.UPDATE);
    168.         } else if(RequestMethod.DELETE.name().equalsIgnoreCase(method)){
    169.             ReflectAnnotationUtil.updateValue(modifyLog, "operateType", OperateType.DELETE);
    170.         }
    171.     }
    172. }

    或者写成

    1.  
    2. 	//环绕通知切面，切点：DBAccessLogger 更新拦截数据
    3. 	@Aspect
    4.     @Component
    5.     @Order(1)
    6.     public class DBAccessLoggerAspect {
    7.     
    8.         // 注入Service用于把日志保存数据库
    9.         @Autowired
    10.         private LogService logService;
    11.         
    12.         @Around("@annotation(com.****.log.DBAccessLogger)") // 环绕通知
    13.         public Object execute(ProceedingJoinPoint pjp) throws Exception {
    14.             // 获得当前访问的class
    15.             Class<?> className = pjp.getTarget().getClass();
    16.             // 获得访问的方法名
    17.             String methodName = pjp.getSignature().getName();
    18.             @SuppressWarnings("rawtypes")
    19.             Class[] argClass = ((MethodSignature) pjp.getSignature()).getParameterTypes();
    20.             // 操作结果，默认为成功
    21.             Long operResult = DictLogConstant.LOGS_OPER_SUCCESS;
    22.             //返回值
    23.             Object rvt = null;
    24.             Method method = className.getMethod(methodName, argClass);
    25.             DBAccessLogger dbAcessLoggerannotation = method.getAnnotation(DBAccessLogger.class);
    26.             String accessTable = dbAcessLoggerannotation.accessTable();
    27.             DBOperationType accessType = dbAcessLoggerannotation.accessType();
    28.             DatabaseEnum databaseEnum = dbAcessLoggerannotation.accessDatasource();
    29.             String accessDatasource = databaseEnum.constName;
    30.             //crd操作直接执行方法
    31.             if (accessType == DBOperationType.DELETE || accessType == DBOperationType.SELECT || accessType == DBOperationType.CREATE) {
    32.                 try {
    33.                     rvt = pjp.proceed();
    34.                 } catch (Throwable e) {
    35.                     e.printStackTrace();
    36.                     throw new RuntimeException(e.getMessage());
    37.                 }
    38.                 // 如果没有返回结果，则不将该日志操作写入数据库。
    39.                 if (rvt == null) return rvt;
    40.             }
    41.             if ((accessType == DBOperationType.DELETE)
    42.                     && ((CUDResult) rvt).getReturnVal() == 0) {
    43.                 operResult = DictLogConstant.LOGS_OPER_FAILURE;
    44.             }
    45.             if (accessTable != null) {
    46.                 if (accessType == DBOperationType.SELECT) {
    47.                     Log sysLog = new Log();
    48. 					/**
    49. 					设置要存放的日志信息
    50. 					**/
    51.                     logService.createLog(sysLog);
    52.     
    53.                 }
    54.                 else if (accessType == DBOperationType.DELETE || accessType == DBOperationType.CREATE) {
    55.                     for (Long recordId : ((CUDResult) rvt).getRecordIds()) {
    56.                         Log sysLog = new Log();
    57.                       	/**
    58. 						设置要存放的日志信息
    59. 						**/
    60.                         logService.createLog(sysLog);
    61.                     }
    62.                 }
    63.                 else {
    64.                     //更新操作
    65.                     Log sysLog = new Log();
    66.                     /**
    67.                    设置日志信息
    68.                    **/
    69.                     //获取更行前的数据
    70.                     Map<String, Object> oldMap = null;
    71.                     Object oldObject;
    72.                     try {
    73.                         ContentParser contentParser = SpringUtil.getBean(dbAcessLoggerannotation.parseClass());
    74.                         //获取更行前的数据
    75.                         oldObject = contentParser.getOldResult(pjp, dbAcessLoggerannotation, databaseEnum.sqlsessionName);
    76.                         oldMap = (Map<String, Object>) objectToMap(oldObject);
    77.                     } catch (Exception e) {
    78.                         e.printStackTrace();
    79.                     }
    80.                     //执行service
    81.                     Object serviceReturn;
    82.                     try {
    83.                         serviceReturn = pjp.proceed();
    84.                     } catch (Throwable throwable) {
    85.                         throwable.printStackTrace();
    86.                         throw new RuntimeException(throwable.getMessage());
    87.                     }
    88.                     CUDResult crudResult = (CUDResult) serviceReturn;
    89.                     Object afterResult = null;
    90.                     try {
    91.                         ContentParser contentParser = SpringUtil.getBean(dbAcessLoggerannotation.parseClass());
    92.                         //更新后的数据
    93.                         afterResult = contentParser.getNewResult(pjp, dbAcessLoggerannotation, databaseEnum.sqlsessionName);
    94.                     } catch (Exception e) {
    95.                         e.printStackTrace();
    96.                     }
    97.                     //修改前后的变化
    98.                     sysLog.setOperation(accessType.getValue());
    99.                     try {
    100.                         String updatedefrent = defaultDealUpdate(afterResult, oldMap);
    101.                         sysLog.setParams(updatedefrent);
    102.                     } catch (Exception e) {
    103.                         e.printStackTrace();
    104.                     }
    105.                    /**
    106.                    设置日志信息
    107.                    **/
    108.                     logService.createLog(sysLog);
    109.                     return serviceReturn;
    110.                 }
    111.             }
    112.     
    113.             if (operResult.longValue() == DictLogConstant.LOGS_OPER_FAILURE) {
    114.                 // 当数据库的UPDATE 和 DELETE操作没有对应的数据记录存在时，抛出异常
    115.                 throw new DBAccessException(accessType.getValue() + "的数据记录不存在！");
    116.             }
    117.             return rvt;
    118.         }
    119.         private Map<?, ?> objectToMap(Object obj) {
    120.             if (obj == null) {
    121.                 return null;
    122.             }
    123.             ObjectMapper mapper = new ObjectMapper();
    124.             mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
    125.             mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    126.             //如果使用JPA请自己打开这条配置
    127.             //mapper.addMixIn(Object.class, IgnoreHibernatePropertiesInJackson.class);
    128.             Map<?, ?> mappedObject = mapper.convertValue(obj, Map.class);
    129.             return mappedObject;
    130.         }
    131.     
    132.         /**
    133.          *
    134.          * @param newObject 更新过后的结果
    135.          * @param oldMap 更新前的结果
    136.          * @return
    137.          */
    138.         private String defaultDealUpdate(Object newObject, Map<String, Object> oldMap) {
    139.             try {
    140.                 Map<String, Object> newMap = (Map<String, Object>) objectToMap(newObject);
    141.                 StringBuilder str = new StringBuilder();
    142.                 Object finalNewObject = newObject;
    143.                 oldMap.forEach((k, v) -> {
    144.                     Object newResult = newMap.get(k);
    145.                     if (v != null && !v.equals(newResult)) {
    146.                         Field field = ReflectionUtils.getAccessibleField(finalNewObject, k);
    147.                         //获取类上的注解
    148.                         DataName dataName = field.getAnnotation(DataName.class);
    149.                         if (field.getType().getName().equals("java.util.Date")) {
    150.                             SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    151.                             if (dataName != null) {
    152.                                 str.append("【").append(dataName.name()).append("】从【")
    153.                                         .append(format.format(v)).append("】改为了【").append(format.format(newResult)).append("】;\n");
    154.                             } else {
    155.                                 str.append("【").append(field.getName()).append("】从【")
    156.                                         .append(format.format(v)).append("】改为了【").append(format.format(newResult)).append("】;\n");
    157.                             }
    158.                         } else {
    159.                             if (dataName != null) {
    160.                                 str.append("【").append(dataName.name()).append("】从【")
    161.                                         .append(v).append("】改为了【").append(newResult).append("】;\n");
    162.                             } else {
    163.                                 str.append("【").append(field.getName()).append("】从【")
    164.                                         .append(v).append("】改为了【").append(newResult).append("】;\n");
    165.                             }
    166.                         }
    167.                     }
    168.                 });
    169.                 return str.toString();
    170.             } catch (Exception e) {
    171.                 throw new RuntimeException("比较异常", e);
    172.             }
    173.         }
    174.     }

    四：自定义日志注解

    1. package com.test.framework.service;
    2.  
    3. import com.test.common.utils.IService;
    4. import com.test.common.utils.OperateType;
    5. import com.test.framework.service.impl.DefaultContentParse;
    6.  
    7. import java.lang.annotation.Documented;
    8. import java.lang.annotation.ElementType;
    9. import java.lang.annotation.Retention;
    10. import java.lang.annotation.RetentionPolicy;
    11. import java.lang.annotation.Target;
    12.  
    13. /**
    14.  * 记录编辑详细信息的标注
    15.  * @author 
    16.  */
    17. @Documented
    18. @Retention(RetentionPolicy.RUNTIME)
    19. @Target({ElementType.METHOD})
    20. public @interface OperateLog {
    21.  
    22.    // 模块名称
    23.    String moduleCode() default "";
    24.  
    25.    // 操作的类型 可以直接调用OperateType 不传时根据METHOD自动确定
    26.    OperateType operateType() default OperateType.NONE;
    27.  
    28.    // 获取编辑信息的解析类，目前为使用id获取，复杂的解析需要自己实现，默认不填写则使用默认解析类
    29.     Class parseclass() default DefaultContentParse.class;
    30.  
    31.     // 查询数据库所调用的class文件
    32.     Class serviceclass() default IService.class;
    33.  
    34.     // 具体业务操作名称
    35.     String handleName() default "";
    36.  
    37.     // 是否需要默认的改动比较
    38.     boolean needDefaultCompare() default false;
    39.  
    40.     // id的类型
    41.     Class idType() default Long.class;
    42.  
    43.     // 是否使用默认本地缓存
    44.     boolean defaultCache() default false;
    45.  
    46.  
    47. }

    五、@OperateLog注解使用

    1. /**
    2.  * 修改记录详情
    3.  * @OperateLog:AOP自定义日志注解
    4.  */
    5. @PostMapping("/editSave")
    6. @OperateLog(moduleCode="editSave", operateType= OperateType.UPDATE, handleName="修改档案信息", needDefaultCompare=true)
    7. @ResponseBody
    8. public AjaxResult editSave(TCustomerItemRecDetail tCustomerItemRecDetail){
    9.     return toAjax(testDangAnDetailService.updateTestDangAnDetail(tCustomerItemRecDetail));
    10. }

    修改功能时，需要实现我们自定义的IService接口，并重写 selectById 方法，在修改前我们需要根据主键id去数据库查询对应的信息，然后在和修改后的值进行比较。

    在这里插入图片描述

    六：IService接口

    1. /**
    2.  * 修改时需要记录修改前后的值时，需要根据主键id去查询修改前的值时需要
    3.  * @author zhang
    4.  */
    5. public interface IService<T, S> {
    6.     T selectById(S id);
    7. }

  • 相关阅读:
    Visual Studio 中的键盘快捷方式大全
    封装了一个居左的iOS轮播视图
    Java程序员找工作需要掌握哪些技能
    Android使用Banner框架实现轮播图
    CaiT：Facebook提出高性能深度ViT结构 | ICCV 2021
    sqlserver2012 完全卸载
    shell脚本自动化执行jar包
    2022-08-01 C++并发编程（四）
    Python 列表推导式：计算不同运动组合的热量列表及最大最小热量消耗情况
    【Reinforcement Learning】强化学习基础内容有哪些？
  • 原文地址：https://blog.csdn.net/yuechuzhixing/article/details/132761054