代理模式在企业级开发中的应用

//业务接口
public interface Service ...{
    //两个方法声明
    public void method1();
    public void method2();
}

//业务逻辑组件，实现Service接口
public class ServiceImpl implements Service ...{
    //实现接口实现的两个方法
    public void method1() ...{
        System.out.println("执行业务方法1");
    }
    public void method2() ...{
        System.out.println("执行业务方法2");
    }
}

//负责产生业务逻辑组件的工厂
public class ServiceFactory ...{
    //将工厂设置成单态模式
    private static ServiceFactroy sf;
    //业务逻辑组件
    private Service service;
    //构造器私有，保证最多只能产生一个工厂
    private ServiceFactory() ...{
    }
    //实例化工厂的方法
    public static ServiceFactory instance() ...{
        if (sf == null)
        ...{
            sf = new ServiceFactory();
        }
        return sf;
    }
    //获取业务逻辑组件的方法
    public Service getService(String impl) ...{
        if (impl.equals("one"))
        ...{
            if (service == null)
            ...{
                service = new ServiceImpl();
            }
        }
        return null;
    }
}

//代理处理器，实现InvocationHandler
public class ProxyHandler implements InvocationHandler ...{
    //target是被代理的目标对象
    private Object target;
    //invoke方法是实现InvocationHandler接口必须实现的方法，
    //该方法会在目标对象方法被调用时，自动被调用
    public Object invoke(Object proxy, Method method, Object[] args)
         throws Exception ...{
        Object result = null;
        if (method.getName().equals("method1"))
        ...{
            System.out.println("开始事务...");
            result = method.invoke(target, args);
            System.out.println("提交事务...");
        }
        else 
        ...{
            result = method.invoke(target, args);
        }
        return result;
    }
    public void setTarget(Object o) ...{
        this.target = o;
    }
}

//负责生成动态代理的代理工厂
public class MyProxyFactory ...{
    public static Object getProxy(Object object) ...{
        //代理处理类实例
        ProxyHandler handler = new ProxyHandler();
        //把该Service实例委托给代理操作
        handler.setTarget(object);
        //第一个参数是用来创建动态代理的ClassLoader对象，只要该对象能访问
        //Service接口即可。第二个参数表明该代理所实现的所有接口，第三个参数
        //是代理的处理类
        return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.
            getClass().getInstance(), handler);
    }
}

public class TestService ...{
    public static void main(String[] args) ...{
        Service service = null;
        //通过ServiceFactory生成Service实例，该Service实例是需要代理的目标对象
        Service targetObject = ServiceFactory.instance().getService("one");
        //根据目标对象，生成代理对象
        Object proxy = MyProxyFactory.getProxy(targetObject);
        //判断代理对象是否实现Service接口
        if (proxy instanceof Service)
        ...{
            //将代理对象转换Service实例
            service = (Service)proxy;
        }
        //通过代理对象执行method1
        service.method1();
        service.method2();
    }
}

==>
开始事务...
执行业务方法1
提交事务...
执行业务方法2