Java动态代理

动态代理(理解): 基于反射机制。
现在需要知道以下的就行:

  1. 什么是动态代理 ?

    使用jdk的反射机制,创建对象的能力, 创建的是代理类的对象。 而不用你创建类文件。不用写java文件。
    动态:在程序执行时,调用jdk提供的方法才能创建代理类的对象。

jdk动态代理,必须有接口,目标类必须实现接口, 没有接口时,需要使用cglib动态代理

  1. 知道动态代理能做什么 ?

可以在不改变原来目标方法功能的前提下, 可以在代理中增强自己的功能代码。
程序开发中的意思。
比如:你所在的项目中,有一个功能是其他人(公司的其它部门,其它小组的人)写好的,你可以使用。
GoNong.class , GoNong gn = new GoNong(), gn.print();

你发现这个功能,现在还缺点, 不能完全满足我项目的需要。 我需要在gn.print()执行后,需要自己在增加代码。
用代理实现 gn.print()调用时, 增加自己代码, 而不用去改原来的 GoNong文件

后面会有,mybatis ,spring

一、代理

1. 什么是代理?

代购, 中介,换ip,商家等等

比如有一家美国的大学, 可以对全世界招生。 留学中介(代理)

留学中介(代理): 帮助这家美国的学校招生, 中介是学校的代理, 中介是代替学校完成招生功能。
代理特点:
1. 中介和代理他们要做的事情是一致的: 招生。
2. 中介是学校代理, 学校是目标。
3. 家长---中介(学校介绍,办入学手续)----美国学校。
4. 中介是代理,不能白干活,需要收取费用。
5. 代理不让你访问到目标。

或者是买东西都是商家卖, 商家是某个商品的代理, 你个人买东西, 肯定不会让你接触到厂家的。

在开发中也会有这样的情况, 你有a类, 本来是调用c类的方法, 完成某个功能。 但是c不让a调用。

a -----不能调用 c的方法。
在a 和 c 直接 创建一个 b 代理, c让b访问。
a --访问b---访问c

2. 使用代理模式的作用

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

3. 实现代理的方式

静态代理和动态代理

二、静态代理

静态代理是指,代理类在程序运行前就已经定义好.java 源文件,其与目标类的关系在 程序运行前就已经确立。在程序运行前代理类已经编译为.class 文件。

  • 代理类是自己手工实现的,自己创建一个java类,表示代理类。

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

  • 特点: 实现简单 、容易理解

    缺点:

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

  • 当目标类增加了, 代理类可能也需要成倍的增加。 代理类数量过多。
  • 当你的接口中功能增加了, 或者修改了,会影响众多的实现类,厂家类,代理都需要修改。

1. 模拟用户购买u盘

用户是客户端类

  • 商家:代理,代理某个品牌的u盘。
  • 厂家:目标类。
  • 三者的关系: 用户(客户端)---商家(代理)---厂家(目标)
  • 商家和厂家都是卖u盘的,他们完成的功能是一致的,都是卖u盘。

实现步骤:

  1. 创建一个接口,定义卖u盘的方法, 表示你的厂家和商家做的事情
package com.md.service;

/**
 * @author MD
 * @create 2020-08-03 9:06
 */

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

    // 定义方法,返回值为u盘的价格
    float sell(int amount);
}

  1. 创建厂家类,实现1步骤的接口
package com.md.factory;

import com.md.service.UsbSell;

/**
 * @author MD
 * @create 2020-08-03 9:11
 */

// 目标类。金士顿厂家
public class UsbKingFactory implements UsbSell {
    @Override
    public float sell(int amount) {
        return 50.0f;
    }
}

  1. 创建商家,就是代理,也需要实现1步骤中的接口。
package com.md.shangjia;
import com.md.factory.UsbKingFactory;
import com.md.service.UsbSell;
import java.lang.reflect.AccessibleObject;
/**
 * @author MD
 * @create 2020-08-03 9:13
 */
// 代理类,这是商家,代理金士顿u盘销售
public class Taobao implements UsbSell {
    // 访问目标类
    // 声明商家代理的厂家是谁
    private UsbSell factory = new UsbKingFactory();
    // 实现销售u盘的功能
    @Override
    public float sell(int amount) {

        // 向厂家发送订单,告诉厂家,进行发货,这是进货价格
        float price = factory.sell(amount);

        // 商家加价获得利润,增强功能
        price+=50;
        // 在目标类的方法调用之后,剩下写的其他功能,都是增加功能
        System.out.println("淘宝商家给你一个大的优惠卷");

        return price;
    }
}

  1. 创建商家,不同的商家销售同一款产品,也是代理,也需要实现1步骤中的接口。
package com.md.shangjia;

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

/**
 * @author MD
 * @create 2020-08-03 9:32
 */

// 代理类
public class Weishang implements UsbSell {

    // 代理的也是金士顿
    private UsbSell factory = new UsbKingFactory();

    @Override
    public float sell(int amount) {
        float price = factory.sell(amount);

        // 增强功能,每个代理根据自己的模式有不同的增强功能

        price+=30;
        System.out.println("微商:亲,要五星好评哟!");

        return price;
    }
}

  1. 创建客户端类,调用商家的方法买一个u盘。
package com.md;

import com.md.shangjia.Taobao;
import com.md.shangjia.Weishang;

/**
 * @author MD
 * @create 2020-08-03 9:23
 */
public class Shopping {

    public static void main(String[] args) {
        // 创建代理的商家对象
        Taobao taobao = new Taobao();

        float price = taobao.sell(1);

        System.out.println("通过淘宝购买的u盘:"+price);


        Weishang weishang = new Weishang();
        float sell = weishang.sell(1);
        System.out.println("通过微商购买的u盘:"+sell);

    }
}

2. 静态代理的缺点

  1. 代码复杂,难于管理

    代理类和目标类实现了相同的接口,每个代理都需要实现目标类的方法,这样就出现了大量的代 码重复。如果接口增加一个方法,除了所有目标类需要实现这个方法外,所有代理类也需要实现 此方法。增加了代码维护的复杂度。

  2. 代理类依赖目标类,代理类过多

    代理类只服务于一种类型的目标类,如果要服务多个类型。势必要为每一种目标类都进行代理, 静态代理在程序规模稍大时就无法胜任了,代理类数量过多。

三、动态代理

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

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

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

使用 JDK 动态代理,和通过 CGLIB 动态代理。

四、 JDK 动态代理

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

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

从 jdk1.3 以来,java 语言通过 java.lang.reflect 包提供三个类支持代理模式 Proxy, Method 和 InvocationHandler

1. InvocationHandler接口

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

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

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

在 invoke 方法中可以截取对目标方法的调用。在这里进行功能增强

invoke()方法:

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
}
// proxy:代表生成的代理对象
// method:代表目标方法
// args:代表目标方法的参数
//第一个参数 proxy 是 jdk 在运行时赋值的,在方法中直接使用,第二个参数后面介绍, 第三个参数是方法执行的参数, 这三个参数都是 jdk 运行时赋值的,无需程序员给出。 

Java 的动态代理是 建立在反射机制之上的。 实现了 InvocationHandler 接口的类用于加强目标类的主业务逻辑。这个接口中有一个 方法 invoke(),具体加强的代码逻辑就是定义在该方法中的,通过代理对象执行接口中的方法时,会自动调用 invoke()方法,

总结:

InvocationHandler 接口:表示你的代理要干什么,怎么用:

  • 创建类实现接口InvocationHandler
  • 重写invoke()方法, 把原来静态代理中代理类要完成的功能,写在这

2. Method 类

invoke()方法的第二个参数为 Method 类对象,该类有一个方法也叫 invoke(),可以调用目标方法。这两个 invoke()方法,虽然同名,但无关。

这个类的invoke方法

public Object invoke(Object obj , Object...args){
    
}
// obj:表示目标对象
// args:表示目标方法参数,也就是上面invoke方法中的第三个参数

该方法的作用是:

  • 调用执行 obj 对象所属类的方法,这个方法由其调用者 Method 对象确定。

在代码中,一般的写法为 method.invoke(target, args); 其中,method 为上一层 invoke 方法的第二个参数。这样,即可调用了目标类的目标方法。

3. Proxy类

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

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

方法: 静态方法 newProxyInstance()
作用是: 创建代理对象, 等同于静态代理中的TaoBao taoBao = new TaoBao();

		返回值:就是代理对象
		public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)

// 1. ClassLoader loader 类加载器,负责向内存中加载对象的。 使用反射获取对象的ClassLoader类a , a.getCalss().getClassLoader(),  目标对象的类加载器
 // 2. Class<?>[] interfaces: 接口, 目标对象实现的接口,也是反射获取的。
 // 3. InvocationHandler h : 我们自己写的,代理类要完成的功能。 
					

4. 实现动态代理的步骤

和静态代理实现相同的功能

  1. 创建接口,定义目标类要完成的功能
package com.md.service;

/**
 * @author MD
 * @create 2020-08-03 10:36
 */
// 目标接口
public interface UsbSell {
    float sell(int count);
}

  1. 创建目标类实现接口
package com.md.factory;

import com.md.service.UsbSell;

/**
 * @author MD
 * @create 2020-08-03 10:37
 */

// 目标类
public class UsbKingFactory implements UsbSell {

    // 目标方法
    @Override
    public float sell(int count) {
        System.out.println("目标类:执行了目标方法");
        return 50.0f;
    }
}

  1. 创建InvocationHandler接口的实现类,在invoke方法中完成代理类的功能
package com.md.handler;

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

/**
 * @author MD
 * @create 2020-08-03 10:43
 */

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

    //
    private Object target = null;

    // 动态代理,目标对象不是固定的,需要什么就传入什么,之后通过 new MySellHandler(),就可以把目标对象传进来
    public MySellHandler(Object target) {
        this.target = target;
    }

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

        // 1. 向厂家发送订单,告诉厂家,进行发货,这是进货价格
//        float price = factory.sell(amount);


        // 2. 商家加价获得利润,增强功能
        //price+=50;
        // 3. 在目标类的方法调用之后,剩下写的其他功能,都是增加功能
       // System.out.println("淘宝商家给你一个大的优惠卷");



        // 1. 执行目标方法,和上面等价,调用目标方法,传入目标对象和相应的参数
        Object res = method.invoke(target,args);

        // 2. 增强功能
        if (res != null){
            Float price = (Float)res;
            price+=50;
            res = price;
        }

        // 3. 在目标类的方法调用之后,剩下写的其他功能,都是增加功能
        System.out.println("淘宝商家给你一个大的优惠卷");
        return res;
    }
}

  1. 使用Proxy类的静态方法,创建代理对象。 并把返回值转为接口类型
package com.md;

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

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

/**
 * @author MD
 * @create 2020-08-03 10:55
 */
public class Shopping {

    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);

        // 4.  通过代理执行方法
        float price = proxy.sell(1);
        System.out.println("通过动态代理调用方法:"+price);
    }
}

五、cgLib 代理

CGLIB(Code Generation Library)是一个开源项目。是一个强大的,高性能,高质量的 Code 生成类 库,它可以在运行期扩展 Java 类与实现 Java 接口。它广泛的被许多 AOP 的框架使用,例如 Spring AOP。

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

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

CGLIB 代理的生成 原理是生成目标类的子类,而子类是增强过的,这个子类对象就是代理对象。所以,使用 CGLIB 生成动态代理,要求目标类必须能够被继承,即不能是 final 的类。

cglib 经常被应用在框架中,例如 Spring ,Hibernate 等。Cglib 的代理效率高于 Jdk。对 于 cglib 一般的开发中并不使用。做了一个了解就可以。

六、练习

  1. 定义接口
package com.md.service;

/**
 * @author MD
 * @create 2020-08-03 20:51
 */
public interface Dog {
    void info();

    void run();
}

  1. 接口的具体实现类
package com.md.factory;

import com.md.service.Dog;

/**
 * @author MD
 * @create 2020-08-03 20:51
 */
public class GunDog implements Dog {
    @Override
    public void info() {
        System.out.println("我是狗");
    }

    @Override
    public void run() {
        System.out.println("狗在跑");
    }
}

  1. 增加方法
package com.md.Util;

/**
 * @author MD
 * @create 2020-08-03 20:53
 */
public class DogUtil {

    public void method1(){
        System.out.println("我是第一个增强方法");
    }

    public void method2(){
        System.out.println("我是第二个增强方法");
    }

}

  1. 实现 InnovationHandler 接口

    动态代理的核心环节就是要实现 InvocaitonHandler 接口。每个动态代理类都必须要实现 InvocationHandler 接口,并且每个代理类的实例都关联到了一个 InvocationHandler 接口实现类的实例对象,当我们通过代理对象调用一个方法的时候,这个方法的调用就会被转发为由 InvocationHandler 这个接口的 invoke() 方法来进行调用,具体的实现如下:

package com.md.handler;

import com.md.Util.DogUtil;

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

/**
 * @author MD
 * @create 2020-08-03 20:55
 */
public class MyHandler implements InvocationHandler {


    private Object target;
	// 需要被代理的对象
    public void setTarget(Object target) {
        this.target = target;
    }

    // 当我们调用被代理对象的方法时,invvoke方法会取而代之
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        DogUtil dogUtil = new DogUtil();

		// 增强方法
        dogUtil.method1();

        // 用反射调用Dog class中的方法
        Object res = method.invoke(target, args);

        dogUtil.method2();

        return res;
    }
}

  1. 使用Proxy类的静态方法,创建代理对象。 并把返回值转为接口类型
package com.md;

import com.md.factory.GunDog;
import com.md.handler.MyHandler;
import com.md.service.Dog;

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

/**
 * @author MD
 * @create 2020-08-03 21:14
 */
public class DogTest {

    public static void main(String[] args) {

        // 实例化被代理对象
        Dog dog = new GunDog();

        // 实例化MyHandler对象,
        MyHandler myHandler = new MyHandler();
        myHandler.setTarget(dog);


        // 用被代理对象产生一个代理对象
        Dog proxy = (Dog) Proxy.newProxyInstance(dog.getClass().getClassLoader(), dog.getClass().getInterfaces(), myHandler);

        // 代理对象调用被代理对象的方法
        proxy.info();
        System.out.println("-------------------");
        proxy.run();


    }
}
// 运行结果
/*
我是第一个增强方法
我是狗
我是第二个增强方法
-------------------
我是第一个增强方法
狗在跑
我是第二个增强方法
*/

还是需要注意newProxyInstance() ,要把返回值转为接口类型,以及注意参数

  • 参数一:类加载器对象即用哪个类加载器来加载这个代理类到 JVM 的方法区
  • 参数二:接口表明该代理类需要实现的接口
  • 参数三:是调用处理器类实例即 InvocationHandler 的实现的实例对象

这个函数是 JDK 为了程序员方便创建代理对象而封装的一个函数,因此你调用newProxyInstance()时直接创建了代理对象
注意:上面的情况是两个方法都增加了功能,若只想在run()里添加增加功能该怎么办?

使用method.getName()获取方法名

package com.md.handler;

import com.md.Util.DogUtil;

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

/**
 * @author MD
 * @create 2020-08-03 20:55
 */
public class MyHandler implements InvocationHandler {


    private Object target;
	// 需要被代理的对象
    public void setTarget(Object target) {
        this.target = target;
    }

    // 当我们调用被代理对象的方法时,invvoke方法会取而代之
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        DogUtil dogUtil = new DogUtil();
        Object res = null;
         
        // 获取当前调用方法的名字,给指定的方法添加新的功能
        String methodName = method.getName();
        if("run".equals(methodName)){
            dogUtil.method1();
            res = method.invoke(target, args);
            dogUtil.method2();
        }else{
            res = method.invoke(target, args);
        }
        return res;
    }
}

这样就可以给指定的方法添加新功能

posted @ 2020-08-03 22:00  山丘i  阅读(276)  评论(0编辑  收藏