代理模式

最新推荐文章于 2025-09-13 09:06:35 发布

原创最新推荐文章于 2025-09-13 09:06:35 发布 · 145 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #设计模式

本文深入探讨了Java中的静态代理与动态代理技术，包括代理模式的定义、涉及的角色、具体实现以及优缺点。重点阐述了如何利用Java动态代理实现业务逻辑的灵活扩展，包括代理处理器的实现及日志操作接口的应用。最后总结了代理技术在实际开发中的应用与思考。

1、代理模式：

1）、代理模式：为某一对象提供一种代理来控制别人对这个对象的访问。
2）、代理模式是常用的Java 设计模式，它的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。

2、涉及的角色：

1）、抽象角色：声明真实对象和代理对象的共同接口。 
2）、代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。 
3）、真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。

3、静态代理，抽象角色（Person）：

package com.sxit.proxy;

public interface Person {
	
	//打招呼
	public void sayHello(String name);
	
	//吃东西
	public void eat(String food);
}

4、真实角色（Chinese实现Person接口）：

package com.sxit.proxy;

public class Chinese implements Person {
	
	public void sayHello(String name) {
		System.out.println("hi,"+name);
	}

	public void eat(String food) {
		System.out.println("I'm eat"+food);
	}
}

5、代理角色（Proxy）：

package com.sxit.proxy;

public class Proxy implements Person{

	//持有真实对象的引用，因为你要告诉这个代理类，你代理的是谁
	private Chinese chinese;
	
	//代理类构造函数初始化真实对象
	public Proxy(){
		if(chinese == null){
			chinese = new Chinese();
		}
	}

	//实现和真实对象一样的接口  执行真实对象业务逻辑之前、之后都可以插入一些其他的业务逻辑
	public void eat(String food) {
		preMethod();
		//调用真实对象eat方法
		chinese.eat(food);
		postMethod();
	}
	
	//实现和真实对象一样的接口  执行真实对象业务逻辑之前、之后都可以插入一些其他的业务逻辑
	public void sayHello(String name) {
		preMethod();
		//调用真实对象sayHello方法
		chinese.sayHello(name);
		postMethod();
	}
	
	public void preMethod(){
		System.out.println("方法调用之前------->>>>>>插入一段业务逻辑");
	}	
	
	public void postMethod(){
		System.out.println("方法调用之后------->>>>>>插入一段业务逻辑");
	}
}

6、测试类（StaticProxyTest）：

package com.sxit.test;

import com.sxit.proxy.Proxy;

public class StaticProxyTest {

	public static void main(String[] args){
		
		//创建代理类  用户与代理直接交互,并不知道真实对象是谁,只通过代理类来执行自己需要的业务逻辑
		Proxy proxy = new Proxy();
		proxy.eat("香蕉");
		proxy.sayHello("傻逼");
	}
}

7、打印信息：

方法调用之前------->>>>>>插入一段业务逻辑
I'm eat香蕉
方法调用之后------->>>>>>插入一段业务逻辑
方法调用之前------->>>>>>插入一段业务逻辑
hi,傻逼
方法调用之后------->>>>>>插入一段业务逻辑

8、小结：

1）、以上代码可以看出，代理类持有真实对象的引用，用户只知道有代理类，而不知道真实对象是谁，当调用代理类的方法时，其实真正执行的是真实类中的业务逻辑，而代理类可以在前后穿插一些其他的业务逻辑。
2）、不足之处：因为这里的代理类持有一个真实对象的引用，真实对象是代理类中的一个属性，那等于是说一个实际对象就要对应一个代理类，大量使用会照成类数量膨胀，那肯定不合理，这是静态代理，那有没有更简单、方便的方式呢？

9、动态代理：

1）、Java动态代理类位于Java.lang.reflect包下，一般主要涉及到如下两个类
2）、Interface InvocationHandler：该接口中仅定义了一个方法Object：invoke(Object obj,Method method, Object[] args)。在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，如上例中的eat()、sayHello()，args为该方法的参数数组， 这个抽象方法在代理类中动态实现。 
3）、Proxy：该类即为动态代理类，作用类似于上例中的Proxy，其中主要包含以下内容：
Protected Proxy(InvocationHandler h)//构造函数
Static Class getProxyClass (ClassLoader loader, Class[] interfaces)//获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。 
Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)//返回代理类的一个实例，返回后的代理类可以当作真实类使用(可使用真实类的在Person接口中声明过的方法)。 
4）、所谓Dynamic Proxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些 interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然啦，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。

10、动态代理，接口角色（Person）：

package com.sxit.proxy;

public interface Person {
	
	//打招呼
	public void sayHello(String name);
	
	//吃东西
	public void eat(String food);
}

11、具体角色：

package com.sxit.proxy;

public class Chinese implements Person {
	
	public void sayHello(String name) {
		System.out.println("hi,"+name);
	}

	public void eat(String food) {
		System.out.println("I'm eat"+food);
	}
}

12、代理处理器：

package com.sxit.proxy;

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

//使用动态代理类时，我们必须实现InvocationHandler接口
public class ProxyHandler implements InvocationHandler{
	
	//代理的目标对象，不像静态代理强制指定某一类型对象
	private Object obj;
	
	//可接受任何类型对象为其代理
	public ProxyHandler(Object obj){
		this.obj = obj;
	}

	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

		preMethod();
		//obj是被代理的对象，args是被调用方法参数，返回值为真实对象调用该方法的返回值
		Object result = method.invoke(obj, args);
		postMethod();
		//如果该方法返回值 则为null
		return result;
	}
	
	public void preMethod(){
		System.out.println("方法调用之前------->>>>>>插入一段业务逻辑");
	}	
	
	public void postMethod(){
		System.out.println("方法调用之后------->>>>>>插入一段业务逻辑");
	}
}

13、测试类（DynamicProxyTest）：

package com.sxit.test;

import com.sxit.proxy.Chinese;
import com.sxit.proxy.Person;
import com.sxit.proxy.ProxyHandler;
import java.lang.reflect.Proxy;

public class DynamicProxyTest {

	public static void main(String[] args) {
		
		Chinese chinese = new Chinese();
		ProxyHandler handler = new ProxyHandler(chinese);
		Person person = (Person)Proxy.newProxyInstance(chinese.getClass().getClassLoader(),chinese.getClass().getInterfaces(), handler);
		person.eat("香蕉");
		person.sayHello("傻逼");
	}
}

14、打印信息：

方法调用之前------->>>>>>插入一段业务逻辑
I'm eat香蕉
方法调用之后------->>>>>>插入一段业务逻辑
方法调用之前------->>>>>>插入一段业务逻辑
hi,傻逼
方法调用之后------->>>>>>插入一段业务逻辑

15、pre、post业务逻辑解耦，定义操作接口（IOperation）：

package com.sxit.proxy;

public interface IOperation {

	//方法前操作
	public void preMethod(String name);
	
	//方法后操作
	public void postMethod(long id);
	
}

16、操作接口实现类（LoggerOperation）：

package com.sxit.proxy;

public class LoggerOperation implements IOperation {

	public void preMethod(String name) {
		System.out.println("方法调用之前------->>>>>>插入一段业务逻辑--------->>"+name);
	}

	public void postMethod(long id) {
		System.out.println("方法调用之后------->>>>>>插入一段业务逻辑--------->>"+id);
	}
}

17、代理处理器（LogProxyHandler）：

package com.sxit.proxy;

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

//使用动态代理类时，我们必须实现InvocationHandler接口
public class LogProxyHandler implements InvocationHandler{
	
	//代理的目标对象，不像静态代理强制指定某一类型对象
	private Object obj;
	
	//额外的操作对象 如LoggerOperation
	private Object proxy;
	
	//可接受任何类型对象为其代理
	public Object bind(Object obj,Object proxy){
		this.obj = obj;
		this.proxy = proxy;
		return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
	}

	/**
	 * 要处理的对象中的每个方法会被此方法送去JVM调用,也就是说,要处理的对象的方法只能通过此方法调用
     * 此方法是动态的,不是手动调用的
	 */
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

		//反射得到操作者类实例
		Class clazz = this.proxy.getClass();
		//反射得到操作者的preMethod方法
		Method preMethod = clazz.getMethod("preMethod", new Class[]{String.class});
		//反射执行preMethod方法
		preMethod.invoke(this.proxy, new Object[]{"日志中的姓名"});
		
		//执行要真实对象的原本方法 obj是被代理的对象，args是被调用方法参数，返回值为真实对象调用该方法的返回值
		Object result = method.invoke(obj, args);
		
		//反射得到操作者的postMethod方法
		Method postMethod = clazz.getMethod("postMethod", new Class[]{long.class});
		//反射执行preMethod方法
		postMethod.invoke(this.proxy, new Object[]{30});
		
		//如果该方法返回值 则为null
		return result;
	}
}

18、测试类（LogDynamicProxyTest）：

package com.sxit.test;

import com.sxit.proxy.Chinese;
import com.sxit.proxy.LogProxyHandler;
import com.sxit.proxy.LoggerOperation;
import com.sxit.proxy.Person;
import com.sxit.proxy.ProxyHandler;

public class LogDynamicProxyTest {

	public static void main(String[] args) {
		
		Chinese chinese = new Chinese();
		ProxyHandler handler = new ProxyHandler(chinese);
		Person person = (Person)new LogProxyHandler().bind(new Chinese(),new LoggerOperation());
		person.eat("香蕉");
		person.sayHello("傻逼");
	}
}

19、打印信息：

方法调用之前------->>>>>>插入一段业务逻辑--------->>日志中的姓名
I'm eat香蕉
方法调用之后------->>>>>>插入一段业务逻辑--------->>30
方法调用之前------->>>>>>插入一段业务逻辑--------->>日志中的姓名
hi,傻逼
方法调用之后------->>>>>>插入一段业务逻辑--------->>30

20、总结：

1）、现在真实对象也与操作类解耦，但是现在是所有方法都被日志记录，如果只希望eat()方法记录日志，而sayHello()方法不要，可以对传进来的method的名字进行判断,判断的条件存在XML里面.这样我们就可以配置文件时解藕了。