1 代理

•  生活中的代理：比如我们生活中比较熟悉的代购、中介、商家等都是属于代理

2 什么是代理模式

代理模式是指：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户类和目标对象之间起到中介的作用。

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

客户类真正想要访问的对象是目标对象，但客户类真正可以访问的对象是代理对象。客户类对目标对象的访问是通过访问代理对象来实现的。当然，代理类与目标类要实现同一个接口。

比如：

有A、B、C三个类，A原来可以调用C类的方法，现在因为某种原因C类不允许A类调用其方法，但B类可以调用C类的方法。A类通过B类调用C类的方法。这里B是C的代理。

A通过代理B访问C ，这种模式就是代理模式。

• 原来的访问关系：

• 通过代理的访问关系：

3 代理模式的作用

1. 功能增强: 在原有的功能上，增加了额外的功能，新增加的功能，叫做功能增强，
2. 控制访问：代理类不让你访问目标，例如商家不让用户访问厂家

4 实现代理的方式

4.1 静态代理

4.1.1 什么是静态代理？

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

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

4.1.2 静态代理的特点：

（1）实现简单

（2）容易理解

4.1.3 静态代理的缺点：

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

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

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

4.1.4 静态代理举例：

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

        用户：客户端类

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

        厂家：目标类

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

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

• 实现步骤：

（1）创建一个接口，定义卖U盘的方法，表示你的厂家和商家做的事情。

（2）创建厂家类，实现（1）步骤的接口

（3）创建商家，就是代理，也需要实现（1）步骤中的接口

（4）创建客户端类，调用商家的方法买一个U盘

• 代理类完成的功能：

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

（2）功能增强

• Java代码实现如下：

（1）创建一个接口，定义卖U盘的方法，表示你的厂家和商家做的事情。

package com.powernode.service;

/**
 * 表示功能的，厂家，商家都要完成的功能
 * 备注：下面只是定义了一个卖U盘的功能，也可以写其它的功能
 */
public interface UsbSell {

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

（2）创建厂家类，实现（1）步骤的接口

package com.powernode.factory;

import com.powernode.service.UsbSell;

//目标类：金士顿厂家.不接受用户的单独购买
public class UsbKingFactory implements UsbSell {
    @Override
    public float sell(int amout) {
        //一个128G的U盘是85元
        return 85.0f;
    }
}

（3）创建商家，就是代理，也需要实现（1）步骤中的接口

package com.powernode.shangjia;

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

/**
 * 淘宝是一个商家，代理金士顿厂家U盘的销售
 */
public class TaoBao implements UsbSell {
    private UsbKingFactory factory = new UsbKingFactory();

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

        //向厂家发送订单，告诉厂家，我买了U盘，厂家发货
        float price = factory.sell(amout);//厂家的价格

        //商家需要加价，也就是代理需要增加价格
        //增强功能，代理类在完成目标类方法调用后，增强的功能。在目标类的方法调用后，你做的其它功能，都是增强的意思。
        price = price + 25;
        //返回增加的价格
        return price;
    }
}

（4）创建客户端类，调用商家的方法买一个U盘

package com.powernode;

import com.powernode.shangjia.TaoBao;

public class ShopMain {

    public static void main(String[] args) {

        TaoBao taoBao = new TaoBao();
        float price = taoBao.sell(1);
        System.out.println("通过淘宝的商家，购买得u盘单价" + price);
    }
}

4.2 动态代理

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

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

1）代理类数量可以很少

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

4.2.1 什么是动态代理

说起动态代理，就先说下什么是动态：

动态指的是在程序执行时，调用jdk提供的方法才能创建代理类的对象。

动态代理是：

在程序执行过程中，使用jdk的反射机制，创建代理类对象，并动态的指定要代理目标类（静态代理中，代理目标是固定，写死的）。而不用你创建类文件，不用写Java文件。

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

换句话说，动态代理是一种创建Java对象的能力，让你不用创建TaoBao类，就能创建代理类对象。一般创建对象是 new Xx()，那现在动态代理也可以做这个事情。

动态代理的实现方式常用的有两种：

1、JDK动态代理

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

1）反射，Method类，表示方法。类中的方法，通过Method可以执行某个方法。

2）jdk动态代理的实现

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

（1）InvocationHandler 接口（中文意思：调用处理器）：就是一个方法 invoke（）

invoke（）:表示代理对象要执行的功能代码，你的代理类要完成的功能就卸载invoke（）方法中。

        代理类完成的功能：

                1、调用目标方法，执行目标方法的功能

                2、功能增强，在目标方法调用时，增加功能。

invoke（）方法原型：

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

入参介绍：

• Object proxy：jdk创建的代理对象，无需赋值
• Method method: 目标类中的方法，jdk提供method对象的
• object[] args: 目标类中方法的参数

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

怎么使用：

        1）创建类实现接口InvocationHandler

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

（2）Method类：目标类中的方法。

作用：通过Method可以执行某个目标类的方法，Method.invoke（）；

        Method.invoke(目标对象， 方法的参数)

说明：Method.invoke（）就是用来执行目标方法的，等同于上面在静态代理中的

     float price = factory.sell(amout);//厂家的价格

（3）Proxy类：核心的对象，创建代理对象，之前创建对象都是new 类的构造方法（）现在我们使用Proxy类的方法，代理new的使用。

方法： 静态方法：newProxyInstance（）

作用：创建代理对象，等同于我上述静态代理举例中的new TaoBao（）= new TaoBao（）

方法原型：

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

入参介绍：

• ClassLoader loader ：类加载器，负责向内存中加载对象的，使用反射获取对象的classLoader。 例如： 类A： A.getClass.getClassLoader(), 主要是为了获取目标对象的类加载器。
• Class<?>[] interfaces：接口，目标对象实现的接口，也是反射获取的。
• InvocationHandler h：是我们自己写的，代理类要完成的功能。

出参介绍：

Object：就是目标对象的代理对象

4.2.2 动态代理举例

• 实现动态代理的步骤：

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

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

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

        1）调用目标方法

        2）增强功能

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

• Java代码实现如下

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

package com.powernode.service;

/**
 * 表示功能的，厂家，商家都要完成的功能
 * 备注：下面只是定义了一个卖U盘的功能，也可以写其它的功能
 */
public interface UsbSell {

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

}

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

package com.powernode.factory;

import com.powernode.service.UsbSell;

//目标类：金士顿厂家.不接受用户的单独购买
public class UsbKingFactory implements UsbSell {
    @Override
    public float sell(int amout) {
        //一个128G的U盘是85元
        return 85.0f;
    }
}

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

package com.powernode.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 {
       // float price = factory.sell(amout);//厂家的价格

        //商家需要加价，也就是代理需要增加价格
        //增强功能，代理类在完成目标类方法调用后，增强的功能。在目标类的方法调用后，你做的其它功能，都是增强的意思。
        //price = price + 25;
        //返回增加的价格

        //(1)执行目标方法
        Object res = null;
        method.invoke(target, args);//执行目标方法，target你传入的是A，那你的目标方法就是A，你传入的是B，那目标方法就是B
        //(2)进行功能增强
        if (res != null) {
            Float price = (Float) res;
            price = price+25;
            res = price;
        }
        return res;
    }
}

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

package com.powernode;

import com.powernode.factory.UsbKingFactory;
import com.powernode.handler.MysellHandler;
import com.powernode.service.UsbSell;
import com.powernode.shangjia.TaoBao;

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

public class ShopMain {

    public static void main(String[] args) {
        //创建代理对象，使用Proxy
        // 1、创建目标对象
       // UsbKingFactory factory = new UsbKingFactory();
        UsbSell factory = new UsbKingFactory();

        //2、创建InvocationHandler对象
        InvocationHandler handler = new MysellHandler(factory);

        //3、创建代理对象
        UsbSell proxy = (UsbSell) Proxy.newProxyInstance(factory.getClass().getClassLoader(),
                factory.getClass().getInterfaces(),
                handler);

        //4、通过代理执行方法
        float price = proxy.sell(1);
        System.out.println(price);

    }
}

2、通过CGLIB动态代理

cglib是第三方的工具库，创建代理对象。它可以在运行期间扩展Java类与实现Java接口，它广泛的被许多AOP的框架使用，例如Spring AOP。

使用JDK的Proxy实现代理，要求目标类和代理类实现相同的接口。若目标类不存在接口，则无法使用该方式实现。

但对于无接口的类，要为其创建动态代理，就要通过cglib来实现。cglib代理的生成原理是生成目标类的子类，而子类是通过增强过的，这个子类对象就是代理对象，所以，使用cglib生成动态代理，要求目标类必须能够被继承，即不能是final的类。

cglib在很多的框架中使用。比如mybatis，spring框架中都有使用。

在Java中，要想创建对象：

（1）创建类文件，Java文件编译为class

（2）使用构造方法，创建类的对象

然而，动态代理是不用做上面的步骤（1），只需要经过步骤（2）就可以把对象创建出来

代理是一个抽象的概念，简单理解就可以理解为在一个java类上去给它增加一些新的功能，但是却不用动原来的代码，在Java中分为静态代理和动态代理，然而动态代理又分为 jdk 动态代理和 cglib 动态代理，详情如下：

1、静态代理

方法：静态代理相当于是多写了一个代理类，在调用的时候调用的是代理类，在代理类中的处理还是原生的处理逻辑，不过在前后添加上需要添加的代码。
缺点：需要为每一个被代理的对象都创建一个代理类。
下面以购物举一个例子：

---

1、我们现在需要写一个接口去定义购物类的方法：

// 接口
public interface IShopping {
    public void doShopping();
}

---

2、定义一个购物的实现类

public class Shopping implements IShopping {

    private String name;

    public Shopping(String name){
        this.name = name;
    }

    @Override
    public void doShopping() {
        System.out.println(name + "买了火腿肠一个。");
        System.out.println(name + "买了啤酒一罐。");
        System.out.println(name + "买了剪刀一把。");
    }

}

---

3、测试类直接运行
这里我们可以看出执行了实现类的代码

public class MainTest {

    @Test
    public void test01(){
        IShopping shopping = new Shopping("小乐乐");
        shopping.doShopping();
    }
}

---

4、现在又有了新的需求，需要我们打印出，某人进入超市购物和离开超市的时间
由于现在我们用的是静态代理，所以我们需要写一个代理类，来包装之前的购物实现类，如下所示：
在这个类中我们可以发现，我们真正的执行逻辑还是之前的购物逻辑，不过在购物逻辑的前后添加了一写=些日志打印

public class ShoppingProxy implements IShopping {

    private String name;
    private Shopping shopping;

    public ShoppingProxy(String name){
        this.name = name;
        this.shopping = new Shopping(name);
    }

    @Override
    public void doShopping() {
        System.out.println(name + "在" + currentTime() + "到达了超市。");
        shopping.doShopping();
        System.out.println(name+"到达了超市。");
        System.out.println(name + "在" + currentTime() + "从超市出去。");
    }

    private String currentTime(){
        //设置日期格式
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        // new Date()为获取当前系统时间
        return df.format(new Date());
    }

}

---

5、测试类打印
没有动之前的逻辑，我们就实现了功能需求，但是缺点就是对于每一个需要代理的类我们都需要写一个新的代理类，太繁琐。

public class MainTest {

    @Test
    public void test01(){
        IShopping shopping = new ShoppingProxy("小乐乐");
        shopping.doShopping();
    }
}

2、动态代理

2.1、jdk动态代理

Proxy.newProxyInstance(classLoader,interfaces,invocationHandler);
通过它创建动态的代理类，我们只需将别的类去调用我们实现的公共方法，就可以。
缺点：必须要实现接口。

---

1、首先我们先写一个接口，如下代码所示：

public interface ICalculator {

    public Integer add(Integer i,Integer j);

    public Integer sub(Integer i,Integer j);

    public Integer mul(Integer i,Integer j);

    public Integer div(Integer i,Integer j);
}

---

2、我们写一个需要被代理的类，这个被代理的类必须要实现上面的接口（因为jdk的动态代理是必须要实现接口的），如下所示：

public class Calculator implements ICalculator {
    @Override
    public Integer add(Integer i, Integer j) {
        Integer result = i + j;
        return result;
    }

    @Override
    public Integer sub(Integer i, Integer j) {
        Integer result = i - j;
        return result;
    }

    @Override
    public Integer mul(Integer i, Integer j) {
        Integer result = i * j;
        return result;
    }

    @Override
    public Integer div(Integer i, Integer j) {
        Integer result = i / j;
        return result;
    }
}

---

3、我们需要写一个代理打印日志的公共方法，这个公共方法将会给被代理的类弄一些屏障类似的东西，在执行真正的方法前后打印一些日志等等，可联系是spring中的aop进行理解，概念大致相似，代码如下所示：

public class MyInvocationHandler implements InvocationHandler {

    private Object target;

    private String prefix = "代理类打印：";

    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String classAndMethod = prefix + "方法名：" + method.getName();
        System.out.println(classAndMethod + "，开始执行：");
        if(args == null || args.length == 0){
            System.out.println(prefix + "没有参数");
        }else{
            System.out.println(prefix + "参数为：" + Arrays.asList(args));
        }
        /**
         * 执行被代理的方法
         * 参数
         * Object obj       被代理的对象
         * Object... args   被代理的方法参数，直接将args传进去
         */
        Object result = method.invoke(target,args);
        System.out.println(prefix + "返回值为：" + result);
        System.out.println(classAndMethod + "，执行结束。");
        return result;
    }
}

---

4、接下来，我们就需要写我们真正的需要被代理的创建 jdk 动态代理的公共方法，然后需要打印日志的处理类指向第三步的方法即可，代码如下所示：

public class CommonProxy {
    /**
     * 公共jdk动态代理生成方法
     * Proxy.newProxyInstance(classLoader,interfaces,invocationHandler);
     * 上面这行代码就是创建一个 jdk 动态代理，我们现在只需要知道传入这三个参数即可
     * 由于这里我们可以很明显的看见，参数需要一个接口
     * 所以说， jdk 动态代理要求被代理的类得实现一个接口
     * @param object
     */
    public static Object createProxy(Object object){
        /**
         * ClassLoader loader       类加载器，通常指定的被代理类的接口的类加载器
         * Class<?>[] interfaces    类型，通常用来被指定被代理类的接口的类型
         * InvocationHandler h      委托执行的处理类：日志功能
         */
        ClassLoader classLoader = object.getClass().getClassLoader();
        Class<?>[] interfaces = object.getClass().getInterfaces();
        InvocationHandler invocationHandler = new MyInvocationHandler(object);
        // 动态创建代理类
        Object o = Proxy.newProxyInstance(classLoader,interfaces,invocationHandler);
        return o;
    }
}

---

5、最后我们来写一个测试类，去动态给我们最开始定义的 Calculator 动态生成一个代理类，代码和运行截图如下所示：

public class MainTest {
    @Test
    public void test(){
        ICalculator o = (ICalculator)CommonProxy.createProxy(new Calculator());
        o.add(1,1);
    }
}

2.2、cglib动态代理

对于cglib的动态代理，创建代理类的时候不需要传入接口参数，所以它不需要强制实现接口。
而是为被代理的对象创建一个子类，jdk 动态代理中的有些代码我们可以用到，这里面只需要改一下动态代理的公共方法和测试类即可。

---

1、创建动态代理公共方法并实现打印日志功能：

public class CglibCommonProxy implements MethodInterceptor {
    /**
     * 需要代理的目标对象
     */
    private Object target;

    public Object createProxy(Object objectTarget){
        // 将传入进来的目标对象赋值给全局变量，在后续调用拦截方法时会用到
        target = objectTarget;
        // enhancer 字面意思，增强剂，也就是给被代理类搞一个屏障
        Enhancer enhancer = new Enhancer();
        //设置父类,因为Cglib是针对指定的类生成一个子类，所以需要指定父类
        enhancer.setSuperclass(objectTarget.getClass());
        // 设置回调
        enhancer.setCallback(this);
        // 搞好这个代理类并返回
        Object result = enhancer.create();
        return result;
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("Cglib动态代理，监听开始！");
        //方法执行，参数：target 目标对象 objects 参数数组
        Object invoke = method.invoke(target, objects);
        System.out.println("Cglib动态代理，监听结束！");
        return invoke;
    }
}

---

2、测试类，测试类代码以及运行截图：

@Test
public void cglibTest(){
    CglibCommonProxy cglibCommonProxy = new CglibCommonProxy();
    ICalculator o = (ICalculator)cglibCommonProxy.createProxy(new Calculator());
    o.add(1,1);
}

1、什么是静态代理？

两个对象之间的操作不直接进行，通过第三方进行代理来实现。就比如说房客租房子这件事情，租房的两个对象是房客和房东，静态代理便是，在房客和房东之间多了一个角色，这便是中介，代理便是中介，现在租房这件事情便是房客和中介，以及中介和房东之间的事情，房客不直接和房东进行租房的操作。

2、为什么要使用静态代理？

回到刚才租房的例子，如果不使用静态代理，后面房客的需求增加了，房东的功能也随之增加，在原有代码的基础上进行代码的改动，可能会导致代码出现问题。

现在如果要对每个方法执行前输出一句话“今天天气真不错”，就需要对每个方法都进行更改，这样可能导致代码出现问题

使用静态代理模式便可以很好解决这个问题

只需要代理类在执行执行方法时进行相应的更改，这样便不会更改源代码，实现同样的需求

3、静态代理如何使用？

静态代理的使用首先要定义代理类实现相应的接口

通过代理类来调用相应的方法，可以实现同样的功能，并且不修改原有代码。

这便是静态代理，静态代理很好的实现了在不修改原有代码的基础上进行业务拓展的功能，这也是它主要的功能。

但是静态代理是代理类在创建的时候，接口以及代理类就已经确定了，因此一个静态代理类只能代理一个类，造成代码的冗余 。

---