代理可以理解为请一个中间人帮忙处理一些事情。

代理支持任意接口类型的实现类对象做代理，也可以直接为接本身做代理。

可以为被代理对象的所有方法做代理。

可以在不改变方法源码的情况下，实现对方法功能的增强。

简化了编程工作、提高了软件系统的可扩展性，也提高了开发效率。

关键：必须有接口，实现类要实现接口（代理通常是基于接口实现的）。创建一个实现类的对象，该对象为业务对象。为业务对象做一个代理对象。

代理的一个案例快速理解

需求：

业务功能的性能统计：某企业用户管理业务，需包含用户登录，用户删除，用户查询功能，并要统计每个功能的耗时。

分析：

1. 定义一个UserService表示用户业务接口，规定必须完成用户登录，用户删除，用户查询功能。

2. 定义一个实现类UserServiceE实现UserService，并完成相关功能，且统计每个功能的耗时。

3. 定义测试类，创建实现类对象，调用方法。

实现：

1.业务接口：

public interface UserService {
    public String login(String name,String psd);
    public void deleteUser();
    public String selectUser();

}

2.实现类

这里为了模拟方便，每个业务方法只是用sleep延时。

public class UserServiceE implements UserService {
    @Override
    public String login(String name,String psd) {
        String rs="密码错误！";
        if("admin".equals(name)&&"123456".equals(psd))
            rs="密码正确";
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return rs;
    }
    @Override
    public void deleteUser() {
        System.out.println("删除用户~");
        try {
            Thread.sleep(1500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    @Override
    public String selectUser() {
        System.out.println("查询用户~");
        try {
            Thread.sleep(2500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "查询了用户~";
    }
}

3.代理类

代理类里面需要传入实现类的对象，在里面就用到了反射的一些知识。

1. 写好一个接口类型的静态方法，直接写return返回代理 Proxy

2. 方法newProxyInstance

3. 对于newProxyInstance有三个参数：类、接口和InvocationHandler

4. 实现InvocationHandler

5. 在invoke里面运行目标方法，invoke反射。

public class proxyUtil {
    public static UserService getProxy(UserService obj){
        return (UserService) Proxy.newProxyInstance(obj.getClass().getClassLoader(),
                obj.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        long startTime=System.currentTimeMillis();

                        Object rs = method.invoke(obj,args);

                        long endTime=System.currentTimeMillis();
                        System.out.println(method.getName()+" 耗时："+(endTime-startTime)/1000.0+"秒。");
                        return rs;
                    }
                });
    }
}

4.main方法

使用动态代理后，就不用再在各个方法中进行修改代码来统计了，而且可扩展性更好。如果对代理类实现泛型，就更加通用了。

    public static void main(String[] args) {
        UserService u= proxyUtil.getProxy( new UserServiceE());

        System.out.println(u.login("admin", "123456"));
        u.deleteUser();
        System.out.println(u.selectUser());
    }