java动态代理

静态代理

现在有一个接口IUser

public interface IUser {
    void show();
  //void delete();
  //void insert();
}

UserImpl类实现了IUser接口

public class UserImpl implements IUser{
    public UserImpl(){

    }
    @Override
    public void show() {
        System.out.println("调用show()");
    }
    /*@Override
    public void delete() {
        System.out.println("delete()");
    }
    @Override
    public void insert() {
        System.out.println("insert()");
    }*/
}

下面是代理

public class UserProxy implements IUser{
    IUser user;
    public UserProxy(){
    }
    public UserProxy(IUser user){
        this.user=user;
    }
    @Override
    public void show(){
        user.show();
        System.out.println("代理调用了show()");
    }
}

下面主函数简单运行一下

public class ProxyTest {
    public static void main(String[] args) {
        IUser user = new UserImpl();
        IUser userProxy = new UserProxy(user);
        userProxy.show();
    }
}

会发现输出了：

调用show()

代理调用了show

这就是静态代理，在这种情况下，同一个接口的每个函数都要有相对应的代理实现，在这里是show方法的代理，如果一个接口还有delete方法、insert方法等等呢，每个方法都要写一个代理方法吗？显然太麻烦了，所以有了动态代理。

动态代理

现在取消IUser接口和UserImpl类的注释，写一个UserInvocationHandler类，即动代理中中介的角色

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class UserInvocationHandler implements InvocationHandler {
    IUser user;
    public UserInvocationHandler(){}
    public UserInvocationHandler(IUser user)
    {
        this.user=user;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
        method.invoke(user,args);
        return null;
    }
}

注：中介类必须要实现InvocationHandler接口

主函数采用如下写法：

public class ProxyTest {
    public static void main(String[] args) {
        IUser user = new UserImpl();
        InvocationHandler userinvocationhandler = new UserInvocationHandler(user);
        IUser userProxy=(IUser)Proxy.newProxyInstance(user.getClass().getClassLoader(), user.getClass().getInterfaces(),userinvocationhandler);//Java 动态代理的核心，它用于创建一个动态代理对象
        userProxy.show();    
    }