设计模式学习记录——代理模式

代理模式的目的：为了实现对某一类的某一方法的扩展

代理模式的要求：被代理类和代理类实现同一个接口，且代理类要持有被代理类对象

静态代理：需要为每个要实现某一功能的类创建一个代理类。

代码如下示例：

    public interface Subject {
        void expandedMethod();
    }

    //被代理类
    public class ExpandedClass implements Subject {
        //需要扩展的方法
        @Override
        public void expandedMethod() {
            System.out.println("Hi, I am the ExpandedClass");
        }
    }

    //代理类
    public class ProxyClass implements Subject {
        private ExpandedClass ec; //持有被代理类的对象
        public ProxyHandler() {
		    this.ec = new ExpandedClass();
	    }
        //扩展被代理类的方法
        @Override
        public void expandedMethod() {
            System.out.println("**** before the ExpandedClass.expandedMethod()*****");
            ec.expandedMethod();
            System.out.println("**** after the ExpandedClass.expandedMethod()*****");
        }
    }
    
    //测试类
    public class Test{
		public static void main(String[] args) {
			ProxyClass proxy = new ProxyClass();
			proxy.expandedMethod();
		}
	}

动态代理：动态的为一些类增加某一功能，例如AOP的拦截器
AOP中的动态代理的实现采用了两种模式：即JDK动态代理和CGLIB动态代理
JDK动态代理：采用JDK的反射原理实现的动态代理；
CGLIB动态代理：采用ASM原理实现的动态代理；

JDK动态代理 示例如下：

    public interface Subject {
        void expandedMethod();
    }

    //被代理类
    public class ExpandedClass implements Subject {
        //需要扩展的方法
        @Override
        public void expandedMethod() {
            System.out.println("Hi, I am the ExpandedClass");
        }
    }
    //JDK动态代理类
    public class JDKProxy implements InvocationHandler {

	    private Object proxied;
	    
        public JDKProxy(){
            
        }

	    public JDKProxy(Object proxied) {
	    	this.proxied = proxied;
	    }

    	@Override
    	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
	    	System.out.println("before the proxy method");
	    	Object reult = method.invoke(proxied, args);
	    	System.out.println("after the proxy method");
	    	return reult;
    	}
    }
    //测试类
    public static Test{
        public static void main(String[] args) {
            JDKDyProxy();
        }
        
        private static void JDKDyProxy(){
            Subject proxy = (Subject) Proxy.newProxyInstance(
                Subject.class.getClassLoader(), new Class[] { Subject.class },
                new JDKProxy(new ExpandedClass())); //将被代理类通过反射原理给代理类
            proxy.expandedMethod();
        }
    }

CGLIB动态代理 示例如下：

    public interface Subject {
        void expandedMethod();
    }

    //被代理类
    public class ExpandedClass implements Subject {
        //需要扩展的方法
        @Override
        public void expandedMethod() {
            System.out.println("Hi, I am the ExpandedClass");
        }
    }
    
    //CGLIB代理类
    public class CglibProxy implements MethodInterceptor {

	    @Override
    	public Object intercept(Object arg0, Method arg1, Object[] arg2,
			MethodProxy arg3) throws Throwable {
		System.out.println("before*-**" + arg3.getSuperName());
		System.out.println("********" + arg1.getName() + "***********");
		Object obj = arg3.invokeSuper(arg0, arg2);
		System.out.println("after*-**" + arg3.getSuperName());
		return obj;
	    }
    }
    
    //测试类
    public static Test{
        public static void main(String[] args) {
            CGLIBDyProxy();
        }
        
        private static void CGLIBDyProxy() {
		    CglibProxy cgProxy = new CglibProxy();
           
		    Enhancer enhance = new Enhancer();
		    enhance.setSuperclass(RealSubject.class);
		    enhance.setCallback(cgProxy);

	    	Subject real = (Subject) enhance.create();
	    	real.doSomething();
	    }
    }