代理模式（结构性模式）-白红宇

代理模式（结构性模式）

阅读量：156 次

发布时间：2019-02-28

本文共 3713 字，大约阅读时间需要 12 分钟。

代理模式（Proxy Pattern）

代理模式（Proxy Pattern）是一种常用的设计模式，主要用于为另一个对象提供一个替代对象，以控制对原对象的访问。通过代理模式，可以在不直接暴露目标对象的情况下，间接地控制其访问或修改其状态。

代理模式的结构

代理模式的核心思想是：当目标对象的访问权限需要被控制或限制时，代理模式可以提供一个替代对象（代理对象），它可以控制对目标对象的访问。这样，客户端代码只需要与代理对象交互，而不需要直接与目标对象进行通信。

静态代理

静态代理是在运行时动态生成的代理对象，通常需要目标对象实现一个接口或继承自一个基类。这种方法的优点是实现简单，但其缺点在于，如果接口发生变化，所有相关的代理类都需要重新编译和发布。

以下是一个简单的静态代理示例：

// 接口
public interface UserDao {
    void save();
}
// 目标对象实现类
public class UserDaoImpl implements UserDao {
    public void save() {
        System.out.println("----已经保存数据!----");
    }
}
// 代理类
public class UserDaoProxy implements UserDao {
    // 维护目标对象
    private UserDao target;
    public UserDaoProxy(UserDao target) {
        this.target = target;
    }
    public void save() {
        System.out.println("开始事务...");
        target.save(); // 调用目标对象的方法
        System.out.println("提交事务...");
    }
}
// 测试类
public class TestMain {
    public static void main(String[] args) {
        // 目标对象
        UserDao userDao = new UserDaoImpl();
        // 代理对象
        UserDao proxy = new UserDaoProxy(userDao);
        // 调用代理对象的方法
        proxy.save();
    }
}

静态代理的缺点

接口依赖性强：因为目标对象需要实现接口，所以一旦接口发生变化，所有相关的代理类都需要重新编译和发布。

类数量过多：每个接口都需要一个对应的代理类，导致类的数量急剧增加，维护成本高。

动态代理

动态代理不需要在源码中定义代理类，而是在运行时动态生成代理对象。这种方法适用于目标对象不实现任何接口的情况。

以下是一个简单的动态代理示例：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
// 代理工厂类
public class ProxyFactory {
    // 维护目标对象
    private Object target;
    public ProxyFactory(Object target) {
        this.target = target;
    }
    // 获取代理对象
    public Object getProxyInstance() {
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(), 
            target.getClass().getInterfaces(), 
            new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println("开始事务2");
                    // 调用目标对象的方法
                    Object returnValue = method.invoke(target, args);
                    System.out.println("提交事务2");
                    return returnValue;
                }
            }
        );
    }
}
// 测试类
public class App {
    public static void main(String[] args) {
        // 目标对象
        UserDao target = new UserDaoImpl();
        // 代理对象
        UserDao proxy = (UserDao) new ProxyFactory(target).getProxyInstance();
        // 调用代理对象的方法
        proxy.save();
    }
}

Cglib代理

Cglib（Code Generation Library）代理是一种基于目标对象的动态代理，它不需要目标对象实现接口，而是动态生成目标对象的子类，从而实现代理。这种方法适用于目标对象没有实现任何接口的情况。

以下是一个简单的Cglib代理示例：

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
// Cglib代理工厂类
public class ProxyFactory implements MethodInterceptor {
    // 维护目标对象
    private Object target;
    public ProxyFactory(Object target) {
        this.target = target;
    }
    // 获取代理对象
    public Object getProxyInstance() {
        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("开始事务...");
        // 调用目标对象的方法
        Object returnValue = method.invoke(target, args);
        System.out.println("提交事务...");
        return returnValue;
    }
}

代理模式的总结

代理模式通过提供一个替代对象，控制对目标对象的访问，主要用于以下场景：

保护目标对象：限制或限制对目标对象的访问。

增加功能：在目标对象的基础上增加额外的功能。

远程访问：当目标对象位于远程服务器时，通过代理对象本地访问目标对象。

静态代理和动态代理是两种常见的实现方式，而Cglib代理是一种适用于特定场景的动态代理方法。在实际应用中，需要根据具体需求选择合适的代理方式。

转载地址：http://pwrd.baihongyu.com/

你可能感兴趣的文章