理解代理模式

一时失言乱红尘 2021-11-30 00:38 228阅读 0赞

--------------------

title: “理解代理模式”

url: “[https://wsk1103.github.io/][https_wsk1103.github.io]”

tags:

*  设计模式

--------------------

## 是什么 ##

代理模式属于结构型模式。给某一个对象提供一个代理，并且使用该代理的对象来访问原来的对象。

代理模式一般分为静态代理和动态代理，动态代理又分为JDK代理和CGLIB代理。

## 优缺点 ##

#### 优点 ####

在不修改原来类的情况下，增强类的功能。

#### 缺点 ####

系统更复杂。

## 静态代理 ##

以 **spring** 的事务 **@translation** 为例。

#### 1. 先创建一个用户的增删改查的接口和其实现类。 ####

/**
     * @author wsk1103
     * @date 2019/7/22
     * @description 用户类
     */
    public interface UserService {
    
        /**
         * 更新
         */
        void update();
    
    }
    
    /**
     * @author wsk1103
     * @date 2019/7/22
     * @description 描述
     */
    public class UserServiceImpl implements UserService{
    
        @Override
        public void update() {
            System.out.println("update......");
        }
    }

一般来说，这就是一个数据库的更新操作了。

#### 2. 静态代理实现事务 ####

但是如果我们想要为其加入 **事务控制** ，又不想修改原来的类，那就可以试试静态代理。

/**
     * @author wsk1103
     * @date 2019/7/22
     * @description 静态代理
     */
    public class TranslationProxy implements UserService {
    
        private UserService userService;
    
        public TranslationProxy(UserService service) {
            this.userService = service;
        }
    
        @Override
        public void update() {
            start();
            userService.update();
            commit();
        }
    
        private void start() {
            System.out.println("start translation");
        }
        
        private void commit() {
            System.out.println("commit translation");
        }
    }

#### 3. 测试和输出结果 ####

/**
     * @author wsk1103
     * @date 2019/7/22
     * @description 描述
     */
    public class Main {
    
        public static void main(String[] args) {
            System.out.println("不使用静态代理");
            UserService userService = new UserServiceImpl();
            userService.update();
            System.out.println("-------");
    
            System.out.println("使用静态代理");
            UserService target = new UserServiceImpl();
            UserService proxy = new TranslationProxy(target);
            proxy.update();
            System.out.println("--------");
    
        }
    
    }
    
    不使用静态代理
    update......
    -------
    使用静态代理
    start translation
    update......
    commit translation
    --------

#### 优点 ####

既达到了功能的增强，并且没有破坏入侵源代码。

#### 缺点 ####

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

## JDK动态代理 ##

还是以 **事务** 为例子。

JDK动态代理主要涉及：**java.lang.reflect.Proxy**

#### 1. 实现动态代理 ####

import java.lang.reflect.Proxy;
    /**
     * @author wsk1103
     * @date 2019/7/22
     * @description 动态代理
     */
    public class TranslationProxyFactory {
    
        //被代理的对象
        private Object target;
    
        public TranslationProxy(Object o) {
            this.target = o;
        }
    
        private void start() {
            System.out.println("start translation");
        }
    
        private void commit() {
            System.out.println("commit translation");
        }
    
        public Object getProxyInstance() {
            return Proxy.newProxyInstance(
                    target.getClass().getClassLoader(),
                    target.getClass().getInterfaces(),
                    (proxy1, method1, args1) -> {
                        start();
                        //执行目标对象方法
                        Object returnValue = method1.invoke(target, args1);
                        commit();
                        return returnValue;
                    }
            );
        }
    }

#### 2. 测试和结果 ####

public class Main {
    
        public static void main(String[] args) {
            System.out.println("不使用静态代理");
            UserService userService = new UserServiceImpl();
            userService.update();
            System.out.println("-------");
    
            System.out.println("使用动态代理");
            UserService target = new UserServiceImpl();
            UserService proxy = (UserService) new TranslationProxyFactory(target).getProxyInstance();
            proxy.update();
            System.out.println("--------");
    
        }
    }
    
    不使用静态代理
    update......
    -------
    使用动态代理
    start translation
    update......
    commit translation
    --------

#### 优点 ####

解耦

#### 缺点 ####

基于Java反射机制实现，代理对象不需要实现接口,但是目标对象一定要实现接口,否则不能用动态代理

## CGLIB动态代理 ##

需要引入新的包 CGLIB 。如果是使用spring的话就不需要，因为spring中默认会引入了。

*  Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口.它广泛的被许多AOP的框架使用,例如Spring AOP和synaop,为他们提供方法的interception(拦截)
 *  Cglib包的底层是通过使用字节码处理框架ASM来转换字节码并生成新的子类.

#### 1. maven 引入 cglib ####

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

#### 2. CGLIB动态代理工厂 ####

import net.sf.cglib.proxy.Enhancer;
    import net.sf.cglib.proxy.MethodInterceptor;
    import net.sf.cglib.proxy.MethodProxy;
    
    import java.lang.reflect.Method;
    
    /**
     * @author wsk1103
     * @date 2019/7/22
     * @description 动态代理
     */
    public class TranslationProxy implements MethodInterceptor {
    
        //被代理的对象
        private Object target;
    
        public TranslationProxy(Object o) {
            this.target = o;
        }
    
        private void start() {
            System.out.println("start translation");
        }
    
        private void commit() {
            System.out.println("commit translation");
        }
    
        public Object getProxyInstance() {
            //1.工具类
            Enhancer en = new Enhancer();
            //2.设置父类
            en.setSuperclass(target.getClass());
            //3.设置回调函数
            en.setCallback(this);
            //4.创建子类(代理对象)
            return en.create();
        }
    
        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            start();
            Object result = method.invoke(target, objects);
            commit();
            return result;
        }
    }

#### 测试和输出 ####

package com.wsk.utils;
    
    /**
     * @author wsk1103
     * @date 2019/7/22
     * @description 描述
     */
    public class Main {
    
        public static void main(String[] args) {
            System.out.println("不使用代理");
            UserService userService = new UserServiceImpl();
            userService.update();
            System.out.println("-------");
    
            System.out.println("使用动态代理");
            UserService target = new UserServiceImpl();
            UserService proxy = (UserService) new TranslationProxy(target).getProxyInstance();
            proxy.update();
            System.out.println("--------");
    
        }
    }
    
    不使用代理
    update......
    -------
    使用动态代理
    start translation
    update......
    commit translation
    --------

#### 优点 ####

解耦

#### 缺点 ####

代理的类不能为final,否则报错；目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法.

#### java中的应用 ####

*  java.lang.reflect.Proxy
 *  Apache Commons Proxy
 *  Mocking frameworks Mockito, Powermock, EasyMock

参考：  
[https://github.com/iluwatar/java-design-patterns/tree/master/proxy][https_github.com_iluwatar_java-design-patterns_tree_master_proxy]  
[https://segmentfault.com/a/1190000009235245\#articleHeader7][https_segmentfault.com_a_1190000009235245_articleHeader7]

[https_wsk1103.github.io]: https://wsk1103.github.io/
[https_github.com_iluwatar_java-design-patterns_tree_master_proxy]: https://github.com/iluwatar/java-design-patterns/tree/master/proxy
[https_segmentfault.com_a_1190000009235245_articleHeader7]: https://segmentfault.com/a/1190000009235245#articleHeader7