java中的动态代理

反射

反射是动态代理的基础，通过反射，我们可以动态的实例化对象，下面是反射的一个简单实例

public class ReflectDemo {

    public void sayHello(String name){
        System.out.println("hello " + name);
    }

    public static void main(String[] args) throws Exception {
        // 通过反射创建对象
        Object service = Class.forName(ReflectDemo.class.getName()).newInstance();
        // 获取服务方法————sayHello
        Method method = service.getClass().getMethod("sayHello", String.class);
        // 反射调用方法
        method.invoke(service, "zhangsan");
    }
}

运行如上代码，得到输出如下

 JDK动态代理

使用JDK的动态代理我们需要完成两个步骤

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

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

下面是一个简单实例

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

// 接口实现类
class HelloServiceImpl implements HelloService {

    @Override
    public void sayHello(String name) {
        System.out.println("hello " + name);
    }
}

public class JDKProxy implements InvocationHandler {

    // 真实服务对象
    private Object target;

    // 绑定委托对象并返回一个代理类
    public Object bind(Object target) {
        this.target = target;
        // 取得代理对象
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), this);
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("#######我是JDK动态代理###########");
        Object result = null;
        // 反射方法前调用
        System.out.println("我准备说hello");
        result = method.invoke(target, args);
        System.out.println("我说过hello了");
        return result;
    }

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

运行上述实例可以得到如下结果

 CGLIB动态代理

使用CGLIB进行动态代理需要带入两个jar包

https://mvnrepository.com/artifact/org.ow2.asm/asm

https://mvnrepository.com/artifact/cglib/cglib

并且使用CGLIB进行动态代理不需要写接口，一个简单的示例如下

// 接口实现类
class HelloServiceCGLIB {

    public void sayHello(String name) {
        System.out.println("hello " + name);
    }
}

public class CGLIBProxy implements MethodInterceptor {
    private Object target;

    // 创建代理对象
    public Object getInstance(Object target){
        this.target = target;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(this.target.getClass());
        // 回调方法
        enhancer.setCallback(this);
        // 创建代理对象
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("########我是CGLIB动态代理##########");
        // 反射方法前调用
        System.out.println("我准备说hello");
        Object resultObj = methodProxy.invokeSuper(o, objects);
        // 反射方法后调用
        System.out.println("我说过hello了");
        return resultObj;
    }

    public static void main(String[] args) throws ClassNotFoundException {
        CGLIBProxy proxy = new CGLIBProxy();
        HelloServiceCGLIB service = (HelloServiceCGLIB) proxy.getInstance(new HelloServiceCGLIB());
        service.sayHello("张三");
    }
}

运行上述代码可以得到如下结果