java代理

简单代理模式，是动态代理的理论基础。常见使用在代理模式

class SysOut {
    public void sout() {
        System.out.println(111);
    }
}

class SysOutProxy {
    private final SysOut sysOut;

    SysOutProxy(SysOut sysOut) {
        this.sysOut = sysOut;
    }

    public void enhanceSout() {
        System.out.println("start");
        sysOut.sout();
        System.out.println("end");
    }

    public static void main(String[] args) {
        SysOut sout = new SysOut();
        SysOutProxy sysOutProxy = new SysOutProxy(sout);
        sysOutProxy.enhanceSout();
    }
}

使用反射完成代理。需要有顶层接口才能使用。

interface SysOutService {
    void sout();
}

class SysOut implements SysOutService {
    public void sout() {
        System.out.println(111);
    }
}

public class MyInvocationHandler implements InvocationHandler {
    // 每次生成动态代理类对象时,实现了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("start..");
        //下面invoke()方法是以反射的方式来创建对象，第一个参数是要创建的对象，第二个是构成方法的参数，由第二个参数来决定创建对象使用哪个构造方法
        Object result = method.invoke(target, args);
        System.out.println("end..");
        return result;
    }

    public static void main(String[] args) {
        // 被代理对象
        SysOutService sout = new SysOut();
        MyInvocationHandler invocationHandlerImpl = new MyInvocationHandler(sout);

        //类加载器
        ClassLoader loader = sout.getClass().getClassLoader();
        Class[] interfaces = sout.getClass().getInterfaces();

        // 主要装载器、一组接口及调用处理动态代理实例
        SysOutService proxyInstance = (SysOutService) Proxy.newProxyInstance(loader, interfaces, invocationHandlerImpl);
        proxyInstance.sout();
    }
}

也是使用反射完成代理，可以直接代理类（jdk动态代理不行），使用字节码技术，不能对 final类进行继承。（需要导入jar包）

Cglib代理：

public class CglibProxy implements MethodInterceptor {
    private Object targetObject;

    // 这里的目标类型为Object，则可以接受任意一种参数作为被代理类，实现了动态代理
    public Object getInstance(Object target) {
        // 设置需要创建子类的类
        this.targetObject = target;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(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("start");
        Object invoke = methodProxy.invoke(targetObject, objects);
        System.out.println("end");
        return invoke;
    }

    public static void main(String[] args) {
        CglibProxy cglib = new CglibProxy();
        SysOut instance = (SysOut) cglib.getInstance(new SysOut());
        instance.sout();
    }
}