java 的代理模式

代理模式

代理proxy是一种设计模式，提供对目标对象的另外的访问模式。好处是可以扩展目标对象的功能。
在实际开发中，可以不修改别人已经写好的代码，通过代理的方式来扩展功能。
生活中的例子：我们们要邀请明星，并不是直接联系明星，而是通过经纪人。
关键点是代理对象对目标对象的扩展，并且会调用目标对象

1.静态代理

静态代理需要定义接口或者父类，被代理的对象和代理对象要实现相中的接口或者继承相同的父类

/**
*接口
*/
public interface IUserDao{
  public void work();
}
/**
*接口实现 目标对象
*/
public class UserDao implements IUserDao{
	public void work(String begin){
			System.out.println("----"+begin+"点开始工作!----");
	}
}

/**
 * 代理对象,静态代理
 */
 public class UserDaoProxy implements IUserDao{
	//接收保存目标对象
	private IUserDao userDao;
	public UserDaoProxy(IUserDao userDao){
    	this.userDao=userDao;
  } 
  public void work() {
        System.out.println("---before--");
        userDao.work();//执行目标对象的方法
        System.out.println("---after---");
    }
}

/**
 * 测试类
 */
public class Test {
    public static void main(String[] args) {
        //目标对象
        UserDao userDao= new UserDao();
        //代理对象,把目标对象传给代理对象,建立代理关系
        UserDaoProxy proxy = new UserDaoProxy(userDao);
        proxy.work();//执行的是代理的方法
    }
}

1、静态代理可以做到在不修改目标对象的功能前提下，对目标功能扩展
2、缺点是由于目标对象和代理对象实现共同的接口，所有会有很多的代理类，一旦接口增加方法，目标对象和代理对象都要维护，维护成本大

动态代理

1、动态代理，代理对象不需要实现接口
2、代理对象的生成是利用JDK的API，在内存中动态的构建对象。需要指定创建代理或目标对象的接口的类型。

代理类所在的包：java.lang.reflect.Proxy，使用newProxyInstance方法，
该方法为静态方法，有三个参数分别为

 public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)

ClassLoader loader：用哪个类加载器去加载代理对象
Class<?>[] interfaces：动态代理类需要实现的接口
InvocationHandler h：动态代理方法在执行时，会调用h里面的invoke方法去执行。会把当前执行目标对象的方法作为参数传入

/**
*代理工厂类
*/
public class ProxyFactory{
		//维护目标对象
		private Object target;
		public ProxyFactory(Object target){
			this.target=target;
		}
		//给目标对象生成代理对象
    public Object getProxyInstance(){
			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("---before--");
                        //执行目标对象方法
                        Object returnValue = method.invoke(target, args);
                        System.out.println("---after---");
                        return returnValue;
                    }
								}
						);
		}
}

/**
 * 测试类
 */
 public class Test {
		// 目标对象
    IUserDao target = new UserDao();
    // 给目标对象，创建代理对象
    IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
    // 执行方法   
    proxy.work('9');
 }
结果
---before--
----9点开始工作！----
---after---

• 动态代理的代理对象不需要实现接口，但是目标对象需要实现接口。

Cglib代理

• JDK的动态代理需要目标对象实现接口，而Cglib能代理没有实现接口的类。它可以在运行期扩展Java类与实现Java接口，提供方法的interception（拦截）。
• Cglib包的底层是通过使用一个小而块的字节码处理框架ASM来转换字节码并生成新的类.不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉.
• Cglib动态构建子类,代理的类不能为final,目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法

/**
 * 目标对象,没有实现任何接口
 */
public class UserDao {
    public void work() {
        System.out.println("----开始工作!----");
    }
}
/**
 * Cglib子类代理工厂
 */
public class ProxyFactory implements MethodInterceptor{
		//维护目标对象
    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }
		//给目标对象创建一个代理对象
    public Object getProxyInstance(){
        //1.工具类
        Enhancer en = new Enhancer();
        //2.设置父类
        en.setSuperclass(target.getClass());
        //3.设置回调函数
        en.setCallback(this);
        //4.创建子类(代理对象)
        return en.create();

    }
		@Override
    public Object intercept(Object obj, Method method, 
    			Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("befor...");

        //执行目标对象的方法
        Object returnValue = method.invoke(target, args);

        System.out.println("after...");

        return returnValue;
    }
}
/**
 * 测试类
 */
public class Test{

    @Test
    public void test(){
        //目标对象
        UserDao target = new UserDao();
        //代理对象
        UserDao proxy = (UserDao)new ProxyFactory(target).getProxyInstance();
        proxy.work();
    }
}

在Spring的AOP中:
如果加入容器的目标对象有实现接口,用JDK代理
如果目标对象没有实现接口,用Cglib代理