InvocationHandler接口是proxy代理实例的调用处理程序实现的一个接口，每一个proxy代理实例都有一个关联的调用处理程序；在代理实例调用方法时，方法调用被编码分派到调用处理程序的invoke方法。

1.定义一个接口类

public interface IUserService {
    public void addUser();
    public void readUser();
    public void deleteUser();
}

2.接口的实现类

public class UserServiceImpl implements IUserService {
    public void addUser() {
        System.out.println("add user");
    }

    public void readUser() {
        System.out.println("read user");
    }

    public void deleteUser() {
        System.out.println("delete user");
    }
}

3.1动态代理定义一个InvocationHandler，在静态代理中就相当于Proxy类的作用

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


//java 动态代理需实现InvocationHandler   ,   InvocationHandler 实际在静态代理中就是起到Proxy类的作用
public class LogInvocationHandler implements InvocationHandler {
    private Object service;
    public void setService(Object service){
        this.service = service;
    }
    //所有代理类方法在执行的时候都会回调这个函数
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("[Log]:"+method.getName()+"called");
        Object ret = method.invoke(this.service,args);
        System.out.println("[Log]:"+method.getName()+"done");
        return ret;
    }
}

3.2静态代理

//代理类也要实现接口，并创建设置
// 接口对象
public class LogUserServiceProxy implements IUserService {
    private IUserService userService;
    public void setUserService(IUserService userService){
        this.userService = userService;
    }
    public void addUser() {
        System.out.println("[log] addUser called");
        this.userService.addUser();
    }

    public void readUser() {
        System.out.println("[log] readUser called");
        this.userService.readUser();
    }

    public void deleteUser() {
        System.out.println("[log] deleteUser called");
        this.userService.deleteUser();
    }
}

4.实现动态代理类,每次调用IUserService proxy的具体方法。如addUser、deleteUser、readUser都会回调LogInvocationHandler中的invoke函数。invoke函数中的proxy具体的含义代表实现接口类的实例 proxy: "UserServiceImpl@5479"，可以参考https://blog.csdn.net/yaomingyang/article/details/81040390

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Proxy;

public class Test1 {
    public static void main(String[] args) {
        IUserService service = new UserServiceImpl();
        LogInvocationHandler handler = new LogInvocationHandler();
        handler.setService(service);
        //getProxyClass(classLoader,接口的类)
        Class<?> proxyClass = Proxy.getProxyClass(service.getClass().getClassLoader(), IUserService.class);
        try {
            IUserService proxy = (IUserService) proxyClass.getConstructor(InvocationHandler.class).newInstance(handler);
            proxy.addUser();
            proxy.deleteUser();
            proxy.readUser();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    }
}

5.输出

[Log]:addUsercalled
add user
[Log]:addUserdone
[Log]:deleteUsercalled
delete user
[Log]:deleteUserdone
[Log]:readUsercalled
read user
[Log]:readUserdone
Process finished with exit code 0