设计模式-代理模式

---

一、什么是代理？

ps：代理模式就是为其他对象提供一种代理来控制这个对象的访问，在某些情况下一个对象不适合或不能直接引用另一个对象，而代理对象可以在客户类和目标对象直接起到中介的作用.简单理解一个对象要做一个事，不是自己去做，而是交给一个中介来做。

• 应用场景：如果我们有一个类有三个方法但是不能满足我们的需求，我们很容易想到在加不就完事了吗？但是这违背了开闭原则（OCP，对扩展开放，修改关闭）和单一职责（SRP）这时候代理模式就派上用场了
• 代理的种类：主要有静态代理和动态代理(jdk和cglib)

二、案例

2.1 静态代理

// 公共接口有一个卖u盘的方法 
public interface UsbSell {
    float sell(float price);
}

//不同的厂商卖不同的u盘
//厂家，不接受用户的单独购买，需要商家
public class JSDUsbFactory implements UsbSell {
    @Override
    public float sell(float price) {
        System.out.println("金是顿的u盘");
        return 20;
    }
}

//这时候我们就需要一个中间的媒介去销售他
//淘宝
public class TaoBao implements UsbSell {
    //声明u盘厂家
    private JSDUsbFactory factory=new UsbFactory();
    @Override
    public float sell(float price) {
        float p=factory.sell(price);
      	p=p+22;
        System.out.println("这是增加的功能");
        return p;
    }
}

//微信
public class WeiShang implements UsbSell {
    private JSDUsbFactory factory=new UsbFactory();
    @Override
    public float sell(float price) {//调用目标方法，增强功能
        float p = factory.sell(price);
        p=p+1;
        System.out.println("这是微商增加的功能");
        return p;
    }
}

// 购买调用测试
//我们根据我们需要的增强去new不同的增强类就好了
public class ShopMain {
    public static void main(String[] args) {
        TaoBao taoBao=new TaoBao();
        float price=taoBao.sell(100);
        System.out.println("淘宝的销售价："+price);
    }
}

总结：
优点:
-实现简单
-容易理解
缺点:
-当目标类增多了，代理类也需要增加（例如：上例中创建了一个工厂类，那么该类只能代表一个工厂，当建立了其它品牌的工厂后，还需要为该工厂创建代理类）当接口的方法增加或修改的时候，很多类都需要修改。因为，目标类和代理类都实现了相同的接口。

2.2 动态代理

2.2.1动态代理的优势

    使用动态代理我们就不需要创建类似TaoBao和微商这两个类了，我们可以使用jdk的反射机制,创建对象的能力,创建的是代理类的的对象.而不用我们创建类文件,不用写java文件, 什么叫动态?在程序执行时,调用jdk提供的方法才能创建代理类的对象，动态代理的优势就很明显了,1.代理类数量可以很少,2.当你修改了接口中的方法时,不会影响代理类。

2.2.2动态代理的实现方式

• jdk动态代理:使用java反射包中的类和接口实现动态代理的功能,反射包java.lang.reflect,里面有三个类:InvocationHandler,Method,Proxy

• cglib动态代理: cglib是第三方的工具库,创建代理对象cglib的原理是继承，cglib通过继承目标类，创建它的子类，在子类中重写父类中同名的方法，实现功能的修改。因为cglib是继承，重写方法，所以要求目标类不能是fina1的，方法也不能是final的。cglib的要求目标类比较宽松，只要能继承就可以了。cglib在很多的框架中使用(mybatis,spring)

• 先来看下反射

package Test;
public class TestApp {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
   //       我们最为熟悉的手动创建对象
//        HelloService service = new HelloServiceImpl();
//        service.sayhello("张三");
//        下面我们使用反射机制进行创建sayhello方法
        HelloServiceImpl target = new HelloServiceImpl();
//        获取sayhello名称对应的Method类对象
//        parameterTypes参数是一个类对象数组，按声明的顺序标识方法的形式参数类型。
        Method method = HelloService.class.getMethod("sayhello", String.class);
        /*
        *  public Object invoke(Object obj, Object... args)
        *       表示执行方法的调用
        *   参数:
        *       1.Object,表示对象,要执行这个对象的方法
        *       2.Object...args,方法执行时的参数值
        * 返回值:
        *       Object:方法执行后的返回值
        * */
        Object ret = method.invoke(target, "李四");
    }
}

• 再来看下jdk动态代理

interface People {
  public abstract   void eat();
}

public class Women implements People{
    @Override
    public void eat() {
        System.out.println("xxx");
    }
}

public class Man implements People {
    @Override
    public void eat() {
       People objectProxy= (People) Proxy.newProxyInstance(//创建接口实例
               People.class.getClassLoader(),//用目标对象有相同的类加载器，动态代理类运行时创建，将类加载到内存(反射)
               new Class[]{People.class},//被代理的类所实现的接口（可以是多个）
               new InvocationHandler() {//书写逻辑
                   @Override//方法执行时，都将调用一次invoke
                   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                       System.out.println("前置方法");
                       method.invoke(new Women,args);//执行目标对象的方法
                       System.out.println("后置方法！！");
                       return null;
                   }//proxy：代理后的实例对象
                    //method：对象被调用的方法
                    //args：调用时的参数
               }
       );
    }
}

• 动态代理改造上述案例

public interface UsbSell {
    float sell(float price);
}

public class UsbFactory implements UsbSell {
    @Override
    public float sell(float price) {
        System.out.println("目标类");
        return 70f;//厂家的U盘价格
    }
}

public class MySellHandler implements InvocationHandler {
    private  Object target=null;
    //动态代理的目标对象是动态的，需要传入进来，传进来的是谁就给谁创建代理
    public MySellHandler(Object target){
        this.target=target;
    }
    //args代表传进来的参数
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object res=null;
        res=method.invoke(target,args);
        if(res!=null){
            Float price=(Float)res;
            price=price+25;
            res=price;
        }
        System.out.println("xx");
        return res;
    }
}

public class Test {
    public static void main(String[] args) {
        UsbSell usbFactory=new UsbFactory();
        InvocationHandler invocationHandler=new MySellHandler(usbFactory);
        //创建代理对象
        UsbSell proxy= (UsbSell) Proxy.newProxyInstance(
                usbFactory.getClass().getClassLoader(),
                usbFactory.getClass().getInterfaces(),
                invocationHandler
        );
        System.out.println(proxy.sell(100));
    }
}

ps:项目中主要别人的方法我们可能不能满足我们业务的需求我们又不能该别人的代码这个时候代理模式就可以很好的帮我们解决这个问题