java动态代理的jdk和cjlib的简单实例

Java动态代理是一种在运行时动态生成代理对象的技术。它可以代理某个接口或者类，使得代理对象可以拦截到对被代理对象的方法调用，并在调用前后进行一些额外的操作，比如记录日志、权限控制等。

Java提供了两种动态代理的实现方式：基于JDK的动态代理和基于CGLIB的动态代理。其中，基于JDK的动态代理只能代理实现了接口的类，而基于CGLIB的动态代理则可以代理任何类，包括没有实现接口的类。

下面是一个基于JDK的动态代理的简单实例：

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

interface Hello {
    void sayHello();
}

class HelloImpl implements Hello {
    public void sayHello() {
        System.out.println("Hello, world!");
    }
}

class MyInvocationHandler implements InvocationHandler {
    private Object target;

    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before invoking " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("After invoking " + method.getName());
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        Hello hello = new HelloImpl();
        InvocationHandler handler = new MyInvocationHandler(hello);
        Hello proxy = (Hello) Proxy.newProxyInstance(
                Main.class.getClassLoader(),
                new Class[] { Hello.class },
                handler);
        proxy.sayHello();
    }
}

这里定义了一个接口`Hello`和它的实现类`HelloImpl`。`MyInvocationHandler`是一个实现了`InvocationHandler`接口的类，它负责拦截并处理对`Hello`接口的方法调用。`Main`类中创建了一个`HelloImpl`对象和一个`MyInvocationHandler`对象，然后调用`Proxy.newProxyInstance`方法构造一个代理对象。通过代理对象调用`sayHello`方法时，`MyInvocationHandler`会先打印一行`Before invoking sayHello`，然后再调用`HelloImpl`对象的`sayHello`方法，最后打印一行`After invoking sayHello`。

下面是一个基于CGLIB的动态代理的简单实例：

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

class Hello {
    public void sayHello() {
        System.out.println("Hello, world!");
    }
}

class MyMethodInterceptor implements MethodInterceptor {
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Before invoking " + method.getName());
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("After invoking " + method.getName());
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Hello.class);
        enhancer.setCallback(new MyMethodInterceptor());
        Hello hello = (Hello) enhancer.create();
        hello.sayHello();
    }
}

这里定义了一个类`Hello`和它的一个方法`sayHello`。`MyMethodInterceptor`是一个实现了`MethodInterceptor`接口的类，它负责拦截并处理对`Hello`类的方法调用。`Main`类中创建了一个`Enhancer`对象，通过`setSuperclass`方法指定要代理的类，通过`setCallback`方法指定拦截器，然后调用`create`方法构造一个代理对象。通过代理对象调用`sayHello`方法时，`MyMethodInterceptor`会先打印一行`Before invoking sayHello`，然后再调用`Hello`对象的`sayHello`方法，最后打印一行`After invoking sayHello`。