浅谈CGLIB动态代理和JDK动态代理 学习笔记

public interface IUserService {

    void login();
}

public class UserService implements IUserService {

    @Override
    public void login() {
        System.out.println("login success");
    }
}

public class UserDynamicProxy implements InvocationHandler {
    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("login before");
        Object result = method.invoke(target, args);
        System.out.println("login after");
        return result;
    }
}

public class DymaticProxyDemo {

    public static void main(String[] args) {
        IUserService userService = new UserService();
        UserDynamicProxy handler = new UserDynamicProxy(userService);
        IUserService serviceProxy = (IUserService) Proxy.newProxyInstance(userService.getClass().getClassLoader(),
                userService.getClass().getInterfaces(), handler);

        serviceProxy.login();
    }
}

>    /**
     * Returns an instance of a proxy class for the specified interfaces
     * that dispatches method invocations to the specified invocation
     * handler.
     *
     * <p>{@code Proxy.newProxyInstance} throws
     * {@code IllegalArgumentException} for the same reasons that
     * {@code Proxy.getProxyClass} does.
     *
     * @param   loader the class loader to define the proxy class
     * @param   interfaces the list of interfaces for the proxy class
     *          to implement
     * @param   h the invocation handler to dispatch method invocations to
     * @return  a proxy instance with the specified invocation handler of a
     *          proxy class that is defined by the specified class loader
     *          and that implements the specified interfaces

public class Dog {

    public void call() {
        System.out.println("wang wang wang");
    }
}

public class CglibProxy implements MethodInterceptor {

    @Override
    public Object intercept(Object object, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("before");
        proxy.invokeSuper(object, args);
        System.out.println("after");
        return null;
    }
}

public class Factory {

    public static Dog getInstance(CglibProxy proxy) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Dog.class);
        enhancer.setCallback(proxy);
        Dog rayDog = (Dog) enhancer.create();
        return rayDog;
    }
}

    public void setSuperclass(Class superclass) {
        if(superclass != null && superclass.isInterface()) {
            this.setInterfaces(new Class[]{superclass});
        } else if(superclass != null && superclass.equals(Object.class)) {
            this.superclass = null;
        } else {
            this.superclass = superclass;
        }

    }

    public void setCallback(Callback callback) {
        this.setCallbacks(new Callback[]{callback});
    }

    public void setCallbacks(Callback[] callbacks) {
        if(callbacks != null && callbacks.length == 0) {
            throw new IllegalArgumentException("Array cannot be empty");
        } else {
            this.callbacks = callbacks;
        }
    }

    public Object create() {
        this.classOnly = false;
        this.argumentTypes = null;
        return this.createHelper();
    }

    private Object createHelper() {
        this.preValidate();
        Object key = KEY_FACTORY.newInstance(this.superclass != null?this.superclass.getName():null, ReflectUtils.getNames(this.interfaces), this.filter == ALL_ZERO?null:new WeakCacheKey(this.filter), this.callbackTypes, this.useFactory, this.interceptDuringConstruction, this.serialVersionUID);
        this.currentKey = key;
        Object result = super.create(key);
        return result;
    }

    private void preValidate() {
        if(this.callbackTypes == null) {
            this.callbackTypes = CallbackInfo.determineTypes(this.callbacks, false);
            this.validateCallbackTypes = true;
        }

        if(this.filter == null) {
            if(this.callbackTypes.length > 1) {
                throw new IllegalStateException("Multiple callback types possible but no filter specified");
            }

            this.filter = ALL_ZERO;
        }

    }

public class CglibDemo {

    public static void main(String[] args) {
        Dog rayDog = Factory.getInstance(new CglibProxy());
        rayDog.call();
    }
}