设计模式之代理模式

代理模式

代理模式

代理模式（Proxy Pattern）是指为其他对象提供一种代理，以控制对这个对象的访问，属于结构型模式。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

代理模式的通用UML图

代理模式一般包含三种角色：
抽象主题角色（ISubject）：抽象主题类的主要职责是声明真实主题与代理的共同接口方法，该类可以是接口也可以是抽象类；

真实主题角色（RealSubject）：该类也被称为被代理类，该类定义了代理所表示的真实对象，是负责执行系统真正的逻辑业务对象；

代理主题角色（Proxy）：也被称为代理类，其内部持有RealSubject的引用，因此具备完全的对RealSubject的代理权。客户端调用代理对象的方法，同时也调用被代理对象的方法，但是会在代理对象前后增加一些处理代码。

在代码中，一般代理会被理解为代码增强，实际上就是在原代码逻辑前后增加一些代码逻辑，而使调用者无感知。代理模式属于结构型模式，分为静态代理和动态代理。

静态代理

代理模式的通用写法就是静态代理，创建抽象主题角色 ISubject 接口

public interface ISubject
{
    void request();
}

创建真实主题角色RealSubject类：

public class RealSubject implements ISubject
{
	@Override
	public void request()
	{
		System.out.println("real service called");
	}
}

创建代理主题角色Proxy类：

public class Proxy implements ISubject
{

	private ISubject subject;

	public Proxy(ISubject subject)
	{
		this.subject = subject;
	}

	@Override
	public void request()
	{
		before();
		subject.request();
		after();
	}

	private void after()
	{
		System.out.println("call service after");
	}

	private void before()
	{
		System.out.println("call service before");
	}
}

测试代码

public class Main
{
	public static void main(String[] args)
	{
		Proxy proxy = new Proxy(new RealSubject());
		proxy.request();
	}
}

运行效果

用继承的方式也可以实现代理模式，这里不再赘述。

动态代理

在Java生态中，目前最普遍使用的是JDK自带的代理和Cglib提供的类库。

JDK动态代理

示例代码

public class JdkProxy implements InvocationHandler
{
	private ISubject target;

	public ISubject getInstance(ISubject target)
	{
		this.target = target;
		Class<?> clazz = target.getClass();
		return (ISubject) Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
	{
		before();
		Object res = method.invoke(target, args);
		after();
		return res;
	}

	private void after()
	{
		System.out.println("jdk call service after");

	}

	private void before()
	{
		System.out.println("jdk call service before");
	}

  // 测试代码
	public static void main(String[] args)
	{
		JdkProxy jdkProxy = new JdkProxy();
		ISubject subject = jdkProxy.getInstance(new RealSubject());
		subject.request();
	}
}

运行效果

JDK动态代理是基于接口的，所以使用JDK的动态代理就要实现接口，如果没有使用接口，则可以使用Cglib的动态代理

Cglib动态代理

CgLib代理的目标对象不需要实现任何接口，它是通过动态继承目标对象实现动态代理的。

Cglib的maven依赖

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib-nodep</artifactId>
    <version>2.2</version>
</dependency>

示例代码

public class CGlibProxy implements MethodInterceptor
{

	public Object getInstance(Class<?> clazz) throws Exception
	{
		//相当于Proxy，代理的工具类
		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(clazz);
		enhancer.setCallback(this);
		return enhancer.create();
	}

	public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable
	{
		before();
		Object obj = methodProxy.invokeSuper(o, objects);
		after();
		return obj;
	}

	private void before()
	{
		System.out.println("cglib call service before");
	}

	private void after()
	{
		System.out.println("cglib call service after");
	}

	public static void main(String[] args) throws Exception
	{
		CGlibProxy cGlibProxy = new CGlibProxy();
		RealSubject realSubject = (RealSubject) cGlibProxy.getInstance(RealSubject.class);
		realSubject.request();
	}
}

运行效果

Cglib的原理是通过继承来实现的动态代理，所以被代理的类可以不用实现接口。

CGLib代理执行代理方法的效率之所以比JDK的高，是因为CGlib采用FastClass机制，它的原理简单来说就是：为代理类和被代理类各生成一个类，这个类会为代理类或被代理类的方法分配一个index （int类型）；这个index当作一个入参，FastClass就可以直接定位要调用的方法并直接进行调用，省去了反射调用，所以调用效率比JDK代理通过反射调用高。

CGLib和JDK动态代理对比

（1）JDK动态代理实现了被代理对象的接口，CGLib代理继承了被代理对象。

（2）DK动态代理和CGLib代理都在运行期生成字节码,JDK动态代理直接写Class字节码，CGLib 代理使用ASM框架写Class字节码，CGlib代理实现更复杂，生成代理类比JDK动态代理效率低。

（3）JDK动态代理调用代理方法是通过反射机制调用的，CGLib代理是通过FastClass机制直接调用方法的，CGLib代理的执行效率更高。

静态代理和动态代理的本质区别

（1）静态代理只能通过手动完成代理操作，如果被代理类增加了新的方法，代理类需要同步增加，违背开闭原则。

（2）动态代理采用在运行时动态生成代码的方式，取消了对被代理类的扩展限制，遵循开闭原则。

（3）若动态代理要对目标类的增强逻辑进行扩展，结合策略模式，只需要新增策略类便可完成，无须修改代理类的代码。

代理模式的优缺点

代理模式的优点：

（1）代理模式能将代理对象与真实被调用目标对象分离。

（2）在一定程度上降低了系统的耦合性，扩展性好。

（3）可以起到保护目标对象的作用。

（4）可以增强目标对象的功能。

代理模式的缺点：

（1）代理模式会造成系统设计中类的数量增加。

（2）在客户端和目标对象中增加一个代理对象，会导致请求处理速度变慢。

（3）增加了系统的复杂度。

打赏