用于跳过方法执行的自定义Java注释

我想创建一个自定义注释来跳过方法执行

这是我的注释代码，带有validator类

@Target({ METHOD , FIELD , PARAMETER } )
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy={MyValidator .class})
public @interface MyAnnotation {

    String message() default "DEFAULT_FALSE";

    Class<?>[] groups() default{};

    Class<? extends Payload>[] payload() default{};

}

---

你应该使用AOP来实现这一点。创建AspectJ项目，然后尝试以下操作：

MyAnnotation.java：

MyAspectClass.java：

MyTestClass.java：

运行时生成的输出：

---

我使用了一个非常通用的aroundAdvice，但是如果你愿意，你可以使用beforeAdvice。事实上，我认为这一点很清楚。

您应该使用AOP来实现这一点。创建AspectJ项目，然后尝试以下操作：

MyAnnotation.java：

MyAspectClass.java：

MyTestClass.java：

运行时生成的输出：

---

我使用了一个非常通用的aroundAdvice，但是如果你愿意，你可以使用beforeAdvice。事实上，我认为这一点很清楚。

这实际上非常简单，是一个人可以写的最简单的方面<代码>；-）

您的示例代码的丑陋之处在于，它使用了几个类，而您没有为这些类显示源代码，因此我必须创建虚拟类/接口，以使您的代码能够编译。您也没有说明验证器是如何应用的，因此我不得不猜测。无论如何，这里有一组完全自洽的示例类：

助手类：

这只是为了使一切都可以编译而搭建的脚手架

package de.scrum\u master.app；
公共接口有效负载{}

package de.scrum\u master.app；
公共类ConstraintValidatorContext{}

package de.scrum\u master.app；
公共@接口约束{
类[]validatedBy（）；
}

package de.scrum\u master.app；
导入java.lang.annotation.annotation；
公共接口约束验证器{
无效初始化（T1注释）；
布尔值是有效的（T2值，ConstraintValidatorContext validatorContext）；
}

package de.scrum\u master.app；
公共类MyValidator实现ConstraintValidator{
@凌驾
公共void初始化（MyAnnotation）{}
@凌驾
公共布尔值有效（字符串值、ConstraintValidatorContext validatorContext）{
如果（“msg”。等于（值））
返回true；
返回false；
}
}

package de.scrum\u master.app；
导入java.lang.annotation.Target；
导入静态java.lang.annotation.ElementType.*；
导入java.lang.annotation.Retention；
导入静态java.lang.annotation.RetentionPolicy.*；
@目标（{方法，字段，参数}）
@保留（运行时）
@约束（validatedBy={MyValidator.class}）
public@interface-MyAnnotation{
字符串消息（）默认值为“default\u FALSE”；
类[]组（）默认值{}；
类它实际上非常简单，是一个人可以编写的最简单的方面。
；-）

您的示例代码的丑陋之处在于，它使用了几个类，您没有显示这些类的源代码，因此我必须创建虚拟类/接口以使您的代码能够编译。您也没有显示验证器是如何应用的，因此我不得不推测。无论如何，下面是一组完全自洽的示例类：

助手类：

这只是为了使一切都可以编译而搭建的脚手架

package de.scrum\u master.app；
公共接口有效负载{}

package de.scrum\u master.app；
公共类ConstraintValidatorContext{}

package de.scrum\u master.app；
公共@接口约束{
类[]validatedBy（）；
}

package de.scrum\u master.app；
导入java.lang.annotation.annotation；
公共接口约束验证器{
无效初始化（T1注释）；
布尔值是有效的（T2值，ConstraintValidatorContext validatorContext）；
}

package de.scrum\u master.app；
公共类MyValidator实现ConstraintValidator{
@凌驾
公共void初始化（MyAnnotation）{}
@凌驾
公共布尔值有效（字符串值、ConstraintValidatorContext validatorContext）{
如果（“msg”。等于（值））
返回true；
返回false；
}
}

package de.scrum\u master.app；
导入java.lang.annotation.Target；
导入静态java.lang.annotation.ElementType.*；
导入java.lang.annotation.Retention；
导入静态java.lang.annotation.RetentionPolicy.*；
@目标（{方法，字段，参数}）
@保留（运行时）
@约束（validatedBy={MyValidator.class}）
public@interface-MyAnnotation{
字符串消息（）默认值为“default\u FALSE”；
类[]组（）默认值{}；
类您需要更改
if（str==“msg”）{
以使用
equals（）
如何进行“跳过”事情会发生吗？嗨，是的，这是我的问题，如果可以使用这种验证器，我不知道是否可以done@SharonBenAsher，请建议如果有其他方法，请提供任何帮助：）如果您已经知道要跳过方法执行-并且您必须知道是否要在之前注释目标方法还有-为什么要调用或实现它们？我知道如何通过AspectJ轻松实现，但这种方法本身是有缺陷的。问题仍然是，如果跳过非void方法，应该返回什么？请给出一个更合理的示例，然后我可能会想帮你。我需要了解你想要解决的实际问题，而不是如何解决你认为应该解决这个问题。这两个问题不一定相同。你需要更改
if（str==“msg”）{
以使用
equals（）
如何“跳过”事情会发生吗？嗨，是的，这是我的问题，如果可以使用这种验证器，我不知道是否可以done@SharonBenAsher，请建议如果有其他方法，请提供任何帮助：）如果您已经知道要跳过方法执行-并且您必须知道是否要在之前注释目标方法还有-为什么要调用或实现它们？我知道如何通过AspectJ轻松实现，但这种方法本身是有缺陷的。问题仍然是，如果跳过非void方法，应该返回什么？请给出更多的理由
public class MyValidator implements ConstraintValidator<MyAnnotation, String >{

    @Override
    public void initialize(MyAnnotation arg0) {

    }

    @Override
    public boolean isValid(String arg0, ConstraintValidatorContext arg1) {

        if(str=="msg"){
            return true;
        }
        return false;
    }

}

public class Test {



    public static void main(String[] args) {
    Test t = new Test();
        boolean valid=false;

         valid=t.validate();
        System.out.println(valid);

    }

@MyAnnotation(message="msg")
    public boolean validate(){

     // some code to return true or false
    return true;


    }
}

package moo.aspecttest;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(value = { ElementType.METHOD })
public @interface MyAnnotation
{
    public String value();
}

package moo.aspecttest;

import java.lang.reflect.Method;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;

@Aspect
public class MyAspectClass
{

    @Around("execution(* *(..))")
    public Object aroundAdvice(ProceedingJoinPoint point) throws Throwable
    {
        Method method = MethodSignature.class.cast(point.getSignature()).getMethod();
        String name = method.getName();
        MyAnnotation puff = method.getAnnotation(MyAnnotation.class);
        if (puff != null) {
            System.out.println("Method " + name + " annotated with " + puff.value() + ": skipped");
            return null;
        } else {
            System.out.println("Method " + name + " non annotated: executing...");
            Object toret = point.proceed();
            System.out.println("Method " + name + " non annotated: executed");
            return toret;
        }
    }
}

package moo.aspecttest;

public class MyTestClass
{

    @MyAnnotation("doh")
    public boolean validate(String s) {
        System.out.println("Validating "+s);
        return true;
    }

    public boolean validate2(String s) {
        System.out.println("Validating2 "+s);
        return true;
    }

    public static void main(String[] args)
    {
        MyTestClass mc = new MyTestClass();

        mc.validate("hello");
        mc.validate2("cheers");

        }
    }
}

Method main non annotated: executing...
Method validate annotated with doh: skipped
Method validate2 non annotated: executing...
Validating2 cheers
Method validate2 non annotated: executed
Method main non annotated: executed