设计模式--代理模式

代理模式即代理，相比于我们生活中各种中介代理，我们自己不熟悉的领域让他们代理去帮我们做，买车找中介找代理，我们只需要注重车的价格和舒适度等我们关心的问题，至于车是怎么造的那交给中介的和厂家去打交道。
在Java面向对象的模型中，而代理模式在各种框架中均有所涉及，代理模式主要分为静态代理和动态代理，代理模式主要对某个类的某个核心方法进行增强，在开发版本的改动中保证其核心方法不改动

1.静态代理

背景：现在有一个人张三，张三想买车，于是他去联系代理的销售。。。。。。

/**
 * 实体类
 */
class Person{
    //每个人都有自己的名字
    public String name;
    public Person(String name){
        this.name = name;
    }

    public void buyCar(){
        System.out.println(name+"付账买车!");
    }
}

/**
 * 代理类
 */
class CarProxy{
    //被代理对象(帮谁代理？)
    private Person person;
    public CarProxy(Person person){
        this.person = person;
    }
    public void help(){
        System.out.println("代理去帮"+person.name+"联系厂家!");
        System.out.println("代理去帮"+person.name+"挑选!");
        System.out.println("==========代理之前==========");
        person.buyCar();	//本质还是这个person在买车，核心方法
        System.out.println("==========代理之后==========");
        System.out.println(person.name+"给代理费!");
    }
}


public class StaticProxy {
    public static void main(String[] args) {
        Person person = new Person("张三");
        CarProxy buyProxy = new CarProxy(person);
        buyProxy.help();
    }
}


程序结构如下:
代理去帮张三联系厂家!
代理去帮张三挑选!
==========代理之前==========
张三付账买车!
==========代理之后==========
张三给代理费!

静态代理的优势在于若对买车这一过程进行更改，我们只需要在代理类的help方法中改动而不触及person.buyCar();的核心业务逻辑。
但是其缺点也很明显：我们得为每一个服务都得创建代理类，接口一旦发生改变，代理类也得相应修改，这就大大提升的代码的冗余性和工作量。

2.动态代理（JDK实现）

所谓动态代理，我们不需要创建具体的代理实现类，而是通过反射机制去动态生成
实现动态代理需要被代理对象实现某一个接口：

//被代理类需要实现的接口
interface Person{
    
    void buyCar();
}
//被代理类张三
class ZhangSan implements Person{
    public String name = "张三";
    @Override
    public void buyCar() {
        System.out.println(name+"付账买车!");
    }
}

class InvocationHandlerImpl implements InvocationHandler{
    private Person person;
    public InvocationHandlerImpl(Person person){
        this.person = person;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("代理去联系厂家!");
        System.out.println("代理去挑选!");
        System.out.println("==========代理之前==========");
        method.invoke(person,args);
        System.out.println("==========代理之后==========");
        System.out.println("给代理费!");
        return null;
    }
}

class Test{
    public static void main(String[] args) {
        Person person = new ZhangSan();
        Person person1 = (Person)Proxy.newProxyInstance(person.getClass().getClassLoader(), person.getClass().getInterfaces(), new InvocationHandlerImpl(person));
        person1.buyCar();
    }
}

//
代理去联系厂家!
代理去挑选!
==========代理之前==========
张三付账买车!
==========代理之后==========
给代理费!

如图动态代理可以得到和静态代理相同的结果，但是InvocationHandlerImpl 又是什么呢，上面的代码不还是创建了1个新的实现类吗？
其实不然，InvocationHandlerImpl 并非实现类，但是它确实实现了需要代理的方法method.invoke(person,args);
除此以外，InvocationHandlerImpl 实现了InvocationHandler接口，所以我们可以用匿名内部类的方式来实现，且InvocationHandler还是一个函数式接口，使用lamba表达式可以使代码更加简洁

interface Person{
    void buyCar();
}

class ZhangSan implements Person{
    public String name = "张三";
    @Override
    public void buyCar() {
        System.out.println(name+"付账买车!");
    }
}


class Test{
    public static void main(String[] args) {
        Person person = new ZhangSan();
        ClassLoader classLoader = person.getClass().getClassLoader();
        Class<?>[] interfaces = person.getClass().getInterfaces();
        Person person1 = (Person)Proxy.newProxyInstance(classLoader,interfaces, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                return method.invoke(person,args);
            }
        });
        person1.buyCar();
    }
}

撇开测试的代码不看，此时使用动态代理模式只是让代理类实现的一个接口，代码耦合度看着就很低了，但是功能仍然满足。