静态代理和动态代理

设计模式中的代理模式理解。代理模式又分为动态代理和静态代理。今天就来入门一下 这两种代理的区别。

首先 来说说 为什么要用代理模式呢。在我们日常程序开发中 经常会遇到这样的需求，要求改变某一个执行方法的逻辑，实际情况中  经常见到的 比如  在执行某个方法的时候  先来 查看执行此方法的权限。

通常的方法  一开始 我们也许会直接改变方法体  在里面进行硬代码植入，这样就改变了原来的实现代码，如果此方法在程序种用到很多 势必造成大量的修改，也会改变 原有的测试准确性。在加上设计模式的OCP(开闭原则)  这也是不可行的。

 

public interface UserManager {
	
	/**
	 * 添加
	 */
	public void add();
	
	/**
	 * 查询
	 * @return
	 */
	public int selectById();

	/**
	 * 删除
	 */
	public void del();
	
}

 

public class UserManagerIml implements UserManager {

	@Override
	public void add() {
		// TODO Auto-generated method stub
		System.out.println("添加");

	}

	@Override
	public int selectById() {
		// TODO Auto-generated method stub
		System.out.println("查询");
		return 2;
	}

	@Override
	public void del() {
		// TODO Auto-generated method stub
		System.out.println("删除");

	}

 以上是接口和实现类的代码。

 

突然老板 哪天说  我要在这些方法执行前 加一些特殊的处理，以checkMethod()  方法为例

 

public void checkMethod(){
		System.out.println("--------security----------");
	}

 

难道我们要在每个方法调用前都要加上此方法吗，那是一个什么样的工作量呢？就算加上了，后期老板又说 不需要呢？ 我们继续注释掉？ 这个时候  就出现了我们常说的代理模式，首先来看静态代理的处理方法。

依然创建一个类  来实现 UserManager 接口。

 

静态代理：

 

public class StaticProxyTest implements UserManager {
	
	private UserManager um;
	
	public StaticProxyTest(UserManager um){
		
		this.um = um;
	}

	@Override
	public void add() {
		
		checkMethod();
		um.add();
		
	}

	@Override
	public int selectById() {
		
		checkMethod();
		return um.selectById();
	}

	@Override
	public void del() {

		checkMethod();
		um.del();
	}
	
	//切点
	public void checkMethod(){
		System.out.println("--------security----------");
	}
	

}

  实现代理功能的类，实现的方法也只是代理功能，并非真正的调用 最终实现方法。虽然此方法避免了  在程序各个地方 进行粘贴checkMethod方法，但是在 这个代理类中 还是重复了粘贴，并且此代理类 只代理了UserManager 一个类。拓展性 依然有局限。

 

 

动态代理：

 

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

public class SecurityHandler implements InvocationHandler {
	
	private Object targetObject;
	
	//创建代理
	public Object createProxyObject(Object object){
	
		 this.targetObject = object;
		
		return Proxy.newProxyInstance(object.getClass().getClassLoader(),
								object.getClass().getInterfaces(), this);
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		// TODO Auto-generated method stub
		
		//切点
		checkMethod();
		
		return method.invoke(targetObject, args);
		
	}

	
	public void checkMethod(){
		System.out.println("--------security----------");
	}
}

 动态代理  运用了几个 java jdk中常用的一些基础知识。在实现createProxyObject创建代理方法的时候 我们要实现一个代理Proxy.newProxyInstance创建代理，传入要代理类对象的装载器，接口方法，以及实现InvocationHandler接口的方法类，并返回代理类。代理类创建成功时  在执行中运用反射 Method调用 invoke()方法  传递参数。

 

 

public class Client {
	
	public static void main(String[] args) {
		SecurityHandler sh = new SecurityHandler();
		UserManager um =  (UserManager)sh.createProxyObject(new UserManagerIml());
		um.add();
	}

}

 

 

执行打印：

--------security----------

 

添加

 

在以前常用的 一些 系统中  一些权限的处理和实现 就是动态代理实现。还有spring 最重要的特性aop也是动态代理原理。