java代理

1.基于jdk动态代理

①建立代理对象和真实对象的关系
②实现代理逻辑方法

待实现接口

/**
 * @author 10242026
 * @date 2019/9/20
 * @Description
 * @TODO
 */
public interface IHello {
    /**
     * sayHello
     */
    void sayHello();
}

接口的实现类(被代理类)

/**
 * @author 10242026
 * @date 2019/9/20
 * @Description
 * @TODO
 */
public class HelloImpl implements IHello {
    @Override
    public void sayHello() {
        System.out.println("这是被代理对象的方法");
    }
}

动态代理绑定和代理逻辑实现

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
 * @author 10242026
 * @date 2019/9/20
 * @Description
 * @TODO
 */
public class JdkProxyExample implements InvocationHandler {
    /**
     * 真实对象(被代理对象)
     */
    private Object target = null;
    /**
     * 利用真实对象构建代理对象
     * @param target
     * @return
     */
    public Object bind(Object target) {
        this.target = target;
        //代理类利用哪个类加载器进行类的加载    代理类实现的是哪个接口   实现InvocationHandler的类(类中的invoke函数进行被代理类方法的改写),此处该类就实现了InvocationHandler的类
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }
    /**
     * 改写被代理类的方法
     * @param proxy 代理对象(bind方法生成的对象)
     * @param method 当前调度的方法 bind生成的对象调用的方法(bind会生成一个代理类对象，然后指定调用哪个方法，这个method的值就是proxy调用的方法)
     * @param args 真实对象中被调用方法的形参
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("进入代理逻辑方法");
        System.out.println("调用真实对象之前的服务");
        //通过反射调用被代理类的方法
        Object obj = method.invoke(target, args);
        System.out.println("调用真实对象之后的服务");
        return obj;
    }
}

代理类测试

import com.zte.cn.mybatis.service.HelloImpl;
import com.zte.cn.mybatis.service.IHello;
/**
 * @author 10242026
 * @date 2019/9/20
 * @Description
 * @TODO
 */
public class TestJdkProxy {
    public static void main(String[] args) {
        HelloImpl hello = new HelloImpl();
        JdkProxyExample example = new JdkProxyExample();
        IHello proxy = (IHello) example.bind(hello);
        proxy.sayHello();
    }
}

2.基于cglib实现动态代理

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
 * @author 10242026
 * @date 2019/9/20
 * @Description
 * @TODO
 */
public class CglibProxyExample implements MethodInterceptor {
    /**
     * 生成cglib代理对象
     * @param clazz Class类 被代理类的Class
     * @return 被代理的Class的cglib代理对象
     */
    public Object getProxy(Class clazz) {
        //cglib增强类对象
        Enhancer enhancer = new Enhancer();
        //设置增强类型
        enhancer.setSuperclass(clazz);
        //定义代理逻辑对象,代理逻辑对象需实现MethodInterceptor方法,本例就是当前对象
        enhancer.setCallback(this);
        //生成并返回代理对象
        return enhancer.create();
    }
    /**
     * 代理类中被调方法的逻辑实现
     * @param o 代理对象 getProxy中的返回值
     * @param method 被调方法
     * @param objects 被调方法的形参
     * @param methodProxy 方法代理
     * @return 代理逻辑返回
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("被调真实对象前");
        Object ret = methodProxy.invokeSuper(methodProxy, objects);
        System.out.println("调用真实对象后");
        return ret;
    }
}

测试

/**
 * @author 10242026
 * @date 2019/9/20
 * @Description
 * @TODO
 */
public class TestCglibProxy {
    public static void main(String[] args) {
        CglibProxyExample example = new CglibProxyExample();
        Object obj = example.getProxy(HelloImpl.class);
        HelloImpl proxy = (HelloImpl) obj;
        proxy.sayHello();
    }
}