设计模式-代理模式-示例源码

23种设计模式汇总讲解文档
汇总学习网址： Java23种设计模式-学习汇总

代理模式
定义¹：为其他对象提供代理，以控制该对象的访问。
透明代理：用户不用设置代理服务器地址，就可以直接访问。代理服务器对于用户来讲是透明的。
普通代理：用户需要自行设置代理服务器的IP地址，用户必须知道代理的存在。
强制代理：必须通过真实角色查找到代理角色，否则无法访问。例如你和某明星比较熟，但是你找他有些事情，他还是让你找他的经纪人。
动态代理：在现实阶段不用关心代理的是谁，而在运行阶段，才指定代理的是哪一个类。
InvocationHandler是JDK提供的动态代理接口，继承后必须实现invoke方法。通过该接口，所有的方法，都由该Handler处理。


// Actor.java

package T12;

/**
 * @author YangCourage
 * 定义接口
 */
public interface Actor {
    
    
//	演员需要表演
	public void show();
}

// ActorTom.java
// 实际的实现类，被代理的对象
/**
 * 
 */
package T12;

/**
 * @author YangCourage
 * 演员Tom
 */
public class ActorTom implements Actor {
    
    

	/* (non-Javadoc)
	 * @see T12.Actor#show()
	 */
	@Override
	public void show() {
    
    
		System.out.println("Tom猫开始演奏音乐");
	}
}


// ProxyActor.java
// 普通的代理类
package T12;

/**
 * @author YangCourage
 * 演员的经纪人
 */
public class ProxyActor implements Actor {
    
    
//	代理的对象
	Actor actor = null;
	public ProxyActor(Actor actor){
    
    
		// 指定代理对象
		this.actor = actor;
	}
	@Override
	public void show() {
    
    
		// 代理模式的对象内容的调用权限是由代理类全权控制的。
		int num = (int) (Math.random()*1000);
		if(num>500 && actor!=null){
    
    
			actor.show();
		}
		else{
    
    
			System.out.println("经纪人拒绝Tom猫上台演奏");
		}
	}
}

/**
 * 动态代理的类
 * InvokeProxyActor.java
 */
package T12;

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

/**
 * @author YangCourage
 * 动态代理类代理
 */
public class InvokeProxyActor implements InvocationHandler {
    
    

	// 动态代理类的类型
	Class<?> clazz = null;
	// 代理的对象内容
	Object obj = null;
	// 动态代理的方法内容
	public InvokeProxyActor(Object obj){
    
    
		this.obj = obj;
		clazz = obj.getClass();
	}
	/**
	 * 动态代理的类
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
    
    
		System.out.println("调用方法前调用");
		// 实际调用方法的位置
		Object back = method.invoke(this.obj, args);
		System.out.println("调用方法后调用");
		return back;
	}
}

/**
 * 主方法的类
 * Main.java
 */
package T12;

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

/**
 * @author YangCourage
 * 
 */
public class Main {
    
    
	public static void main(String[] args) {
    
    
		System.out.println("=========开始展示普通代理========");
		
		// 普通代理的调用
		Actor actor = new ActorTom();
		Actor proxy = new ProxyActor(actor);
		proxy.show();
		proxy.show();
		proxy.show();
		proxy.show();
		
		System.out.println("=========开始展示动态代理========");
		// 动态代理的调用
		// 定义被代理的对象
		Actor actor1 = new ActorTom();
		// 定义代理Invocation对象
		InvocationHandler handler = new InvokeProxyActor(actor1);
		// 定义动态代理的代理类
		// 参数ClassLoader 代理的类实际类, new Class[]{代理的接口},定义的InvocationHandler类
		Actor proxy1 = (Actor)Proxy.newProxyInstance(ActorTom.class.getClassLoader(), new Class[]{
    
    Actor.class}, handler);
		proxy1.show();
	}
}

运行结果如下所示

=开始展示普通代理
经纪人拒绝Tom猫上台演奏
经纪人拒绝Tom猫上台演奏
Tom猫开始演奏音乐
Tom猫开始演奏音乐
=开始展示动态代理
调用方法前调用
Tom猫开始演奏音乐
调用方法后调用

《设计模式之禅》秦小波 ↩︎

设计模式-代理模式-示例源码

猜你喜欢