设计模式-12代理模式

代理模式

介绍：

• 代理模式为对象提供一个替身，以控制对这个对象的访问，即通过代理对象访问目标对象，这样做的好处是，可以在目标对象实现的基础上，增强额外的功能和操作，即扩展了目标对象的功能
• 被代理的对象可以是远程对象、创建开销大的对象或者需要安全控制的对象
• 代理模式又不同形式，主要可以分为三种：
  1）静态代理
  2）动态代理，也可以成为JDK代理，接口代理
  3）Cglib代理，可以在内存中动态的创建对象，而不需要实现接口，他是属于动态代理的范畴

静态代理

介绍：

​ 静态代理在使用时，需要定义接口或者父类，被代理对象与代理对象一起实现相同的接口或者是继承相同父类

public interface ITeacherDao {
    void teach();
}

/**
 * 目标类
 */
public class TeacherDao implements ITeacherDao {
    @Override
    public void teach() {
        System.out.println("老师在上课...");
    }
}

/**
 * 代理类
 */
public class TeacherDaoProxy implements ITeacherDao{

    private ITeacherDao iTeacherDao;

    public TeacherDaoProxy(ITeacherDao iTeacherDao) {
        this.iTeacherDao = iTeacherDao;
    }

    @Override
    public void teach() {
        System.out.println("执行目标方方法之前的一些操作。。。");
        iTeacherDao.teach();
        System.out.println("执行目标方法之后的一些操作。。。");
    }
}

public class Client {
    public static void main(String[] args) {
        TeacherDao teacherDao = new TeacherDao();
        TeacherDaoProxy teacherDaoProxy = new TeacherDaoProxy(teacherDao);

        teacherDaoProxy.teach();
    }
}

总结：

优点：在不修改目标对象的功能前提下，能通过代理对象对目标功能扩展

缺点：因为代理对象需要与目标对象实现一样的接口所以会有很多代理类，一旦接口增加方法，目标对象与代理对象都要维护

动态代理

介绍：

• 代理对象，不需要实现接口，但目标对象要实现接口，否则不能用动态代理
• 代理对象的生成，是利用JDK的API，动态的在内存中构建代理对象
• 动态代理也叫做JDK代理或者接口代理

JDK中生成代理对象的API

• 代理类所在包：java.lang.reflect.Proxy

• JDK实现代理只需要使用newProxyInstance方法，但是该方法需要接收三个参数，完整的写法是：

static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)

public interface ITeacherDao {
    void teach();

    void sayHello(String name);
}

/**
 * 目标类
 */
public class TeacherDao implements ITeacherDao {
    @Override
    public void teach() {
        System.out.println("老师在上课...");
    }

    @Override
    public void sayHello(String name) {
        System.out.println("你好!" + name);
    }
}

public class ProxyFactory {

    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }
    //public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
    /**
     * 1.ClassLoader:指定当前目标对象使用的类加载器，获取加载器的方法固定
     * 2.Class<?>[] interfaces：目标对象实现的接口类型，使用反向方法确定类型
     * 3.InvocationHandler h：事件处理，执行目标对象的方法时，会触发事件处理器方法，
     * 会把当前执行的目标对象方法作为参数传入
     */
    public Object getProxyInstance() {
        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("执行代理方法开始。。");
                Object returnVal = method.invoke(target, args);
                System.out.println("执行代理方法结束。。");
                return returnVal;
            }
        });
    }
}

public class Client {
    public static void main(String[] args) {
        //创建目标对象
        ITeacherDao target = new TeacherDao();
        //给目标对象创建代理对象，可以转成ITeacherDao
        ITeacherDao proxyInstance = (ITeacherDao) new ProxyFactory(target).getProxyInstance();
        //proxyInstancecom.h3c.com.designpattrn.proxy.dynamic.TeacherDao@12a3a380
        //每次调用法法时都会触发InvocationHandler中的方法，只有调用方法时才会执行目标方法
        //System.out.println("proxyInstance" + proxyInstance);
        //System.out.println("proxyInstance" + proxyInstance);
        //proxyInstanceclass com.sun.proxy.$Proxy0 内存中生成的代理对象
        System.out.println("proxyInstance" + proxyInstance.getClass());
        //proxyInstance.teach();
        /**
         * 执行代理方法开始。。
         老师在上课...
         执行代理方法结束。。
         */
        proxyInstance.sayHello("tom");
    }
}

Cglib代理

介绍：

• 静态代理和JDK代理模式都要求目标对象时实现一个接口，但是有时候目标对象只是一个单独的对象，并没有实现任何接口，这个时候可使用目标对象子类来实现代理就是Cglib代理

• Cglib代理也叫做子类代理，他是内存中构建一个子类对象从而实现对目标对象功能扩展，有些书也叫Cglib代理归属到动态代理

• Cglib是一个强大的高性能的代码生成包，它可以在运行期扩展java类与实现java接口，它广泛的被许多AOP的框架使用，例如spring aop，实现方法拦截

• 在aop编程中如何选择代理模式

  1.目标对象需要实现接口，用JDK代理

  2.目标对象不需要实现接口，用Cglib代理

• Cglib包的底层是通过使用字节码处理框架ASM来转换字节码并生成新的类

Cglib代理实现步骤：

• 引入Cglib的jar文件
• 在内存中动态构建子类，注意代理类不能为final，否则会报错
• 目标对象的方法如果为final/static，那么就不会被拦截，即不会执行目标对象额外的业务方法
  

<!--添加cglib依赖包 -->
		<dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.2.2</version>
        </dependency>
        public class TeacherDao {
    public void teach() {
        System.out.println("老师在上课...");
    }

    public void sayHello(String name) {
        System.out.println("你好!" + name);
    }
}

/**
 * cglib代理借助于Enhancer获取代理对象
 */
public class ProxyFactory implements MethodInterceptor {
    //维护一个目标对象
    private Object target;
    //构造器
    public ProxyFactory(Object target) {
        this.target = target;
    }

    public Object getProxyInstance(){
        //1.创建一个工具类
        Enhancer enhancer = new Enhancer();
        //2.设置父类
        enhancer.setSuperclass(target.getClass());
        //3.设置回调函数
        enhancer.setCallback(this);
        //4.创建代理对象
        return enhancer.create();
    }
    //重写intercept方法，会调用目标对象的方法
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("执行cglib代理之前、、、开始");
        Object returnVal = method.invoke(target, args);
        System.out.println("执行cglib代理之后、、、结束");
        return returnVal;
    }
}


public class Client {
    public static void main(String[] args) {
        //创建目标对象
        TeacherDao target = new TeacherDao();
        //获取代理对象
        TeacherDao proxyInstance = (TeacherDao)new ProxyFactory(target).getProxyInstance();
        //执行目标方法
        proxyInstance.teach();
        proxyInstance.sayHello("jack");
    }