代理模式也是一种常用的设计模式。传统的代理模式主要用于采用简单对象来代替复杂的对象，如果创建一个对象所需的时间比较长，且计算资源相当昂贵，可以采用一个相对简单的对象来代替它。代理模式可将创建过程推迟到真正需要该对象时完成，一旦整个对象创建成功，对代理的方法调用将变成对实际对象的方法调用。
J2EE 里的代理模式通常是采用功能更强大的对象来代替目标对象。例如，对于普通的业务逻辑组件，其方法都应该有事务性，但这种开始事务和结束事务都是通用步骤。因此原始业务逻辑对象的方法可以无须事务操作，而是由系统生成动态代理来负责事务操作，并调用实际的目标方法。
package com.zxr.service;
/**
* 业务接口
* @author 张相荣
* @Date 2010-7-10 下午05:34:41
* @Email: [email protected]
*/
public interface Service {
public void methodOne();
public void methodTwo();
}
package com.zxr.service;
/**
* 业务实现类
* @author 张相荣
* @Date 2010-7-10 下午05:36:20
* @Email: [email protected]
*/
public class ServiceImpl implements Service {
/* (non-Javadoc)
* @see com.zxr.service.Service#methodOne()
*/
@Override
public void methodOne() {
System.out.println("methodOne is Working");
}
/* (non-Javadoc)
* @see com.zxr.service.Service#methodTwo()
*/
@Override
public void methodTwo() {
System.out.println("methodTwo is Woring");
}
}
package com.zxr.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
* @author 张相荣
* @Date 2010-7-10 下午05:54:57
*/
public class ProxyHandler implements InvocationHandler {
//target是被代理的目标对象
private Object target;
/* invoke方法是实现InvocationHandler接口必须实现的方法，该方法会在目标对象方法被调用时，自动被调用。
* @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//result是调用目标方法的返回值
Object result=null;
if("methodOne".equals(method.getName())){
//例如开启事务
System.out.println("methodOne was Call, Transaction Beging...");
//执行目标方法
result=method.invoke(target, args);
//例如结束事务
System.out.println("Transaction commit...");
}else{
//直接调用目标方法
result=method.invoke(target, args);
}
return result;
}
public void setTarget(Object obj){
this.target=obj;
}
}
package com.zxr.factory;
import com.zxr.service.Service;
import com.zxr.service.ServiceImpl;
/**
* 负责产生业务组件
* @author 张相荣
* @Date 2010-7-10 下午05:40:04
*/
public class ServiceFactory {
//将工厂设计成単例模式
private static ServiceFactory serviceFactory;
private Service service;
private ServiceFactory(){
}
public static ServiceFactory instance(){
if(serviceFactory==null){
serviceFactory=new ServiceFactory();
}
return serviceFactory;
}
public Service getService(String serviceImp){
if("one".equals(serviceImp)){
if(service==null){
service=new ServiceImpl();
}
return service;
}
return null;
}
}
package com.zxr.factory;
import java.lang.reflect.Proxy;
import com.zxr.proxy.ProxyHandler;
/**
* @author 张相荣
* @Date 2010-7-10 下午06:07:05
*/
public class MyProxyFactory {
public static Object getProxy(Object obj){
ProxyHandler proxyHandler=new ProxyHandler();
//将Service实例托给代理操作
proxyHandler.setTarget(obj);
//第一个参数：创建动态代理的ClassLoader对象，只要该对象能访问Service接口即可。
//第二个参数：表明该代理实现的所有接口。
//第三个参数：代理的常理类（类似回调）。
return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), proxyHandler);
}
}
/**
*
*/
package com.zxr.main;
import com.zxr.factory.MyProxyFactory;
import com.zxr.factory.ServiceFactory;
import com.zxr.service.Service;
/**
* @author 张相荣
* @Date 2010-7-10 下午05:52:16
*/
public class Working {
/**
* @param args
*/
public static void main(String[] args) {
//测试工厂类方法
Service service=null;
service=ServiceFactory.instance().getService("one");
if(service!=null){
service.methodOne();
service.methodTwo();
}
System.out.println("=========================");
//测试代理类方法
Object proxy=MyProxyFactory.getProxy(service);
if(proxy instanceof Service){
service=(Service)proxy;
service.methodOne();
service.methodTwo();
}
}
}
记录体验下。
