动态代理

动态代理

一、反射技术

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectService {

    /**
     * 服务方法
     */
    public void sayHello(String name){
        System.out.println("hello "+name);
    }
    
    /**
     * 测试
     * @throws ClassNotFoundException 
     * @throws IllegalAccessException 
     * @throws InstantiationException 
     * @throws SecurityException 
     * @throws NoSuchMethodException 
     * @throws InvocationTargetException 
     * @throws IllegalArgumentException 
     */
    
    public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
        //通过反射创建ReflectService对象
        Object service=Class.forName(ReflectService.class.getName()).newInstance();
        //获取服务方法
        Method method=service.getClass().getMethod("sayHello", String.class);
        //反射调用方法
        method.invoke(service, "zz");
    }
    
}

　　代码通过反射技术去创建ReflectService对象，获取方法后通过反射调用。

二、JDK动态代理

JDK动态代理，是由JDK的java.lang.reflect.*包提供支持的：

1.编写服务类和接口，这是真正的服务提供者，在JDK代理中接口是必须的

2.编写代理类，提供绑定和代理方法

　　写一个接口及其实现类

　　HelloService.java

public interface HelloService {
    public void sayHello(String name);
}

　　HelloServiceImpl.java

public class HelloServiceImpl implements HelloService{

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

}

　　写一个代理类，提供真实对象的绑定和代理方法

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

public class HelloServiceProxy implements InvocationHandler{

    /**
     * 真实服务对象
     */
    private Object target;
    /**
     * 绑定委托对象并返回一个代理类
     * 
     */
    public Object bind(Object target){
        this.target=target;
        //取得代理对象
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
        //jdk代理需要提供接口
        /*
         * param1：类加载器
         * param2：接口
         * param3：this代表当前helloServiceProxy类
         */
    }
    @Override
    /**
     * 通过代理对象调用方法首先进入这个方法
     * param1：代理对象
     * param2：当前调用的方法
     * param3：方法参数
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // TODO Auto-generated method stub
        System.err.println("######我是JDK动态代理#####");
        Object result=null;
        //反射方法前调用
        System.err.println("我准备说Hello");
        //执行方法，相当于调用HelloServiceImpl类的sayHello方法
        result=method.invoke(target, args);
        //反射方法后调用
        System.err.println("我说过Hello了");
        return result;
    }
    
}

　　测试类

public class HelloServiceMain {

    public static void main(String[] args) {
        HelloServiceProxy helloHandler=new HelloServiceProxy();
        HelloService proxy=(HelloService)helloHandler.bind(new HelloServiceImpl());
        proxy.sayHello("张三");
    }
}

　　执行绑定后，在进入代理对象方法调用的时候就会到HelloServiceProxy的代理方法上（invoke方法）