Java-动态代理

 

JDK

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

public class MyInvocationHandler implements InvocationHandler {

    private Object target;//目标对象
    public MyInvocationHandler(Object target) {
        this.target = target;
    }
    public MyInvocationHandler() {}
    
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("invoke方法");
        //获取目标方法
        Object result = method.invoke(target, args);
        
        if(result != null) {
            String str = (String)result;
            result  = str.toUpperCase();//修改目标方法返回值结果
        }
        return result;
    }
}

 public interface SomeService { 2 String doSmoe(); 3 } 

public class SomeServiceImpl implements SomeService {

    public String doSmoe() {
        System.out.println("目标方法");
        return "ok";
    }
}

import java.lang.reflect.Proxy;

public class Test {

    public static void main(String[] args) {
        
        SomeService target = new SomeServiceImpl();
        
        //动态代理对象
        MyInvocationHandler h = new MyInvocationHandler(target);
        
        SomeService proxy = (SomeService)Proxy.newProxyInstance(target.getClass().getClassLoader(), 
                target.getClass().getInterfaces(), h);
        
        String doSmoe = proxy.doSmoe();
        System.out.println(doSmoe);
    }
}

CGLIB

        <!-- cglib动态代理 -->
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.2.6</version>
        </dependency>

import java.lang.reflect.Method;

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

public class MyInterceptor implements MethodInterceptor {
    
    private Object target;
    public MyInterceptor() {
        super();
    }
    public MyInterceptor(Object target) {
        super();
        this.target = target;
    }

    public Object intercept(Object arg0, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("执行目标方法之前");
        Object result = method.invoke(target, args);
        System.out.println("执行目标方法之后");
        if(result != null) {
            result = "hello" + result;
        }
        return result;
    }
}

import net.sf.cglib.proxy.Enhancer;

public class ProxyFactory {

    public Object createProxy(Object target) {
        //定义增强器对象
        Enhancer en  = new Enhancer();
        //指定父类
        en.setSuperclass(target.getClass());
        //指定调用处理器对象
        MyInterceptor h = new MyInterceptor(target);
        en.setCallback(h);
        return en.create();//创建cglib对象
    }
}

public class TargetClass {

    public String doSome() {
        System.out.println("目标类中的目标方法");
        return " world";
    }
}

public class Test {
    public static void main(String[] args) {
        TargetClass target = new TargetClass();
        
        ProxyFactory factory = new ProxyFactory();
        TargetClass proxy = (TargetClass)factory.createProxy(target);
        
        System.out.println("proxy:" + proxy.getClass().getName());
        
        String doSome = proxy.doSome();
        System.out.println(doSome);
    }
}