Question

无论如何都要制作一种每次调用方法时调用的“超级方法”，即使对于未定义的方法也是如此？有点像这样：

public void onStart() {
    System.out.println("Start");
}

public void onEnd() {
    System.out.println("End");
}

public SuperMethod superMethod() {
    System.out.println("Super");
}

// "Start"
// "Super"
onStart();

// "End"
// "Super"
onEnd();

// "Super"
onRun();

感谢您的帮助。

编辑 - 细节：我有一个库可以更新很多，并在每次更新时进行重新模糊处理。为了使我的工作流程更容易，我正在让我的程序自动更新库（需要做我想做的事情，我不会详细说明为什么，但我的程序将适用于未来的更新）并且我有混淆映射下载库，我想创建一种名为Library的代理，然后当我调用Library.getInstance()时，它将获得getInstance()的模糊映射并调用库的方法getInstance()或abz，因为它在当前时刻被映射到。{/ p>

Answer 1

当然你可以这样做，不是用标准的java，而是用AspectJ

这是一个简单的例子：

具有后期建议的方面

package net.fsa.aspectj.test;


public aspect SuperMethdAspect {

    pointcut afterPointCut() : execution(public * com.my.pack.age.MyClass.*(..));

    after() : afterPointCut() {
        System.out.println("Super");
    }
}

你的目标是

package com.my.pack.age;

public class MyClass {

    public void onStart() {
        System.out.println("Start");
    }

    public void onEnd() {
        System.out.println("End");
    }
}

最后是一些测试应用

package net.fsa.aspectj.test;

import com.my.pack.age.MyClass;

public class MyApp {

    public static void main(String... args) {
        MyClass myClass = new MyClass();
        myClass.onStart();
        myClass.onEnd();
    }
}

<强>输出

Start
Super
End
Super

Answer 2

以下是使用Proxy类的纯Java实现：

import java.lang.reflect.*;
import java.util.*;

public class Demo
{
    public static void main(String[] args)
    {
        Map<String, String> map = new HashMap<String, String>();
        map.put("onStart", "abc");
        map.put("onEnd", "def");
        Library library = new LibraryProxy(map, new LibraryImpl()).proxy();
        library.onStart();
        library.onEnd();
        library.onRun();
    }
}

interface Library
{
    void onStart();
    void onEnd();
    void onRun();
}

class LibraryImpl
{
    public void abc() { System.out.println("Start"); }
    public void def() { System.out.println("End"); }
}

class LibraryProxy implements InvocationHandler
{
    Map<String, String> map;
    Object impl;

    public LibraryProxy(Map<String, String> map, Object impl)
    {
        this.map = map;
        this.impl = impl;
    }

    public Library proxy()
    {
        return (Library) Proxy.newProxyInstance(Library.class.getClassLoader(),
            new Class[] { Library.class }, this);
    }

    @Override
    public Object invoke(Object proxy, Method m, Object[] args) throws Throwable
    {
        Object res = null;
        String name = map.get(m.getName());
        if (name == null) {
            System.out.println("[" + m.getName() + " is not defined]");
        } else {
            m = impl.getClass().getMethod(name, m.getParameterTypes());
            res = m.invoke(impl, args);
        }
        System.out.println("super duper");
        return res;
    }
}

输出：

Start
super duper
End
super duper
[onRun is not defined]
super duper

Answer 3

Java并不真正允许像这样的魔法。为了使调用发生，它必须出现在您的（已编译）代码中。所以答案是否定的，并非没有明确地添加对相关方法的调用。但是，您可以通过使用预处理器或运行时代码生成来隐藏它。

我认为AspectJ可能就是你想要的。

Answer 4

我想这不是你想要的，但你可以将方法中的所有代码都包装到try {}finally {supermethod ()}中。这样就可以称之为超级方法。

Answer 5

这个概念背后的术语称为拦截器。您需要一个容器来执行此操作，如ApplicationServer，CDI Container，Spring或AOP。它像这样工作

1. call your Method
2. pause your Method
3. call intercepter
4. do interceptor stuff
5. resume your Method inside the interceptor

在调用其他方法时调用方法

5 个答案: