动态代理设计模式

动态代理描述：
代理就是被代理者没有能力或者不愿意去完成某件事情，需要找别人代替自己去完成这件事。动态代理只能为实现接口的实现类对象做代理(也可以只为接口做代理对象)。
动态在业务上的应用：
a.在业务开发中经常存在很多重复的方法代码，他们前后的代码形式是一样的。
b.只有中间部分有差别，这种时候出现代码冗余
c.动态代理可以解决这种情况，直接省略前后的重复的代码，然后就可以避免这种冗余现象
业务介绍：需要记录用户登录时间、查询数据时间、删除时间（起始时间和结束时间的方法都是一样的）
在Java的步骤：
1、必须有接口
2、实现类要实现接口，定义自己的业务功能代码
3、为业务对象做代理对象
4、测试
（1）面向接口编程，定义接口

public interface UserService {
    String login(String loginName, String passWord);
    void getUsers();
    void deleteUsers();
}

（2）实现类（重写接口所有方法，编写自己的业务代码）

public class UserServiceImpl implements UserService {
    @Override
    public String login(String loginName, String passWord) {
        String msg = "登录失败";
        try {
            if("admin".equals(loginName) && "123456".equals(passWord)){
                msg = "success";//判断用户和密码是否正确，正确则输出success
            }
            Thread.sleep(2000);//睡眠2秒，由于时间太快所以让它睡眠，显示效果
        } catch (Exception e) {
            e.printStackTrace();
        }
        return msg;
    }

    @Override
    public void getUsers() {
        try {
            Thread.sleep(3000);
            System.out.println("查询数据！");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    @Override
    public void deleteUsers() {
        try {
            Thread.sleep(1500);
            System.out.println("删除数据！");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

（3）为业务对象做代理对象
Java官方提供了Proxy类生成代理对象返回：
public static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)
1、obj.getClass().getClassLoader()目标对象通过getClass方法获取类的所有信息后，调用getClassLoader() 方法来获取类加载器。获取类加载器后，可以通过这个类型的加载器，在程序运行时，将生成的代理类加载到JVM即Java虚拟机中，以便运行时需要！
2、obj.getClass().getInterfaces()获取被代理类的所有接口信息，以便于生成的代理类可以具有代理类接口中的所有方法。
3、InvocationHandler 这是调用处理器接口，它自定义了一个 invoke 方法，用于集中处理在动态代理类对象上的方法调用，通常在该方法中实现对委托类方法的处理以及访问.

public class ProxyUtil {
    public static <T> T getProxy(T obj) {
        return (T) Proxy.newProxyInstance(obj.getClass().getClassLoader()
                , obj.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        // proxy : 代表当前代理对象本身，一般不用
                        // method：代表正在执行且被代理的方法对象
                        // args :代表了在执行且被代理的方法的参数！
                        long startTime = System.currentTimeMillis();

                        // 触发真正被代理的方法执行：
                        Object result =  method.invoke(obj , args);

                        long endTime = System.currentTimeMillis();
                        System.out.println(method.getName() + "方法耗时："+ (endTime - startTime) /1000.0 + "s");

                        return result;
             }
        });
    }
}

（4）测试

public class TestDemo {
    public static void main(String[] args) {
        // 1、创建业务实现类对象
        UserService userService = ProxyUtil.getProxy(new UserServiceImpl());
        System.out.println(userService.login("admin" , "123456")); //先走代理，代理在调方法
        userService.getUsers();
        userService.deleteUsers();
    }
}

优点：
***动态代理非常的灵活，可以为任意的接口实现类对象做代理
***动态代理可以为被代理对象的所有接口的所有方法做代理，
***动态代理可以在不改变方法源码的情况下，实现对方法功能的增强，
***动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，
***因为Java 反射机制可以生成任意类型的动态代理类。
***动态代理同时也提高了开发效率。
缺点：
***只能针对接口或者接口的实现类对象做代理对象，普通类是不能做代理对象的。