代理模式知识了解

代理模式

代理模式是指，为其他对象提供一种代理以控制对这个对象的访问。

在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户类和目标对象之间起到中介的作用。

换句话说，使用代理对象，是为了在不修改目标对象的基础上，增强主业务逻辑。

客户类真正的想要访问的对象是目标对象，但客户类真正可以访问的对象是代理对象。

客户类对目标对象的访问是通过访问代理对象来实现的。

当然，代理类与目标类要实现同一个接口。

例如：有 A，B，C 三个类， A 原来可以调用 C 类的方法，现在因为某种原因 C 类不允许A 类调用其方法，

但 B 类可以调用 C 类的方法。A 类通过 B 类调用 C 类的方法。这里 B 是 C 的代理。A 通过代理 B 访问 C。

原来的访问关系：

A类-----可以访问------->C类

通过代理的访问关系：

A类-----不可以访问------>C类

B类-----可以访问------->C类

A类-----可以访问------->B类

A类----->访问B类----->访问C类

Window 系统的快捷方式也是一种代理模式。快捷方式代理的是真实的程序，双击快捷方式是启动它代表的程序。

使用代理模式的作用

（1）功能增强：在你原有的功能上，增加了额外的功能，新增加的功能，叫做功能增强。

（2）控制访问：代理类不让你访问目标，例如商家不让用户访问厂家。

代理模式分类

可以将代理分为两类：静态代理与动态代理。

静态代理

1）代理类是自己手工实现的，自己创建一个java类，表示代理类。

2）同时你所要代理的目标类是确定的。

特点： 1）实现简单 2）容易理解。

模拟一个用户购买u盘的行为

用户是客户端类

商家：代理，代理某个品牌的u盘。

厂家：目标类。

三者的关系： 用户（客户端）—商家（代理）—厂家（目标）

商家和厂家都是卖u盘的，他们完成的功能是一致的，都是卖u盘。

实现步骤：

创建一个接口，定义卖u盘的方法，表示你的厂家和商家做的事情。
创建厂家类，实现1步骤的接口。
创建商家，就是代理，也需要实现1步骤中的接口。
创建客户端类，调用商家的方法买一个u盘。

实现

（1）定义业务接口

package com.kwxy.service;

// 表示功能的，厂家，商家都要完成的功能
public interface UsbSell {

    //定义方法 参数 amount:表示一次购买的数量，暂时不用
    //返回值表示一个u盘的价格。
    float sell(int amount);

    //可以多个其它的方法
    //void print();
}

（2）定义接口实现类

目标类 UsbKingFactory(金士顿 u 盘)，该类实现了业务接口。

package com.kwxy.factory;

import com.kwxy.service.UsbSell;

//目标类： 金士顿厂家, 不接受用户的单独购买。
public class UsbKingFactory implements UsbSell {
    @Override
    public float sell(int amount) {
        System.out.println("目标类中的方法调用 , UsbKingFactory 中的sell ");
        //一个128G的u盘是 85元。
        //后期根据amount ，可以实现不同的价格，例如10000个，单击是80， 50000个75
        return 85.0f;
    }
}

（3）代理商TaoBao

TaoBao 就是一个代理类，代理厂家销售 u 盘

package com.kwxy.shangjian;

import com.kwxy.factory.UsbKingFactory;
import com.kwxy.service.UsbSell;

//taobao是一个商家，代理金士顿u盘的销售。
public class TaoBao implements UsbSell {

    //声明 商家代理的厂家具体是谁
    private UsbKingFactory factory = new UsbKingFactory();

    @Override
    //实现销售u盘功能
    public float sell(int amount) {

        //向厂家发送订单，告诉厂家，我买了u盘，厂家发货
        float price = factory.sell(amount); //厂家的价格。
        //商家 需要加价， 也就是代理要增加价格。
        price = price + 25; //增强功能，代理类在完成目标类方法调用后，增强了功能。
        //在目标类的方法调用后，你做的其它功能，都是增强的意思。
        System.out.println("淘宝商家，给你返一个优惠券，或者红包");

        //增加的价格
        return price;
    }
}

（4）代理商WeiShang

WeiShang 就是一个代理类，代理厂家销售 u 盘。

package com.kwxy.shangjian;

import com.kwxy.factory.UsbKingFactory;
import com.kwxy.service.UsbSell;

public class WeiShang implements UsbSell {
    //代理的是 金士顿，定义目标厂家类
    private UsbKingFactory factory = new UsbKingFactory();
    @Override
    public float sell(int amount) {
        //调用目标方法
        float price = factory.sell(amount);
        //只增加1元
        price = price + 1;
        return price;
    }
}

（5）客户端调用者，购买商品类

package com.kwxy;

import com.kwxy.shangjian.TaoBao;
import com.kwxy.shangjian.WeiShang;

public class ShopMain {

    public static void main(String[] args) {
        //创建代理的商家taobao对象
//        TaoBao taoBao = new TaoBao();
//        通过代理类，实现购买u盘，增加了优惠券，红包等等
//        float price = taoBao.sell(1);
//        System.out.println("通过淘宝的商家，购买u盘单价："+price);


        WeiShang weiShang = new WeiShang();
        //通过代理类，实现购买u盘，增加了优惠券，红包等等
        float price = weiShang.sell(1);
        System.out.println("通过微商购买的价格："+ price);

    }
}

（5）如果目标类增加了，比如增加了一个闪迪厂家

package com.kwxy.factory;

import com.kwxy.service.UsbSell;

//目标类： 闪迪厂家, 不接受用户的单独购买。
public class UsbSanFactory implements UsbSell {
    @Override
    public float sell(int amount) {
        System.out.println("闪迪 目标类中的方法调用 , UsbSanFactory 中的sell ");
        //一个128G的u盘是 85元。
        //后期根据amount ，可以实现不同的价格，例如10000个，单击是80， 50000个75
        return 85.0f;
    }
}

（6）还得重新增加闪迪的TaoBao和WeiShang代理类

package com.kwxy.shangjian;

import com.kwxy.factory.UsbSanFactory;
import com.kwxy.service.UsbSell;

//taobao是一个商家，代理金士顿u盘的销售。
public class TaoBaoSanDi implements UsbSell {

    //声明 商家代理的厂家具体是谁
    private UsbSanFactory factory = new UsbSanFactory();

    @Override
    //实现销售u盘功能
    public float sell(int amount) {

        //向厂家发送订单，告诉厂家，我买了u盘，厂家发货
        float price = factory.sell(amount); //厂家的价格。
        //商家 需要加价， 也就是代理要增加价格。
        price = price + 25; //增强功能，代理类在完成目标类方法调用后，增强了功能。
        //在目标类的方法调用后，你做的其它功能，都是增强的意思。
        System.out.println("淘宝商家，给你返一个优惠券，或者红包");

        //增加的价格
        return price;
    }
}

package com.kwxy.shangjian;

import com.kwxy.factory.UsbSanFactory;
import com.kwxy.service.UsbSell;

public class WeiShangSanDi implements UsbSell {
    //代理的是 闪迪，定义目标厂家类
    private UsbSanFactory factory = new UsbSanFactory();
    @Override
    public float sell(int amount) {
        //调用目标方法
        float price = factory.sell(amount);
        //只增加1元
        price = price + 1;
        return price;
    }
}

缺点

当你的项目中，目标类和代理类很多时候，有以下的缺点：

（1）当目标类增加了，代理类可能也需要成倍的增加。代理类数量过多。

（2）当你的接口中功能增加了，或者修改了，会影响众多的实现类，厂家类，代理都需要修改。影响比较多。

代理类完成的功能

（1）目标类中方法的调用

（2）功能增强

动态代理

动态代理是指代理类对象在程序运行时由 JVM 根据反射机制动态生成的。动态代理不需要定义代理类的.java 源文件。

动态代理其实就是 jdk 运行期间，动态创建 class 字节码并加载到 JVM。

动态代理的实现方式常用的有两种：使用 JDK 动态代理，与通过 CGLIB 动态代理。

在静态代理中目标类很多时候，可以使用动态代理，避免静态代理的缺点。

动态代理中目标类即使很多：

1）代理类数量可以很少。

2）当你修改了接口中的方法时，不会影响代理类。

jdk动态代理（理解）

使用java反射包中的类和接口实现动态代理的功能。

反射包 java.lang.reflect , 里面有三个类：InvocationHandler ，Method，Proxy。

jdk 动态代理是基于 java 的反射机制实现的。使用 jdk 中接口和类实现代理对象的动态创建。

jdk 的动态要求目标对象必须实现接口，这是 java 设计上的要求。

InvocationHandler 接口

InvocationHandler 接口叫做调用处理器，负责完调用目标方法，并增强功能。

通过代理对象执行目标接口中的方法，会把方法的调用分派给调用处理器(InvocationHandler)的实现类，

执行实现类中的 invoke()方法，我们需要把功能代理写在 invoke ()方法中。

public Object invoke(Object proxy, Method method, Object[] args)

方法原型：

参数：

Object proxy：jdk创建的代理对象，无需赋值。

Method method：目标类中的方法，jdk提供method对象的

Object[] args：目标类中方法的参数， jdk提供的。

InvocationHandler 接口：表示你的代理要干什么。

怎么用：

（1）创建类实现接口InvocationHandler

（2）重写invoke（）方法，把原来静态代理中代理类要完成的功能，写在这。

Method类

表示方法的，确切的说就是目标类中的方法。

InvocationHandler中的invoke()方法的第二个参数为 Method 类对象，该类有一个方法也叫 invoke()，可以调用目标方法。

这两个 invoke()方法，虽然同名，但无关。

public Object invoke ( Object obj, Object... args)

obj：表示目标对象

args：表示目标方法参数，就是其上一层 invoke 方法的第三个参数

该方法的作用是：调用执行 obj 对象所属类的方法，这个方法由其调用者 Method 对象确定。

在代码中，一般的写法为 method.invoke(target, args);

Proxy 类

通过 JDK 的 java.lang.reflect.Proxy 类实现动态代理，会使用其静态方法 newProxyInstance()，依据目标对象、业务接口及调用处理器三者，自动生成一个动态代理对象。

之前创建对象都是 new 类的构造方法()，现在我们是使用Proxy类的方法，代替new的使用。

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

ClassLoader loader：类加载器，负责向内存中加载对象的。使用反射获取对象的ClassLoader。

Class<?>[] interfaces：接口数组，目标对象实现的接口，也是反射获取的。

InvocationHandler handler：我们自己写的，代理类要完成的功能。

返回值：就是代理对象。

cgLib代理（了解）

cglib动态代理（了解）: cglib是第三方的工具库，创建代理对象。

cglib的原理是继承， cglib通过继承目标类，创建它的子类，在子类中重写父类中同名的方法，实现功能的修改。

因为cglib是继承，重写方法，所以要求目标类不能是final的，方法也不能是final的。

cglib的要求目标类比较宽松，只要能继承就可以了。cglib在很多的框架中使用，

比如 mybatis ，spring框架中都有使用。

但对于无接口的类，要为其创建动态代理，就要使用 cglib来实现。

对于 cglib 一般的开发中并不使用。做了一个了解就可以。

jdk 动态代理实现

实现动态代理的步骤：

1. 创建接口，定义目标类要完成的功能
2. 创建目标类实现接口
3. 创建InvocationHandler接口的实现类，在invoke方法中完成代理类的功能
  （1）调用目标方法
  （2）增强功能

   使用步骤：
  （1）创建目标对象。
  （2）创建InvocationHandler对象。
  （3）使用Proxy类的静态方法，创建代理对象，并把返回值转为接口类型。
  （4）通过代理执行方法。

参考代码：

（1）创建接口，定义目标类要完成的功能

package com.kwxy.service;

//目标接口
public interface UsbSell {

    float sell(int amount);

    void print();
}

（2）创建目标类实现接口

package com.kwxy.factory;

import com.kwxy.service.UsbSell;

//目标类
public class UsbKingFactory implements UsbSell {
    @Override
    public float sell(int amount) {
        //目标方法
        System.out.println("目标类中，执行sell目标方法");
        return 85.0f;
    }

    @Override
    public void print() {

    }
}

（3）创建InvocationHandler接口的实现类，在invoke方法中完成代理类的功能

package com.kwxy.handler;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

//必须实现InvocationHandler接口，完成代理类要做的功能（1.调用目标方法，2.功能增强）
public class MySellHandler implements InvocationHandler {

    private Object target = null;

    //动态代理：目标对象是活动的，不是固定的，需要传入进来。
    //传入是谁，就给谁创建代理。
    public MySellHandler(Object target) {
        //给目标对象赋值
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        Object res  = null;
        //向厂家发送订单，告诉厂家，我买了u盘，厂家发货
        //float price = factory.sell(amount); //厂家的价格。
        res =  method.invoke(target,args); //执行目标方法



        //商家 需要加价， 也就是代理要增加价格。
        //price = price + 25; //增强功能，代理类在完成目标类方法调用后，增强了功能。
        if( res != null ){
            Float price = (Float)res;
            price = price + 25;
            res = price;
        }

        //在目标类的方法调用后，你做的其它功能，都是增强的意思。
        System.out.println("淘宝商家，给你返一个优惠券，或者红包");
        //记录数据库

        //增加的价格，代理过后的价格
        return res;
    }
}

使用步骤：

（1）创建目标对象。

（2）创建InvocationHandler对象。

（3）使用Proxy类的静态方法，创建代理对象，并把返回值转为接口类型。

（4）通过代理执行方法。

package com.kwxy;

import com.kwxy.factory.UsbKingFactory;
import com.kwxy.handler.MySellHandler;
import com.kwxy.service.UsbSell;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

public class MainShop {

    public static void main(String[] args) {
        //创建代理对象，使用Proxy
        //1. 创建目标对象
        UsbSell factory = new UsbKingFactory();
        //2.创建InvocationHandler对象
        InvocationHandler handler = new MySellHandler(factory);
        //3.创建代理对象，并把返回值转为接口类型
        UsbSell proxy = 
            (UsbSell) Proxy.newProxyInstance(
            factory.getClass().getClassLoader(),
            factory.getClass().getInterfaces(),
            handler);

        //com.sun.proxy.$Proxy0 : 这是jdk动态代理创建的对象类型。
        System.out.println("proxy:"+proxy.getClass().getName());
        //4.通过代理执行方法
        float price = proxy.sell(1);
        System.out.println("通过动态代理对象，调用方法："+price);
    }
}