图解Java设计模式之代理模式

package com.example.demo.proxy;

public interface ITeacherDao {

	/**
	 * 授课的方法
	 */
	void teach();
}
package com.example.demo.proxy;

public class TeacherDao implements ITeacherDao{

	@Override
	public void teach() {
		// TODO Auto-generated method stub
		System.out.println(" 老师授课中 。。。 ");
	}

}
package com.example.demo.proxy;

/**
 * 
 * 代理对象，静态代理
 * 
 * @author zhaozhaohai
 *
 */
public class TeacherDaoProxy implements ITeacherDao{
	
	/**
	 * 目标对象，通过接口来聚合
	 */
	private ITeacherDao ITeacherDao;

	/**
	 * 构造器
	 * @param iTeacherDao
	 */
	public TeacherDaoProxy(ITeacherDao iTeacherDao) {
		super();
		ITeacherDao = iTeacherDao;
	}



	@Override
	public void teach() {
		// TODO Auto-generated method stub
		// 方法
		System.out.println("开始代理 完成某些操作 。。。 ");
		ITeacherDao.teach();
		// 方法
		System.out.println("提交 。。。。 ");
	}

}
package com.example.demo.proxy;

public class Client {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 创建目标对象（被代理对象）
		TeacherDao teacherDao = new TeacherDao();
		// 创建代理对象，同时将代理对象传递给代理对象
		TeacherDaoProxy teacherDaoProxy = new TeacherDaoProxy(teacherDao);
		// 通过代理对象，调用到被代理对象的方法
		// 即 ：执行的是代理对象的方法，代理对象再去调用目标对象的方法
		teacherDaoProxy.teach();
	}

}

package com.example.demo.proxy.dynamic;

/**
 * 接口
 * @author zhaozhaohai
 *
 */
public interface ITeacherDao {

	/**
	 * 授课方法
	 */
	void teach();
	
	void sayHello(String name);
}
package com.example.demo.proxy.dynamic;

public class TeacherDao implements ITeacherDao{

	@Override
	public void teach() {
		// TODO Auto-generated method stub
		System.out.println(" 老师授课中 。。。 ");
	}

	@Override
	public void sayHello(String name) {
		// TODO Auto-generated method stub
		System.out.println("hello " + name);
	}

}
package com.example.demo.proxy.dynamic;

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

public class ProxyFactory {
	
	/**
	 * 维护一个目标对象，Object
	 */
	private Object target;

	/**
	 * 构造器，对target进行初始化
	 * @param target
	 */
	public ProxyFactory(Object target) {
		this.target = target;
	}
	
	/**
	 * 给目标对象生成一个代理对象
	 * @return
	 */
	public Object getProxyInstance() {
		//说明 
		/** 
		public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
		//1. ClassLoader loader : 指定当前目标对象使用的类加载器, 获取加载器的方法固定
		//2. Class<?>[] interfaces: 目标对象实现的接口类型，使用泛型方法确认类型
		//3. InvocationHandler h : 事情处理，执行目标对象的方法时，会触发事情处理器方法, 会把当前执行
		的目标对象方法作为参数传入
		*/
		return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
			
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				System.out.println("JDK 代理开始 -- ");
				// 反射机制调用目标对象的方法
				Object returnObject = method.invoke(target, args);
				System.out.println(" JDK 代理提交 ");
				return returnObject;
			}
		});
	}
	
}
package com.example.demo.proxy.dynamic;

public class Client {
	public static void main(String[] args) {
		// 创建目标对象
		ITeacherDao teacherDao = new TeacherDao();
		// 给目标对象，创建代理对象，可以转成ITeacherDao
		ITeacherDao iTeacherDao = (ITeacherDao)new ProxyFactory(teacherDao).getProxyInstance();
		// class com.sun.proxy.$Proxy0 内存中动态生成了代理对象
		System.out.println(iTeacherDao.getClass());
		// /通过代理对象，调用目标对象的方法 
		//proxyInstance.teach();
		iTeacherDao.sayHello(" tom ");
	}
}

package com.example.demo.proxy.cglib;

public class TeacherDao {

	public String teach() {
		System.out.println(" 老师授课中，我是cglib代理，不需要实现接口 ");
		return "hello";
	}
}
package com.example.demo.proxy.cglib;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class ProxyFactory implements MethodInterceptor{
	
	/**
	 * 维护目标对象
	 */
	private Object target;
	
	public ProxyFactory(Object tObject) {
		// TODO Auto-generated constructor stub
		this.target = tObject;
	}
	
	/**
	 * 返回一个代理对象 ：是target对象的代理对象
	 * @return
	 */
	public Object getProxyInstance() {
		// 1. 创建一个工具类
		Enhancer enhancer = new Enhancer();
		// 2. 设置父类
		enhancer.setSuperclass(target.getClass());
		// 3. 设置回掉函数
		enhancer.setCallback(this);
		// 4. 创建子类对象，即代理对象
		return enhancer.create();
	}

	@Override
	public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
		// TODO Auto-generated method stub
		System.out.println("Cglib 代理模式 -- 开始 ");
		Object retObject = method.invoke(target, args);
		System.out.println("Cglib 代理模式 -- 提交 ");
		return retObject;
	}

}
package com.example.demo.proxy.cglib;

public class Client {
	public static void main(String[] args) {
		//创建目标对象
		TeacherDao target = new TeacherDao(); 
		//获取到代理对象，并且将目标对象传递给代理对象
		TeacherDao proxyInstance = (TeacherDao)new ProxyFactory(target).getProxyInstance();
		//执行代理对象的方法，触发 intecept 方法，从而实现 对目标对象的调用 
		String res = proxyInstance.teach();
		System.out.println("res=" + res);
	}
}