基于Spring的静态代理与动态代理的区别_spring动态代理和静态代理的区别-CSDN博客

本文链接：https://blog.csdn.net/H_hello_world/article/details/120594222

代理模式为其他对象提供一种代理以控制对这个对象的访问.（或者说是在两个目标对象之间，添加一个中间对象（这个对象叫做代理对象，其作用为实现行为、增强目标对象的行为））

静态代理

静态代理的特点:

1、目标角色固定
2、在应用程序执行前就得到目标角色
3、代理对象会增强目标对象的行为
4、有可能存在多个代理引起"类爆炸"（缺点）

静态代理的三要素：

代理角色与真实角色实现相同的接口
代理角色持有真实角色的引用
代理行为

结婚案例

Marry 结婚行为

package com.yjxxt.staticproxy;

public interface Marry {
    public void toMarry();
}

真实角色 (目标对象)

package com.yjxxt.staticproxy;

public class You implements Marry{
    @Override
    public void toMarry() {
        System.out.println("我今天结婚了...");
    }
}

代理角色

package com.yjxxt.staticproxy;

public class MarryCompanyProxy implements Marry{
    //目标对象，代理角色拥有目标对象的引用
    private Marry marry;
    // 通过构造器将目标对象传入
    public MarryCompanyProxy(Marry marry) {
        this.marry = marry;
    }
    //代理角色实现行为
    @Override
    public void toMarry() {
        //前置操作
        before();
        //调用真实角色（目标对象中的方法）
        marry.toMarry();
        //后置操作
        after();
    }
    public void before(){
        System.out.println("邀请亲朋好友。。。");

    }
    public void after(){
        System.out.println("扎气球.....");
    }
}

Test类

package com.yjxxt.staticproxy;

public class Test {
    public static void main(String[] args) {
        //目标对象（真实角色）
        You you = new You();
        //代理角色
        MarryCompanyProxy mc = new MarryCompanyProxy(you);
        //通过代理角色调用目标对象的方法
        mc.toMarry();
    }
}

动态代理

相比于静态代理，动态代理在创建代理对象上更加的灵活，动态代理类的字节码在程序运行时，由Java反射机制动态产生。它会根据需要，通过反射机制在程序运行期，动态的为目标对象创建代理对象，无需程序员手动编写它的源代码。动态代理不仅简化了编程工作，而且提高了软件系统的可扩展性，因为反射机制可以生成任意类型的动态代理类。代理的行为可以代理多个方法，即满足生产需要的同时又达到代码通用的目的。

动态代理的特点:

目标对象不固定
在应用程序执行时动态创建目标对象
代理对象会增强目标对象的行为

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

JDK 动态代理
CGLIB动态代理

JDK动态代理

注：JDK动态代理的目标对象必须有接口实现，如果有些类并没有接口实现，则不能使用JDK代理。

Marry 结婚行为

package com.yjxxt.staticproxy;

public interface Marry {
    public void toMarry();
}

真实角色 (目标对象)

package com.yjxxt.staticproxy;

public class You implements Marry{
    @Override
    public void toMarry() {
        System.out.println("我今天结婚了...");
    }
}

动态代理角色

package com.yjxxt.dynamicProxy;

import com.yjxxt.staticproxy.Marry;

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

public class JdkHandler implements InvocationHandler {

    //目标对象
    //目标对象的类型不固定，创建时生成
    private Object target;

    //通过构造器给目标对象赋值
    public JdkHandler(Marry target) {
        this.target = target;
    }
    /**
     * 1、调用目标对象的方法（返回Object）
     * 2、增强目标对象的行为
     * @param proxy 调用该方法的代理实例
     * @param method 目标对象的方法
     * @param args 目标对象的方法形参
     * @return
     * @throws Throwable
     */

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //前置操作
        before();

        //调用真实角色（目标对象中的方法）
        Object result = method.invoke(target, args);

        //后置操作
        after();
        //返回创建的代理对象
        return result;
    }
    //前置操作
    public void before(){
        System.out.println("邀请亲朋好友。。。");
    }
    //后置操作
    public void after(){
        System.out.println("扎气球.....");
    }
	//动态获取代理角色
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }
}

CGLIB 动态代理

JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能使用JDK的动态代理，cglib是针对类来实现代理的，它的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。

添加依赖

在pom.xml文件中引入cglib的相关依赖

<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2.2</version>
</dependency>

Marry 结婚行为

package com.yjxxt.staticproxy;

public interface Marry {
    public void toMarry();
}

真实角色 (目标对象)

package com.yjxxt.staticproxy;

public class You implements Marry{
    @Override
    public void toMarry() {
        System.out.println("我今天结婚了...");
    }
}

CGLIB 动态代理角色

package com.yjxxt.cglibproxy;


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 CglibInterceptor implements MethodInterceptor {

    //目标对象
    private Object target;

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

    /**
     * 拦截器
     * 1、目标对象的方法调用
     * 2、增强行为
     * @param o 由CGLib动态生成的代理类实例
     * @param method 实体类所调用的被代理的方法引用
     * @param objects 参数值列表
     * @param methodProxy 生成的代理类对方法的代理引用
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        // 前置增强行为
        System.out.println("==============前置");

        Object result = methodProxy.invoke(target, objects);

        // 后置增强行为
        System.out.println("==============后置");

        return result;
    }

    动态获取代理角色
    public Object getProxy(){
        // 通过Enhancer对象的create()方法可以生成一个类，用于生成代理对象
        Enhancer enhancer = new Enhancer();
        //设置父类，将目标类设置为父类
        enhancer.setSuperclass(target.getClass());
        //设置拦截器 回调对象为对象本身
        enhancer.setCallback(this);
        //生成一个代理类，并返回
        return enhancer.create();
    }
}