代理模式

基础介绍

代理模式：为一个对象提供一个替身，以控制对这个对象的访问。即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的
功能操作,即扩展目标对象的功能。
代理模式有不同的形式, 主要有三种 静态代理、动态代理 (JDK代理、接口代理)和 Cglib代理 (可以在内存动态的创建对象，而不需要实现接口， 他是属于
动态代理的范畴) 。

静态代理

需求，在一个用户新增操作前后增加一些操作。

第一步：定义一个接口:IUserDao

public interface IUserDao {

    public void saveUser();
}

第二步：目标对象UserDao实现接口IUserDao

public class UserDao implements IUserDao{
    @Override
    public void saveUser() {
        System.out.println("新增用户");
    }
}

第三步:使用静态代理方式,就需要在代理对象UserDaoProxy中也实现IUserDao

public class UserDaoProxy implements IUserDao{

    private IUserDao target;

    public UserDaoProxy(IUserDao target) {
        this.target = target;
    }

    @Override
    public void saveUser() {
        System.out.println("新增之前  进行业务处理");
        target.saveUser();
        System.out.println("新增之后  进行业务处理");
    }
}

第四步:调用的时候通过调用代理对象的方法来调用目标对象

public class Client {

    public static void main(String[] args) {
        //目标对象
        UserDao userDao = new UserDao();
        //代理对象
        UserDaoProxy userDaoProxy = new UserDaoProxy(userDao);
        userDaoProxy.saveUser();
    }
}

运行结果：

总结

优点：
在不修改目标对象的功能前提下, 能通过代理对象对目标功能扩展
缺点：
1）因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类
2) 一旦接口增加方法,目标对象与代理对象都要维护

动态代理

jdk动态代理

第一步：定义一个接口:IUserDao

public interface IUserDao {

    public void saveUser();
}

第二步：目标对象UserDao实现接口IUserDao

public class UserDao implements IUserDao{
    @Override
    public void saveUser() {
        System.out.println("新增用户");
    }
}

第三步：创建代理对象生成工厂

public class ProxyFactory {

    //目标对象
    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }

    //给目标对象生产代理对象
    public Object getProxyInstance() {
        /**
         *  public static Object newProxyInstance(ClassLoader loader,
         *                                           Class<?>[] interfaces,
         *                                           InvocationHandler h)
         *   ClassLoader loader:指定当前目标对象使用的类加载器，获取加载器的方法固定。
         *   Class<?>[] interfaces:目标对象实现的接口类型，使用泛型方式确认类型。
         *   InvocationHandler h:事件处理，执行目标对象的方法时，会触发事情处理器方法，
         *                       会把当前执行的目标对象方法作为参数传入。
         */
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("jdk动态代理开始");
                        Object invoke = method.invoke(target,args);
                        System.out.println("jdk动态代理结束");
                        return invoke;
                    }
                });
    }
}

测试

public class Client {

    public static void main(String[] args) {
        //目标对象
        IUserDao userDao = new UserDao();

        //给目标对象创建代理对象
        IUserDao proxyInstance = (IUserDao)new ProxyFactory(userDao).getProxyInstance();
        proxyInstance.saveUser();
    }
}

运行结果：

Cglib动态代理

第一步：创建目标对象

public class UserDao{
    public void saveUser() {
        System.out.println("新增用户");
    }
}

第二步:创建代理对象生成工厂

public class PoxyFactory implements MethodInterceptor {

    //维护一个目标对象
    private Object target;

    public PoxyFactory(Object target) {
        this.target = target;
    }

    //返回一个代理对象，是target 对象的代理对象
    public Object getPoxyInstance() {
        //1.创建一个工具类
        Enhancer enhancer = new Enhancer();
        //2.设置父类
        enhancer.setSuperclass(target.getClass());
        //3.设置回调函数
        enhancer.setCallback(this);
        //4.创建子类对象，即代理对象
        return enhancer.create();
    }


    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

        System.out.println("Cglib代理模式开始---");
        Object invoke = method.invoke(target, args);
        System.out.println("Cglib代理模式结束---");
        return invoke;
    }
}

测试：

public class Client {

    public static void main(String[] args) {
        UserDao userDao = new UserDao();
        UserDao poxyInstance = (UserDao)new PoxyFactory(userDao).getPoxyInstance();
        poxyInstance.saveUser();
    }
}

运行结果：

总结

1）静态代理需要自己写代理类，动态代理则是动态生成代理对象。
2）如何选择代理模式：1. 目标对象需要实现接口，用JDK代理2. 目标对象不需要实现接口，用Cglib代理。
3）JDK动态代理只能对实现了接口的类生成代理，而不能针对类
4）Cglib是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法，并覆盖其中方法的增强，但是因为采用的是继承，所以该类或方法最好不要生成final，对于final类或方法，是无法继承的