Explicação detalhada da classe JoinPoint e da classe Proceedingjoinpoint do SpringAOP e da notificação surround AOP para obter informações de anotação

1. Classe JoinPoint, classe Proceedingjoinpoint

1. Ao usar springboot para escrever AOP, há uma classe JoinPoint usada para obter informações sobre a classe proxy e a classe proxy.

JointPoint é um ponto identificável durante a execução do programa.Este ponto pode ser usado como ponto de entrada do AOP. O objeto JointPoint contém muitas informações relacionadas ao corte. Como objetos de ponto de entrada, métodos, propriedades, etc. Podemos obter o status e as informações desses pontos por meio da reflexão, que é utilizada para rastrear e registrar informações da aplicação de log.

# 返回目标对象，即被代理的对象
Object getTarget();

# 返回切入点的参数
Object[] getArgs();

# 返回切入点的Signature
Signature getSignature();

# 返回切入的类型，比如method-call，field-get等等，感觉不重要 
 String getKind();

2. Proceedingjoinpoint herda JoinPoint. O método prosseguir é exposto com base no JoinPoint.

Notificação surround = pré + execução do método alvo + pós-notificação O método prosseguir é usado para iniciar a execução do método alvo. A exposição desse método pode oferecer suporte a aspectos como aop:around.

( Proceedingjoinpoint suporta apenas notificação surround @Around, enquanto outros aspectos só precisam usar JoinPoint. Essa também é a maior diferença entre notificação surround e métodos de pré e pós-notificação. Isso está relacionado ao tipo de aspecto )

Nota:
joinpoint.getSignature(): obtém informações sobre o método aprimorado.
Depois que o objeto obtido por joinpoint.getSignature é convertido à força na classe de implementação MethodSignature, o método getReturnType() interno pode ser usado para obter o tipo de valor de retorno do método de destino.

@Before("customerJoinPointerExpression()")
public void beforeMethod(JoinPoint joinPoint){
    // 前置通知
	joinPoint.getSignature().getName(); // 获取目标方法名
	joinPoint.getSignature().getDeclaringType().getSimpleName(); // 获取目标方法所属类的简单类名
	joinPoint.getSignature().getDeclaringTypeName(); // 获取目标方法所属类的类名
	joinPoint.getSignature().getModifiers(); // 获取目标方法声明类型(public、private、protected)
	Object[] args = joinPoint.getArgs(); // 获取传入目标方法的参数，返回一个数组
	joinPoint.getTarget(); // 获取被代理的对象
	joinPoint.getThis(); // 获取代理对象自己
}

  // 匹配方法执行连接点方式
    @Around(value = "execution(* *..SomeserviceImpl.Dofirst(..))")
    public Object myAspectJ(ProceedingJoinPoint point) throws Throwable {
      
         //拦截的实体类
        Object target = point.getTarget();
        //拦截的方法名称
        String methodName = point.getSignature().getName();
        //拦截的方法参数
        Object[] args = point.getArgs();
        //拦截的放参数类型
        Class[] parameterTypes = ((MethodSignature)point.getSignature()).getMethod().getParameterTypes();

        object = point.proceed(); //目标方法的执行
        return null;
    }

2. Notificação surround AOP para obter informações de anotação

1. Conceito

Anotação é informação escrita no código-fonte. Ela pode fornecer informações adicionais além do código. Ela tem sua própria estrutura. Você pode usar ferramentas para extrair essas informações estruturadas.
Simplificando, as anotações são comentários estruturados escritos acima do programa. Java lerá a mensagem de acordo com sua estrutura e executará as operações correspondentes.
Por exemplo, se a anotação @Override estiver marcada em um método, durante a compilação, Java verificará se o método atual sobrecarrega o método da classe pai e, caso contrário, um erro será relatado.

Java vem com anotações padrão
@Override: indica que a definição do método atual substituirá o método na classe pai;
@Deprecated: indica que o código está obsoleto e o compilador emitirá um aviso se o código anotado com @Deprecated for usado;
@ SuppressWarnings: indica mensagens de aviso de desligamento do compilador.

Use as anotações acima para gerar suas próprias anotações, assim como definir uma classe você mesmo, você pode criar uma anotação personalizada através de @interface.

[@Target]     //限定注解可以标注的位置：ANNOTATION_TYPE、CONSTRUCTOR 、FIELD 、LOCAL_VARIABLE 、METHOD 、PACKAGE 、PARAMETER 、TYPE
[@Retention]  //说明了这个注解的存活时间	:SOURCE，CLASS ，RUNTIME
[@Documented] // 将注解中的元素包含到 Javadoc 中去	
[@Inherited]  //子类自动拥有父类的注解	
public @interface [名称] {
     // 元素
     String value() default "hello";
}

[@Retention]
RetentionPolicy.SOURCE: A anotação é retida apenas no estágio do código-fonte e será descartada e ignorada quando o compilador for compilado;
RetentionPolicy.CLASS: A anotação só é retida até que a compilação esteja em andamento e não será ser carregado na JVM.;
RetentionPolicy.RUNTIME: As anotações podem ser retidas até que o programa esteja em execução e serão carregadas na JVM, para que as anotações possam ser obtidas quando o programa estiver em execução .

2. Exemplos de código

anotação:

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface AopCache 
{
    /**
     * 每个方法唯一的key
     */
    String key();
}

Tipo de seção:

@Aspect    //标注增强处理类（切面类）
@Component //交由Spring容器管理
@Order(0)  //设置优先级，值越低优先级越高
public class MyaspectJ {

    //定义增强，pointcut连接点使用@annotation（xxx）进行定义
    @Pointcut(value = "@annotation(xx.xx.xx.AopCache)")
    public void methodPointcut(){}

    // 匹配方法执行连接点方式
    @Around("methodPointcut()")
    public Object myAspectJ(ProceedingJoinPoint point) throws Throwable {
    
        // 获取方法上的注解
        MethodSignature methodSignature = (MethodSignature) point.getSignature();
        Method method = methodSignature.getMethod();
        AopCache annotation = method.getAnnotation(AopCache.class);
        //获取key
        String key = annotation.key();

        object = point.proceed();   // 1. 目标方法的调用
        return null;
    }
}

Se o método usar esta anotação, ele executará diretamente o aprimoramento de aspecto.

@AopCache(key = "自定义key值")
public String getAllType(){

   return "";
}