Annotation de journal simple de configuration Spring

Java a introduit les annotations dans jdk1.5, et le framework Spring utilise également pleinement les annotations Java.

Ce qui suit expliquera le processus simple d'annotations personnalisées dans Spring, qui impliquera des concepts liés à l'AOP (programmation orientée aspect) dans le framework Spring.

Si vous ne connaissez pas les annotations Java, vous pouvez d'abord comprendre les annotations personnalisées Java : Annotations personnalisées Java

1 Créer une annotation personnalisée

requestUrl est un paramètre personnalisé. par nous

package com.sam.annotation;

import java.lang.annotation.*;

/**
 * @author sam
 * @since 2017/7/13
 */

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface MyLog {

    String requestUrl();

}

2. Analyse des annotations

La fonctionnalité AOP (programmation orientée aspect) de Spring est utilisée ici

L'annotation @Aspect est utilisée pour réaliser cela. classer une classe d'aspect

Spécifiez le point d'entrée via @Pointcut. Le point d'entrée spécifié ici est le type d'annotation MyLog, c'est-à-dire que la méthode modifiée par l'annotation @MyLog entre dans le point d'entrée.

• @Avant Pré-notification : Une notification qui est exécutée avant un certain point de connexion, mais cette notification ne peut pas empêcher le processus d'exécution avant le point de connexion (à moins qu'elle ne lève une exception).

• @Around Around notification : vous pouvez implémenter avant et après l'exécution de la méthode. Vous devez exécuter point.proceed();

• @AfterReturning Post-notification : Notification exécutée après qu'un point de connexion soit terminé normalement : par exemple, une méthode ne lève aucune exception et retourne normalement.

• @AfterThrowing Notification d'exception : notification exécutée lorsque la méthode lève une exception et se termine.

• @After Post notification : une notification exécutée après qu'un point de connexion se termine normalement : par exemple, une méthode ne lève aucune exception et retourne normalement.

package com.sam.annotation;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * @author sam
 * @since 2017/7/13
 */
@Aspect //AOP 切面
@Component
public class MyLogAspect {


    //切入点
    @Pointcut(value = "@annotation(com.sam.annotation.MyLog)")
    private void pointcut() {

    }


    /**
     * 在方法执行前后
     *
     * @param point
     * @param myLog
     * @return
     */
    @Around(value = "pointcut() && @annotation(myLog)")
    public Object around(ProceedingJoinPoint point, MyLog myLog) {

        System.out.println("++++执行了around方法++++");

        String requestUrl = myLog.requestUrl();

        //拦截的类名
        Class clazz = point.getTarget().getClass();
        //拦截的方法
        Method method = ((MethodSignature) point.getSignature()).getMethod();

        System.out.println("执行了 类:" + clazz + " 方法:" + method + " 自定义请求地址:" + requestUrl);

        try {
            return point.proceed(); //执行程序
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            return throwable.getMessage();
        }
    }

    /**
     * 方法执行后
     *
     * @param joinPoint
     * @param myLog
     * @param result
     * @return
     */
    @AfterReturning(value = "pointcut() && @annotation(myLog)", returning = "result")
    public Object afterReturning(JoinPoint joinPoint, MyLog myLog, Object result) {

        System.out.println("++++执行了afterReturning方法++++");

        System.out.println("执行结果：" + result);

        return result;
    }

    /**
     * 方法执行后 并抛出异常
     *
     * @param joinPoint
     * @param myLog
     * @param ex
     */
    @AfterThrowing(value = "pointcut() && @annotation(myLog)", throwing = "ex")
    public void afterThrowing(JoinPoint joinPoint, MyLog myLog, Exception ex) {
        System.out.println("++++执行了afterThrowing方法++++");
        System.out.println("请求：" + myLog.requestUrl() + " 出现异常");
    }

}

3. Utilisez des annotations personnalisées

Utilisez l'annotation @MyLog directement dans le contrôleur pour démarrer le projet et visitez http://localhost:8080/index

package com.sam.controller;

import com.sam.annotation.MyLog;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author sam
 * @since 2017/7/13
 */
@RestController
@RequestMapping(value = "/index")
public class IndexController {

    @MyLog(requestUrl = "/index请求")
    @RequestMapping(method = RequestMethod.GET)
    public String index() {
        return "index";
    }
}

Résultat

Ce qui précède explique le processus simple d'implémentation d'annotations personnalisées dans Spring. Si vous avez besoin d'effectuer plus d'opérations personnalisées, vous devez effectuer la programmation dans les classes d'aspect. .

++++执行了around方法++++
执行了 类:class com.yfs.controller.IndexController 方法:public java.lang.String com.yfs.controller.IndexController.index() 自定义请求地址:/index请求
++++执行了afterReturning方法++++
执行结果：index

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!