14.7代理

代理：是基本的设计模式之一，我们用插入的（代理者）来代替实际的对象（供应者），以此来为我们提供不同的操作和额外的方法，而代理就是两者之间的角色
静态代理:手动代理，没有去动态的创建代理对象。

package com.package14.Two;
class RealObject implements Interface{//供应者
    @Override
    public void doSomething() {
        System.out.println("RealObject doSomething()");
    }
    @Override
    public void somethingElse(String arg) {
        System.out.println("somethingElse"+arg);
    }
}
class SimplePerxy implements Interface {//代理者
    private Interface anInterface;
    SimplePerxy(Interface anInterface){
        this.anInterface=anInterface;
    }
    @Override
    public void doSomething() {
        info();
        System.out.println("SimplePerxy doSomething");//代理者自己的方法
       anInterface.doSomething();//拿到了供应者的方法
    }
    @Override
    public void somethingElse(String arg) {
        info();
        System.out.println("SimplePerxy somethingElse"+arg);//代理者自己的方法
        anInterface.somethingElse(arg);//拿到了供应者的方法
    }
    public void info(){
        System.out.println("代理者额外的方法");
    }
}
public class SimplePerxyDemo {
    public static void consumer(Interface ainterface){
          ainterface.doSomething();
          ainterface.somethingElse("boolean");
    }
    public static void main(String[] args) {
        consumer(new RealObject());
        System.out.println("================");
        consumer(new SimplePerxy(new RealObject()));
    }
}

上述的列子中，我们不仅通过代理让同一个方法表现了不同的操作。同时，代理者还提供了额外的方法
动态代理 ：动态的创建代理对象，并动态的处理对代理方法的调用

package com.package14.Two;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
class ProxyMetthed implements InvocationHandler{
    //代理者
    Object object;
    ProxyMetthed(Object object){this.object=object;}
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //该proxy对象 和Proxy.newProxyInstance产生的代理对象 是一个对象
        return method.invoke(object,args);
    }
}
interface SomeMethed{
    void test();
}
abstract class MethedDemo implements SomeMethed{
    @Override
    public void test() {
        System.out.println("语言");
    }
}
class Chains extends MethedDemo{
    @Override
    public void test() {
        System.out.println("中文");
    }
}
public class ProxyDemo {
    public static void main(String[] args) {
          info(new Chains());
    }
  static void info(Object object){
      SomeMethed someMethed=
         (SomeMethed)Proxy.newProxyInstance(SomeMethed.class.getClassLoader(),new Class[]{SomeMethed.class},new ProxyMetthed(object));
      someMethed.test();
  }
}

Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)去动态的创建代理。
方法参数使用：
1：loader：该接口的类加载器或实现该接口的类的加载器
2. interfaces：供应者的接口
获取方式
2-1，通过代理者的class对象动态获取 MethedDemo.class.getInterfaces()
注意:无法通过代理者获取接口，虽然继承供应者
System.out.println(Arrays.toString(Chains.class.getInterfaces()));
2-2，手动的方式去指定 new Class[]{SomeMethed.class}

3：h：是InvocationHandler的一个实例，供应者与代理者的中间角色(代理)；
proxy：其实和Proxy.newProxyInstance产生的代理对象 是一个对象
method：执行的代理目标方法
args：目标方法的参数
返回的Object是目标方法的返回值