Java-使用代理类

因此，通过

ClassC

，我有几个类

ClassA

（不是我自己实现的，所以我不能修改它们的源代码）。每个类实现了一些常见的函数和一些独特的函数。这些类用于向数据源提供不同类型的身份验证行为。例如，下面是每个类实现的示例：

// Uses pre-configured privileged user credentials to get data
ClassA.getUsers(...)

// Saves session to allow user to log-in once and perform any operation after that without repeated authentication
ClassB.login(Username, Password)
ClassB.logout()
ClassB.getUsers(..., Username, Password)

// Uses given token to authenticate user and get data
ClassC.getUsers(..., Token)

我正在尝试为这些类开发一个

ProxyClass

，这样我就可以进行如下调用：

ProxyClass
  .getUsers(...);                     => calls ClassA.getUsers(...)

ProxyClass
  .authenticate(Token)
  .getUsers(...);                     => calls ClassC.getUsers(..., Token)

T obj = ProxyClass
  .authenticate(Username, Password);  => calls ClassD.login(Username, Password)

obj.getUsers(...)                     => calls ClassD.getUsers(...)
obj.logout()                          => calls ClassD.logout();

这可能吗？如果可能的话，有人能告诉我

ProxyClass

的样子吗

例如，是否可以确保如果

ClassC

没有

getUsers（）

，则

ProxyClass.authentication（Token）。

根本不会显示

getUsers

如果代理类中的一个方法被声明为

void

，我们会再次返回代理类的一个实例，这样代理类的调用者就可以将调用链接在一起，这样做是否可行

如果可能的话，一个完整的解决方案肯定会很好。但我也会接受部分的。如果我有一个好的起点，我可能会计算出剩下的。但现在我甚至不知道如何开始实施它(

谢谢，阿维西姆

---

编辑我想我应该提到，

ProxyClass

，我指的是

DynamicProxy

类。这涉及方法调用中的反射。如果这不可能，或者不是非常复杂，我想我必须解决静态代理类。

当然

package utils;

public class ProxyClasses {

    public static class ClassA {
        public void function1(Object arg1, Object arg2, Object arg3) {}
    }
    public static class ClassB {
        public void function1(Object arg1, Object arg2, Object arg3, String username, String password) {}
    }
    public static class ClassC {
        public void function1(Object arg1, Object arg2, Object arg3, String token) {}
    }

    public static interface ClassCommon {
        ProxyClasses function1(Object arg1, Object arg2, Object arg3); // or whatever
    }
    public static class ProxyClass implements ClassCommon {
        @Override
        public void function1(Object arg1, Object arg2, Object arg3) {
            new ClassA().function1(arg1, arg2, arg3);
        }

        public ClassCommon authenticate() {
            return new ClassCommon() {
                @Override
                public void function1(Object arg1, Object arg2, Object arg3) {
                    new ClassA().function1(arg1, arg2, arg3);
                    return this;
                }
            };
        }
        public ClassCommon authenticate(final String username, final String password) {
            ClassB classB = new ClassB();
            classB.login(username, password);
            return new ClassCommon() {
                @Override
                public void function1(Object arg1, Object arg2, Object arg3) {
                    new ClassB().function1(arg1, arg2, arg3, username, password);
                    return this;
                }
            };
        }
        public ClassCommon authenticate(final String token) {
            return new ClassCommon() {
                @Override
                public void function1(Object arg1, Object arg2, Object arg3) {
                    new ClassC().function1(arg1, arg2, arg3, token);
                    return this;
                }
            };
        }
    }
}

---

为什么ClassB需要两次凭据？您不需要动态代理来通过反射调用方法。但在这种特殊情况下，我看不出有任何理由使用反射，这可以用纯oop解决。