动态代理的分析

动态代理：

特点：字节码随用随创建，随用随加载。
作用：不修改源码的基础上，对方法增强。
分类：

基于接口的动态代理
基于子类的动态代理

基于接口的动态代理：

涉及的类：Proxy
提供者：JDK官方
如何创建代理对象：使用Proxy类中的newProxyInstance方法。
创建代理对象的要求：被代理类最少实现一个接口，如果没有则不能使用。
newProxyInstance的参数：

ClassLoader：类加载器。用于加载代理对象字节码的。和被代理对象使用相同的类加载器。（固定写法）
Class[]：字节码数组。让代理对象和被代理对象有相同方法。（固定写法）
InvocationHandler：用于提供增强的代码。它是让我们写如何代理，我们一般都是写一个该接口的实现类。通常情况下都是匿名内部类，但不是必须的。此接口的实现类都是谁用谁写。

new InvocationHandler() {
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                return null;
            }
        }

invoke方法：
作用：执行被代理对象的任何接口方法都会经过该方法。
参数：

proxy：代理对象的引用
method：当前执行的方法
args：当前执行方法所需的参数
return：和被代理对象方法有相同的返回值

示例：
Producer接口：

package com.qublog.proxy;

//对生产厂家要求的接口
public interface Producer {
    //销售
    public void saleProduct(float money);

    //售后
    public void afterService(float money);
}

ProducerImpl类：

package com.qublog.proxy;

//一个生产者
public class ProducerImpl implements Producer {

    //销售
    public void saleProduct(float money) {
        System.out.println("销售产品，并拿到钱："+money);
    }

    //售后
    public void afterService(float money) {
        System.out.println("提供售后服务，并拿到钱："+money);
    }
}

Client类：

package com.qublog.proxy;

import javax.jws.Oneway;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//模拟一个消费者
public class Client {

    public static void main(String[] args) {
        final ProducerImpl producer = new ProducerImpl();

        //动态代理
        Producer proxyProducer = (Producer) Proxy.newProxyInstance(producer.getClass().getClassLoader(),
                producer.getClass().getInterfaces(), new InvocationHandler() {
            //作用：执行被代理对象的任何接口方法都会经过该方法
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //提供增强的代码
                Object returnValue = null;
                //获取方法执行的参数
                Float money = (Float)args[0];
                //判断当前方法是不是销售
                if ("saleProduct".equals(method.getName())) {
                    returnValue = method.invoke(producer,money*0.8f);
                }
                return returnValue;
            }
        });
        proxyProducer.saleProduct(10000f);
    }

}

这里实现了代理商赚取商品价格20%的代理费，代理替工厂销售商品。

基于子类的动态代理

涉及的类：Enhancer
提供者：第三方cgLib库
如何创建代理对象：使用Enhancer类中的create方法
创建代理对象的要求：被代理类不能是最终类，最终类没法创建子类也就没法创建代理对象了。
create方法的参数：

Class：字节码。用于指定被代理对象的字节码。
Callback：用于提供增强的代码。它是让我们写如何代理，我们一般都是写一个该接口的实现类。通常情况下都是匿名内部类，但不是必须的。此接口的实现类都是谁用谁写。我们一般写的都是该接口的子接口的实现类：MethodInterceptor。

new MethodInterceptor() {
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                return null;
            }
        }

intercept方法：
作用：该方法执行被代理对象的任何方法都会经过该方法。
参数：

o、method、objects：与基于接口的动态代理中invoke方法的参数是一样的。
MethodProxy：当前执行方法的代理对象。

示例：
pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.qublog</groupId>
    <artifactId>spring03_proxy</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.1_3</version>
        </dependency>
    </dependencies>
</project>

ProducerImpl类：

package com.qublog.cglib;

//一个生产者
public class ProducerImpl{

    //销售
    public void saleProduct(float money) {
        System.out.println("销售产品，并拿到钱："+money);
    }

    //售后
    public void afterService(float money) {
        System.out.println("提供售后服务，并拿到钱："+money);
    }
}

Client类：

package com.qublog.cglib;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

//模拟一个消费者
public class Client {

    public static void main(String[] args) {
        final ProducerImpl producer = new ProducerImpl();

        ProducerImpl cglibProducer = (ProducerImpl) Enhancer.create(producer.getClass(), new MethodInterceptor() {
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                //提供增强的代码
                Object returnValue = null;
                //获取方法执行的参数
                Float money = (Float)objects[0];
                //判断当前方法是不是销售
                if ("saleProduct".equals(method.getName())) {
                    returnValue = method.invoke(producer,money*0.8f);
                }
                return returnValue;
            }
        });
        cglibProducer.saleProduct(12000f);
    }
}

quBlog

发布了59 篇原创文章 · 获赞 0 · 访问量 762

私信关注

动态代理：

基于接口的动态代理：

基于子类的动态代理

猜你喜欢