Granda's Blog

JAVA：动态代理

发表于 | 分类于

动态代理的创建

  • Proxy来创建动态代理类，是为一个或多个接口动态生成的实现类，每个动态代理实例创建时，需要传入一个InvocationHandler对象，动态代理对象调用任何方法，都会替换成执行InvocationHandler对象的invoke()方法
  • Proxy提供两个方法创建动态代理实例:
    1. static Class<?> getProxyClass(ClassLoader loader,Class<?>… interfaces):创建动态代理类所对应的Class对象，通过该代理类来创建对象时，需要传入InvocationHandler对象
    2. static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h):直接创建动态代理对象

  • 创建Dog接口

    1
    2
    3
    4
    public interface Dog {
    	void eat();
    	void run();
    }

  • 创建Dog的实现类BigDog

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    public class BigDog implements Dog{
    	@Override
    	public void eat() {
    		System.out.println("This is eat method");
    	}
    	@Override
    	public void run() {
    		System.out.println("This is run method");
    	}
    }

  • 创建DogUtil类，提供额外处理的方法

    1
    2
    3
    4
    5
    6
    7
    8
    public class DogUtil {
    	public void method1(){
    		System.out.println("The first method");
    	}
    	public void method2(){
    		System.out.println("The second method");
    	}
    }

  • 创建InvokationHandler的实现类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    public class MyInvokationHandler implements InvocationHandler {
    	//需要被动态代理代理的对象
        private Object target;
    	public void setTarget(Object target){
    		this.target = target;
    	}
        //执行动态代理的所有方法，都会替换成下面方法
    	@Override
    	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    		DogUtil dogUtil = new DogUtil();
    		dogUtil.method1();
            //通过被代理的原对象执行原方法
    		Object result = method.invoke(target , args);
    		dogUtil.method2();
    		return result;
    	}
    }

  • 创建动态代理的类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public class MyProxyFactory {
    	public static Object getProxy(Object target){
    		//创建一个MyInvokationHandler对象
            MyInvokationHandler handler = new MyInvokationHandler();
            //传入要代理的对象
    		handler.setTarget(target);
            //创建并返回动态代理对象
    		return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), handler);
        }
    }

  • 测试类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public class Test {
    	public static void main(String[] args){
            //创建原始对象
    		Dog target = new BigDog();
            //对原来的target方法创建代理对象
    		Dog dog = (Dog)MyProxyFactory.getProxy(target);
    		dog.eat();
    		dog.run();
    	}
    }

  • 执行结果

    1
    2
    3
    4
    5
    6
    The first method
    This is eat method
    The second method
    The first method
    This is run method
    The second method