Comment implémenter la journalisation des opérations avec élégance dans le projet Java SpringBoot ?

1. Qu'est-ce que l'AOP ?

AOP (Aspect-Oriented Programming), en parlant d'AOP, presque tous ceux qui ont étudié le framework Spring savent que c'est l'une des trois idées fondamentales de Spring (IOC : Inversion of Control, DI : Dependency Injection, AOP : Aspect Oriented Programmation). Il peut encapsuler une logique ou des responsabilités (telles que le traitement des transactions, la gestion des journaux, le contrôle des autorisations, etc.) qui ne sont pas liées à l'entreprise mais sont communément appelées par les modules métier, afin de réduire la duplication de code dans le système et de réduire le couplage entre les modules. Et cela est propice à l’évolutivité et à la maintenabilité futures.

2. Qu'a fait l'AOP ?

En termes simples, AOP fait principalement trois choses :

• 1 Où intervenir, c'est-à-dire dans quel code métier le code non métier tel que la journalisation est exécuté.

• 2. Quand intervenir, avant ou après l'exécution du code métier.

• 3. Que faire après la connexion, comme la vérification des autorisations, la connexion, etc.

peut être compris avec une image :

Explication d'un terme principal sur l'image :

• Pointcut : point de coupe, décidez où couper dans le code commercial Milieu (c'est-à-dire tissé dans la surface coupée). Les pointscuts sont divisés en mode d'exécution et en mode d'annotation. Mode d'exécution : vous pouvez utiliser des expressions de chemin pour spécifier quelles classes sont intégrées aux aspects. Mode d'annotation : vous pouvez spécifier quel code modifié par annotation est intégré aux aspects.

• Conseils : Traitement, y compris le calendrier de traitement et le traitement du contenu. Traiter le contenu signifie faire quelque chose, comme vérifier les autorisations et enregistrer les journaux. Le timing de traitement fait référence au moment où le contenu du traitement est exécuté, qui est divisé en pré-traitement (c'est-à-dire avant l'exécution du code métier), post-traitement (après l'exécution du code métier), etc.

• Aspect : Aspect, à savoir Pointcut et Advice.

• Point commun : Point commun est un point d'exécution du programme. Par exemple, l'exécution d'une méthode ou la gestion d'une exception. Dans Spring AOP, un point de jointure représente toujours une exécution de méthode.

• Weaving : Weaving est le processus de traitement du contenu dans la méthode de l'objet cible via un proxy dynamique.

3. Étapes de mise en œuvre

(1) Personnaliser une annotation @Log (2) Créer une classe d'aspect, définir le point de coupure pour intercepter la méthode annotée @Log, intercepter les paramètres passés et effectuer la journalisation (3) Modifier @ Log est marqué sur l'interface

Les étapes spécifiques de mise en œuvre sont les suivantes :

1 Ajouter une dépendance AOP

Le code est le suivant (exemple) :

 <dependency>
   	<groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

2. Généralement, les annotations sont utilisées pour les journaux Tapez l'expression pointcut, nous créons d'abord une annotation de journal, lorsque le conteneur Spring analyse la méthode avec cette annotation, elle sera améliorée.

Le code est le suivant (exemple) :

@Target({ ElementType.PARAMETER, ElementType.METHOD }) // 注解放置的目标位置,PARAMETER: 可用在参数上  METHOD：可用在方法级别上
@Retention(RetentionPolicy.RUNTIME)    // 指明修饰的注解的生存周期  RUNTIME：运行级别保留
@Documented
public @interface Log {

    /**
     * 模块
     */
    String title() default "";

    /**
     * 功能
     */
    public BusinessType businessType() default BusinessType.OTHER;

    /**
     * 是否保存请求的参数
     */
    public boolean isSaveRequestData() default true;

    /**
     * 是否保存响应的参数
     */
    public boolean isSaveResponseData() default true;
}

3. Déclaration d'aspect

Déclarez une classe d'aspect et remettez-la au conteneur Spring pour la gestion.

Le code est le suivant (exemple) :

@Aspect
@Component
@Slf4j
public class LogAspect {
    @Autowired
    private IXlOperLogService operLogService;
    /**
     * 处理完请求后执行
     * @param joinPoint 切点
     */
    @AfterReturning(pointcut = "@annotation(controllerLog)", returning = "jsonResult")
    public void doAfterReturnibng(JoinPoint joinPoint, Log controllerLog, Object jsonResult) {
        handleLog(joinPoint, controllerLog, null, jsonResult);
    }
    protected void handleLog(final JoinPoint joinPoint, Log controllerLog, final Exception e, Object jsonResult) {
        try {
            // 获取当前的用户
            JwtUser loginUser = SecurityUtils.getLoginUser();

            // 日志记录
            XlOperLog operLog = new XlOperLog();
            operLog.setStatus(0);
            // 请求的IP地址
            String iP = ServletUtil.getClientIP(ServletUtils.getRequest());
            if ("0:0:0:0:0:0:0:1".equals(iP)) {
                iP = "127.0.0.1";
            }
            operLog.setOperIp(iP);
            operLog.setOperUrl(ServletUtils.getRequest().getRequestURI());
            if (loginUser != null) {
                operLog.setOperName(loginUser.getUsername());
            }
            if (e != null) {
                operLog.setStatus(1);
                operLog.setErrorMsg(StringUtils.substring(e.getMessage(), 0, 2000));
            }
            // 设置方法名称
            String className = joinPoint.getTarget().getClass().getName();
            String methodName = joinPoint.getSignature().getName();
            operLog.setMethod(className + "." + methodName + "()");
            operLog.setRequestMethod(ServletUtils.getRequest().getMethod());
            operLog.setOperTime(new Date());
            // 处理设置注解上的参数
            getControllerMethodDescription(joinPoint, controllerLog, operLog, jsonResult);
            // 保存数据库
            operLogService.save(operLog);

        } catch (Exception exp) {
            log.error("异常信息:{}", exp.getMessage());
            exp.printStackTrace();
        }
    }
    /**
     * 获取注解中对方法的描述信息 用于Controller层注解
     * @param log 日志
     * @param operLog 操作日志
     * @throws Exception
     */
    public void getControllerMethodDescription(JoinPoint joinPoint, Log log, XlOperLog operLog, Object jsonResult) throws Exception {
        // 设置操作业务类型
        operLog.setBusinessType(log.businessType().ordinal());
        // 设置标题
        operLog.setTitle(log.title());
        // 是否需要保存request，参数和值
        if (log.isSaveRequestData()) {
            // 设置参数的信息
            setRequestValue(joinPoint, operLog);
        }
        // 是否需要保存response，参数和值
        if (log.isSaveResponseData() && StringUtils.isNotNull(jsonResult)) {
            operLog.setJsonResult(StringUtils.substring(JSON.toJSONString(jsonResult), 0, 2000));
        }
    }
    /**
     * 获取请求的参数，放到log中
     * @param operLog 操作日志
     * @throws Exception 异常
     */
    private void setRequestValue(JoinPoint joinPoint, XlOperLog operLog) throws Exception {
        String requsetMethod = operLog.getRequestMethod();
        if (HttpMethod.PUT.name().equals(requsetMethod) || HttpMethod.POST.name().equals(requsetMethod)) {
            String parsams = argsArrayToString(joinPoint.getArgs());
            operLog.setOperParam(StringUtils.substring(parsams,0,2000));
        } else {
            Map<?,?> paramsMap = (Map<?,?>) ServletUtils.getRequest().getAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE);
            operLog.setOperParam(StringUtils.substring(paramsMap.toString(),0,2000));
        }
    }
    /**
     * 参数拼装
     */
    private String argsArrayToString(Object[] paramsArray) {
        String params = "";
        if (paramsArray != null && paramsArray.length > 0) {
            for (Object object : paramsArray) {
                // 不为空 并且是不需要过滤的 对象
                if (StringUtils.isNotNull(object) && !isFilterObject(object)) {
                    Object jsonObj = JSON.toJSON(object);
                    params += jsonObj.toString() + " ";
                }
            }
        }
        return params.trim();
    }
    /**
     * 判断是否需要过滤的对象。
     * @param object 对象信息。
     * @return 如果是需要过滤的对象，则返回true；否则返回false。
     */
    @SuppressWarnings("rawtypes")
    public boolean isFilterObject(final Object object) {
        Class<?> clazz = object.getClass();
        if (clazz.isArray()) {
            return clazz.getComponentType().isAssignableFrom(MultipartFile.class);
        } else if (Collection.class.isAssignableFrom(clazz)) {
            Collection collection = (Collection) object;
            for (Object value : collection) {
                return value instanceof MultipartFile;
            }
        } else if (Map.class.isAssignableFrom(clazz)) {
            Map map = (Map) object;
            for (Object value : map.entrySet()) {
                Map.Entry entry = (Map.Entry) value;
                return entry.getValue() instanceof MultipartFile;
            }
        }
        return object instanceof MultipartFile || object instanceof HttpServletRequest
                || object instanceof HttpServletResponse || object instanceof BindingResult;
    }
}

4. Marquez-le sur l'interface

Marquez l'annotation personnalisée sur l'interface qui doit enregistrer le journal des opérations, le code est le suivant (exemple) :

	@Log(title = "代码生成", businessType = BusinessType.GENCODE)
    @ApiOperation(value = "批量生成代码")
    @GetMapping("/download/batch")
    public void batchGenCode(HttpServletResponse response, String tables) throws IOException {
        String[] tableNames = Convert.toStrArray(tables);
        byte[] data = genTableService.downloadCode(tableNames);
        genCode(response, data);
    }

5. Effet de mise en œuvre

Les journaux seront enregistrés lorsque les opérations pertinentes sont effectuées, et certaines informations de base sont enregistrées et stockées dans la table de données.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!