简单的代理模式

代理模式

     1、什么是代理模式

             1、为其他对象提供一种代理，也就是在前置，后置，增加业务，spring中的aop就是使用的代理模式

             2、代理模式分为动态代理和静态代理，动态代理和静态代理的区别就是不需要为每一个目标类都去创建一个代理对象，简化了编程工作

    2、代理类特点

              1、代理类和目标类拥有共同的接口

              2、代理类在目标类执行方法前后进行一些处理

              3、和代理模式的区别：装饰模式主要是传入一个对象，来对这个对象进行增强能力，即使怎么装饰，对象还是这个对象，不变。

                    代理模式是在自己的构造器中new一个新的对象，调用者不需要知道这个对象是谁，只需要知道事情做了就好了。

   3、代码实现

             需求：我们利用打官司这个需求来实现代理模式，需求的核心点为人要打官司，需要律师来帮忙打官司，以下为代码的实现

         1、静态代理

                   1、首先创建一个打官司的类

//打官司
public interface Law {
    void law();
}

                   2、创建用户，即使有律师也需要用户自己陈述事实

public class Person implements Law{
    @Override
    public void law() {
        System.out.println("陈述事实");
    }
}

                  3、主要还是要律师来处理这场官司，现在来请出律师，这里发现用户类是代理类自己new出来的，和装饰模式的区别

//律师
public class Lawyer implements Law{

    private Person person;
    @Override
    public void law() {
        zbcl();
        if(person == null){
            person = new Person();
        }
        person.law();
        gsjs();
    }

    public void zbcl(){
        System.out.println("准备材料");
    }

    public void gsjs(){
        System.out.println("官司结束");
    }

}

                   4、现在来调用律师来打官司，这样静态代理就完成了

 public static void main(String[] args) {
        //主要还是律师来处理事情的，此时只需要调用律师来执行就可以了，律师会把这场官司打完
        Lawyer lawyer = new Lawyer();
        lawyer.law();
 }

         2、JDK动态代理

                       保存生成的动态代理的对象：System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

                1、介绍

                          1、只能代理实现了接口的类，传入子类的类加载器和接口数组，就可以返回该类的接口，并执行接口中的方法

                          2、动态代理类需要实现InvocationHandler接口中的invoke方法，再根据反射的方式执行

                          3、原理是生成一个和目标类一致的$Proxy的类，该类实现了目标类接口并且继承Proxy类。并第二步创建Handler类实现InvocationHandler，将实现后的Handler传入到$Proxy中，$Proxy类将自己对象本身和自己的方法传入到Handler中，也就是实际执行的是Handler中的方法invoke，这样也就实现了动态代理

                          4、为什么需要实现接口的原因，是因为jdk生成的代理类继承了Proxy类，所以不能再去继承一个类的，只能只能实现该类的接口

                 2、代码

                         1、动态代理类

public class MyHandler implements InvocationHandler {

    Person person;

    //将要被代理的对象用构造的方式注入
    public MyHandler(Person person) {
        this.person = person;
    }

    /**
     *
     * @param proxy 生成的$Proxy类
     * @param method 执行的方法
     * @param args 方法内的参数
     * @return  方法的返回值
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //返回要执行的方法，然后去执行方法
        System.out.println("准备材料");
        method.invoke(person, args);
        System.out.println("官司结束");
        return null;
    }



    public static void main(String[] args) {
        MyHandler myHandler = new MyHandler(new Person());
//        //生成代理对象  使用代理类生成代理
        Class<Person> personClass = Person.class;
        Law law = (Law) Proxy.newProxyInstance(personClass.getClassLoader(),personClass.getInterfaces(), myHandler);
        law.law();
    }

}

                         2、执行

           3、cglib动态代理

                  1、介绍

                                1、针对类来实现代理

                                2、对要代理的类产生一个子类，通过方法拦截来自父类的调用

                 2、实现方式

                               1、导入cglib包，实现MethodInterceptor接口，并实现intercept方法

                               2、这样相当于复制了一个子类继承父类，然后就可以用子类调用父类的方法来执行，invokeSuper就是可以调用父类的方法，传入父类对象，传入参数即可

                               3、用Enhancer对象来明确要复制的父类，并且复制完返回当前对象。

public class MyHandler implements MethodInterceptor {
    /**
     * 拦截目标类所有的调用
     * @param obj 目标类（也就是父类）
     * @param method 目标方法的反射对象
     * @param args  方法的参数
     * @param proxy  代理类（也就是动态生成的子类，父类是obj）
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        //代理类（子类）调用目标类（父类）的方法
        System.out.println("准备材料");
        proxy.invokeSuper(obj,args);
        System.out.println("官司结束");

        return null;
    }


    public static void main(String[] args) {

        Enhancer enhancer = new Enhancer();
        //把传进来的class 作为父类 复制
        enhancer.setSuperclass(Person.class);
        //把当前对象返回
        enhancer.setCallback(new MyHandler());
        //返回创建好的子类
        Person person = (Person)enhancer.create();
        person.law();
    }

}