011代理模式

呢喃coding

已于 2023-03-24 14:27:04 修改

阅读量241

点赞数

分类专栏：设计模式文章标签：代理模式 java 设计模式

于 2023-03-24 14:26:28 首次发布

本文链接：https://blog.csdn.net/qq_25385555/article/details/129750148

版权

设计模式专栏收录该内容

10 篇文章 0 订阅

订阅专栏

代理模式允许在不修改原始类的情况下，通过代理类添加功能。静态代理需手动创建代理类，缺点是当有多个类需要代理时，会产生大量代理类。动态代理分为JDK和CGLIB，JDK基于接口，CGLIB基于继承。SpringAOP利用代理模式实现面向切面编程，支持事务管理和延迟加载等功能。

摘要由CSDN通过智能技术生成

代理模式的原理与实现

在不改变原始类（或叫被代理类）的情况下，通过引入代理类来给原始类附加功能。一般情况下，我们让代理类和原始类实现同样的接口。但是，如果原始类并没有定义接口，并且原始类代码并不是我们开发维护的。在这种情况下，我们可以通过让代理类继承原始类的方法来实现代理模式。

静态代理

public interface Person {
    void request();
}


public class RealPerson implements Person {
    @Override
    public void request() {
        System.out.println("我是原始类");
    }
}


public class ProxyPerson implements Person {

    private Person realPerson;

    public ProxyPerson(Person subject) {
        this.realPerson = subject;
    }

    @Override
    public void request() {
        System.out.println("我是代理类,start");
        realPerson.request();
        System.out.println("我是代理类,end");
    }
}


public class ProxyTest {
    public static void main(String[] args) {
        Person realPerson = new RealPerson();
        ProxyPerson proxy = new ProxyPerson(realPerson);
        proxy.request();
    }
}


我是代理类,start
我是原始类
我是代理类,end

优点

在不改变目标对象的前提下扩展目标对象的功能，类似于我们代码开发中，如果需要引入类库，可以继承他们，扩展他们的功能，或者类库也会给我们一下接口，方便我们扩展功能

缺点：

如果需要代理多个类，每个类都会有一个代理类，会导致代理类无限制扩展；如果类中有多个方法，同样的代理逻辑需要反复实现、应用到每个方法上，一旦接口增加方法，目标对象与代理对象都要进行修改
所以静态代理不怎么常用

动态代理

代理类在程序运行时创建的代理方式被成为动态代理。也就是说，这种情况下，代理类并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指示”动态生成的

jdk动态代理

创建JDK动态代理需要先实现InvocationHandler接口，并重写其中的invoke方法，具体步骤如下：

创建一个类实现InvocationHandler接口。
给Proxy类提供委托类的ClassLoader和Interfaces来创建动态代理类。
利用反射机制得到动态代理类的构造函数。
利用动态代理类的构造函数创建动态代理类对象。

public interface Person {
    void request();
}


public class RealPerson implements Person {
    @Override
    public void request() {
        System.out.println("我是原始类");
    }
}


public class DynamicPerson implements InvocationHandler {

    //代理目标类
    private Object target;

    //通过构造函数，传递目标类，
    public DynamicPerson(Object person) {
        this.target = person;
    }

    /**
     * 实现代理方法，这里面写扩展点
     被代理的对象，被代理对象的某个方法，被代理对象接受的的参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("我是动态代理类,start");
        Object invoke = method.invoke(target, args);
        System.out.println("我是动态代理类,end");
        return null;
    }
}


public class DynamicProxyTest {

    public static void main(String[] args) {
        RealPerson realPerson = new RealPerson();
        InvocationHandler handler = new DynamicPerson(realPerson);
        Person proxyInstance = (Person) Proxy.newProxyInstance(
                realPerson.getClass().getClassLoader(),
                realPerson.getClass().getInterfaces(),
                handler);

        proxyInstance.request();

    }

}



我是动态代理类,start
我是原始类
我是动态代理类,end

生成的代码

RealPerson realPerson = new RealPerson();
DynamicPerson dynamicPerson = new DynamicPerson();
Person proxyInstance = (Person) dynamicPerson.getInstance(realPerson);
Class<?> proxyClass = proxyInstance.getClass();
byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{Person.class});
String className = proxyClass.getName();
className = className.substring(className.lastIndexOf(".") + 1);
String classContent = new String(bytes);
System.out.println(className + " class content: \n" + classContent);




$Proxy0 class content: 
class $Proxy0 implements Person {
    private InvocationHandler h;
    public $Proxy0(InvocationHandler var1) {
        this.h = var1;
    }
    public final void request() {
        try {
            this.h.invoke(this, m1, (Object[])null);
        } catch (Error | RuntimeException var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
}

cglib动态代理

首先需要引入 CGLIB 的依赖：

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.2.5</version>
    </dependency>

然后，我们需要修改一下原始类和代理类：

public class RealPerson {

    public void request() {
        System.out.println("我是原始类");
    }
}

public class DynamicPerson implements MethodInterceptor {

    // 代理目标类
    private Object target;

    public Object getInstance(Object target) {
        this.target = target;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }

    /**
* 实现代理方法，这里面写扩展点
* 被代理的对象，被代理对象的某个方法，被代理对象接受的的参数
*/
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("我是动态代理类,start");
        Object result = proxy.invoke(target, args);
        System.out.println("我是动态代理类,end");
        return result;
    }
}

然后，在测试类中创建原始类和代理类的实例，并测试代理类的方法：

public class DynamicProxyTest {

    public static void main(String[] args) {
        RealPerson realPerson = new RealPerson();
        DynamicPerson dynamicPerson = new DynamicPerson();
        RealPerson proxyInstance = (RealPerson) dynamicPerson.getInstance(realPerson);
        proxyInstance.request();
    }
}

生成的代码

RealPerson$$EnhancerByCGLIB$$ea0c4a7b class content: 
public class RealPerson$$EnhancerByCGLIB$$ea0c4a7b extends RealPerson implements Factory{
    private boolean CGLIB$BOUND;
    public static Object CGLIB$FACTORY_DATA;
    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final Callback[] CGLIB$STATIC_CALLBACKS;
    private static final Method CGLIB$request$0$Method;
    private static final MethodProxy CGLIB$request$0$Proxy;
    private static final Object[] CGLIB$emptyArgs;
    private MethodInterceptor CGLIB$CALLBACK_0;

    public final void request(){
        MethodInterceptor tmp = this.CGLIB$CALLBACK_0;
        if (tmp == null){
            CGLIB$BIND_CALLBACKS(this);
            tmp = this.CGLIB$CALLBACK_0;
        }
        if (tmp != null){
            tmp.intercept(this,CGLIB$request$0$Method,CGLIB$emptyArgs,CGLIB$request$0$Proxy);
        } else {
            super.request();
        }
    }

    public Object newInstance(Callback[] arrcallback){
        CGLIB$SET_THREAD_CALLBACKS(arrcallback);
        RealPerson$$EnhancerByCGLIB$$ea0c4a7b realPerson$$EnhancerByCGLIB$$ea0c4a7b = new RealPerson$$EnhancerByCGLIB$$ea0c4a7b();
        CGLIB$SET_THREAD_CALLBACKS(null);
        return realPerson$$EnhancerByCGLIB$$ea0c4a7b;
    }

    public Object newInstance(Callback callback){
        CGLIB$SET_THREAD_CALLBACKS(callback);
        RealPerson$$EnhancerByCGLIB$$ea0c4a7b realPerson$$EnhancerByCGLIB$$ea0c4a7b = new RealPerson$$EnhancerByCGLIB$$ea0c4a7b();
        CGLIB$SET_THREAD_CALLBACKS(null);
        return realPerson$$EnhancerByCGLIB$$ea0c4a7b;
    }

    public RealPerson$$EnhancerByCGLIB$$ea0c4a7b(){
        RealPerson$$EnhancerByCGLIB$$ea0c4a7b realPerson$$EnhancerByCGLIB$$ea0c4a7b = this;
        CGLIB$BIND_CALLBACKS(realPerson$$EnhancerByCGLIB$$ea0c4a7b);
    }

    static{
        CGLIB$STATICHOOK1();
    }
}

区别

JDK 动态代理是基于接口来实现的，它要求被代理的目标类必须实现接口，代理类实现了与目标类相同的接口，代理类的方法里面调用了目标类的方法。这种方式要求目标类必须实现接口，因为代理类需要实现与目标类相同的接口，如果目标类没有实现接口，那么就无法使用 JDK 动态代理。

CGLIB 代理则不需要目标类实现接口，它通过生成目标类的子类来实现代理。代理类继承了目标类，同时也包含了目标类的所有方法，代理类重写了目标类的方法，在重写的方法中加入了自己的扩展逻辑。因为 CGLIB 代理是通过继承来实现的，所以目标类必须是可继承的类，不能是 final 类。

因此，JDK 动态代理和 CGLIB 代理的实现方式是不同的，前者是基于接口，后者是基于继承。

应用场景

代理模式常用在业务系统中开发一些非功能性需求，比如：监控、统计、鉴权、限流、事务、幂等、日志。我们将这些附加功能与业务功能解耦，放到代理类统一处理，让程序员只需要关注业务方面的开发。除此之外，代理模式还可以用在 RPC、缓存等应用场景中。

Spring AOP

主要体现在AOP（面向切面编程）上。在使用Spring AOP时，我们可以通过声明切面（Aspect）和切点（Pointcut）来将一些横切关注点（cross-cutting concern）切入到应用程序的流程中。具体来说，我们可以定义一些切面类，然后在其中声明一些方法，这些方法可以在应用程序的流程中某些特定的时刻被执行，从而实现一些横切关注点。
下面是一个简单的例子，展示了如何使用Spring AOP：

@Aspect
    public class MyAspect {

        @Before("execution(* com.example.service.UserService.*(..))")
        public void before(JoinPoint joinPoint) {
            System.out.println("前置通知：" + joinPoint.getSignature().getName());
        }

        @AfterReturning("execution(* com.example.service.UserService.*(..))")
        public void afterReturning(JoinPoint joinPoint) {
            System.out.println("后置通知：" + joinPoint.getSignature().getName());
        }

        @Around("execution(* com.example.service.UserService.*(..))")
        public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
            System.out.println("环绕通知开始：" + proceedingJoinPoint.getSignature().getName());
            Object result = proceedingJoinPoint.proceed();
            System.out.println("环绕通知结束：" + proceedingJoinPoint.getSignature().getName());
            return result;
        }

    }

在上面的代码中，我们首先通过注解@Aspect声明了一个切面类MyAspect。然后，我们定义了三个不同的通知方法，分别是@Before、@AfterReturning和@Around。这些通知方法可以在UserService这个服务类的方法执行前、执行后和执行前后都被调用。其中，@Before和@AfterReturning是比较简单的通知，它们分别在UserService的方法执行前和执行后被调用，而@Around是比较灵活和强大的通知，它可以在方法执行前、执行后和执行前后都被调用，并且还可以控制方法的执行过程。通过这种方式，我们可以在应用程序的流程中插入一些横切关注点，比如日志记录、安全验证、性能监控等等。这就是Spring AOP实验代理模式的精髓所在。

Spring 延迟加载

代理模式实现延迟加载在Spring框架中，我们可以使用代理模式实现延迟加载。具体来说，我们可以在Bean的定义中使用lazy-init属性来指定是否启用延迟加载。如果设置了lazy-init=“true”，则Spring会在Bean第一次被使用时才进行初始化，从而可以减小应用程序的启动时间和内存占用

<bean id="userService" class="com.example.service.impl.UserServiceImpl" lazy-init="true">
  <property name="userRepository" ref="userRepository"/>
</bean>

Spring 事务管理

代理模式实现事务管理在使用Spring框架进行事务管理时，我们通常会使用代理模式。具体来说，我们会在DAO层定义一个接口和实现类，并且在实现类中使用@Transactional注解来标识事务的边界。然后，在Service层中，我们可以通过依赖注入的方式来获取DAO实例，从而实现对DAO层方法的代理，从而实现事务管理。

java
public interface UserDao {

    void save(User user);

    void delete(long id);

}

@Transactional
public class UserDaoImpl implements UserDao {

    @Override
    public void save(User user) {
        // ...
    }

    @Override
    public void delete(long id) {
        // ...
    }

}

@Service
public class UserService {

    @Autowired
    private UserDao userDao;

    @Transactional
    public void save(User user) {
        userDao.save(user);
    }

    @Transactional
    public void delete(long id) {
        userDao.delete(id);
    }

}

Spring 远程调用

代理模式实现远程调用在分布式系统中，我们通常会使用代理模式实现远程调用。具体来说，我们可以在应用程序中定义一个接口，并且在另一个应用程序中实现这个接口。然后，在调用方应用程序中，我们可以通过依赖注入的方式来获取实现类的代理对象，从而实现远程调用。
在上面的代码中，我们使用了Hessian框架实现了远程调用。通过在应用程序中定义接口并且在另一个应用程序中实现这个接口，我们可以通过代理模式实现远程调用。

对比

和装饰模式区别

  在行为效果上, 两种设计模式都可以实现增强

 代理模式的增强: 添加非业务功能;

 装饰器模式的增强: 弥补或者扩展业务功能;

如果你非要使用装饰器进行非业务功能的增强, 以及使用代理模式扩展业务功能是否可以? 可以, 但是我们学习设计模式的目的是为了写出大牛一样专业的代码, 那么就借鉴设计模式的规则.
去高速公路上开车就遵守高速的限速规定

呢喃coding

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录