我有一些 BaseClass用一些方法 void doSomething() .

foSomething有不同的方法它们由 SubClass1 实现, SubClass2和 SubClass3 .

现在我想添加一个Boolean active属性(property)给BaseClass这样当doSomething在一个实例上调用它只会返回而不做任何事情。

我知道我可以编码 BaseClass有 doSomething()看起来像:

Void doSomething(){
   if (this.getActive()) actuallyDoSomething();
}

然后 @Override actuallyDoSomething()而不是 @Override doSomething()在子类中。 但感觉不对...从某种意义上说，已经同意子类应该为 doSomething() 提供实现。他们不知道actuallyDoSomething() .

我也可以让每个子类添加一个 if (!this.getActive()) return;在其实现之初 doSomething()但这也似乎是错误的，因为它的通用功能我更愿意保持通用。

执行此操作的常见/最佳实践方法是什么？ 不改子类能做到吗？

更新

Q 的重点不是设计此类功能的正确方法(这很简单)， 但如何在不破坏任何内容的情况下将此类功能添加到现有场景中。

active默认情况下为真，但如果有人调用 setActive(false)，则希望在任何所述子类的任何实例上然后它将变为非 Activity 状态并连续调用 .doSomething()不会做任何事...

最佳答案

您想使用来自 AspectJ 的 @Around 建议并执行如下操作:

// Let subClass instances run normally...
cec.setActive(true);
letThemDoSomething("BEFORE", sbc1, sbc2, sbc3);

// Now change existing scenario...
cec.setActive(false);
letThemDoSomething("AFTER", sbc1, sbc2, sbc3);

这将输出:

BEFORE ======
SubClass1: doSomething() called.
SubClass2: doSomething() called.
SubClass3: doSomething() called.

AFTER ======
Blocking instance<1> method: my.first.spring.aop.aspectj.SubClassN#doSomething([]) !!
Blocking instance<2> method: my.first.spring.aop.aspectj.SubClassN#doSomething([]) !!
Blocking instance<3> method: my.first.spring.aop.aspectj.SubClassN#doSomething([]) !!

在接下来的几行中，我将描述如何使用注释实现这一点。
我也会在这里使用 Spring。它有助于使配置更快、更容易。

1-配置

工具和依赖项

Java 7、AspectJ 1.7.4、Spring 4.0.2

项目结构

pom.xml

<project ...>

  <properties>
     <maven.compiler.source>1.7</maven.compiler.source>
     <maven.compiler.target>1.7</maven.compiler.target> 

     <spring.version>4.0.2.RELEASE</spring.version>
     <aspectj.version>1.7.4</aspectj.version>
  </properties>

  <dependencies>
    <!-- Spring -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <!-- AspectJ -->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>${aspectj.version}</version>
    </dependency>

    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>${aspectj.version}</version>
    </dependency>
  </dependencies>

</project>

2 - 现有代码

BaseClass.java

public class BaseClass {
    public void doSomething() {

    }

    public void say(String msg) {
         System.out.println(msg);
    }
}    

SubClassN.java

public class SubClassN extends BaseClass {
    private Integer index;

    public SubClassN(Integer index) {
        this.index = index;
    }

    @Override
    public void doSomething() {
        say("SubClass" + index + ": doSomething() called.");
    }

    public Integer getIndex() {
        return index;
    }
}

3 - 更改现有代码(不破坏任何东西...)

这是 AspectJ 及其 @Around 建议。我们将首先要求 AsjectJ 在调用任何 doSomething 方法时调用一个特定方法。 doSomething 可以在 BaseClass 或其任何子类中的任何位置。

此特定方法 称为changeExistingScenario。它可以有任何名称。这里重要的是放在上面的注释。

关于@Around 值的一句话:

execution(* my.first.spring.aop.aspectj.BaseClass.doSomething(..))

这个表达式简单地表明了我们想要拦截的方法签名模式。
它会拦截 BaseClass 或子类中的任何 doSomething 方法，无论 多少个参数、返回类型和访问修饰符。

有关详细信息，请参阅:http://guptavikas.wordpress.com/2010/04/15/aspectj-pointcut-expressions/

ChangeExistingCode.java

@Aspect // Mark ChangeExistingCode as the class for modifying the code 
@Component
public class ChangeExistingCode {
    private boolean active;

    public void setActive(boolean active) {
        this.active = active;
    }

    /**
     *
     * This method will be called by AspectJ anytime a `doSomething` method is called.
     *
     * This will give us a chance to decide whether the `doSomething` method should
     * be called or not.
     *
     */
    @Around("execution(* my.first.spring.aop.aspectj.BaseClass.doSomething(..))")
    public void changeExistingScenario(ProceedingJoinPoint joinPoint) throws Throwable {
        // Is active ?
        if (active) { // Yes, let doSomething() run as usual
            joinPoint.proceed();
        } else {// No, block doSomething() invokation
            Signature s = joinPoint.getSignature();

            System.out.format( //
                    "Blocking instance<%d> method: %s#%s(%s) !!\n", //
                    ((SubClassN)joinPoint.getTarget()).getIndex(), //
                    s.getDeclaringTypeName(), //
                    s.getName(), //
                    Arrays.toString(joinPoint.getArgs()) //
                    );
        }
    }
}

4-让所有的魔法出现...

主.java

@Configuration // Mark the Main class as the class where Spring will find its configuration
@ComponentScan // Ask Spring to look for other components within the Main class package
@EnableAspectJAutoProxy // Let Spring auto configure AspectJ aspects for us...
public class Main {

    private static int subClassCounter;

    public static void main(String[] args) {
        subClassCounter=0;

        GenericApplicationContext  context = new AnnotationConfigApplicationContext(Main.class);

        SubClassN sbc1 = context.getBean(SubClassN.class);
        SubClassN sbc2 = context.getBean(SubClassN.class);
        SubClassN sbc3 = context.getBean(SubClassN.class);

        ChangeExistingCode cec = context.getBean(ChangeExistingCode.class);

        // Let subClass instances run normally...
        cec.setActive(true);
        letThemDoSomething("BEFORE", sbc1, sbc2, sbc3);

        // Now change existing scenario...
        cec.setActive(false);
        letThemDoSomething("AFTER", sbc1, sbc2, sbc3);

        context.close();
    }

    private static void letThemDoSomething(String prefix, SubClassN... existingClasses) {
        System.out.format("%s ======\n", prefix);
        for (SubClassN subClassInstance : existingClasses) {
            subClassInstance.doSomething();
        }
        System.out.println();
    }

    @Bean // Tell Spring to use this method for creating SubClassN instances
    @Scope(BeanDefinition.SCOPE_PROTOTYPE) // Scope prototype force creation of multiple instances
    private static SubClassN buildSubClassN() {
        subClassCounter++;
        return new SubClassN(subClassCounter);
    }
}

输出

BEFORE ======
SubClass1: doSomething() called.
SubClass2: doSomething() called.
SubClass3: doSomething() called.

AFTER ======
Blocking instance<1> method: my.first.spring.aop.aspectj.SubClassN#doSomething([]) !!
Blocking instance<2> method: my.first.spring.aop.aspectj.SubClassN#doSomething([]) !!
Blocking instance<3> method: my.first.spring.aop.aspectj.SubClassN#doSomething([]) !!

5- 引用文献

• Download full code: http://www.filedropper.com/advicearoundsample

• AspectJ official site

  • @Around javadoc
  • @Aspect javadoc

• Spring official site

  • @Bean javadoc
  • @Component javadoc
  • @ComponentScan javadoc
  • @Configuration javadoc
  • @EnableAspectJAutoProxy javadoc

• Other useful resources that helped writing this answer

  • AspectJ Pointcut Expressions
  • Mkyong - Spring AOP + AspectJ annotation example

关于java - 如何在不修改子类的情况下添加对现有子类中方法调用的控制？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/21883856/