代理模式之静态代理,JDK动态代理和cglib动态代理

代理模式,顾名思义,就是通过代理去完成某些功能。比如,你需要购买火车票,不想跑那么远到火车站售票窗口买,可以去附近的火车票代售点买,或者到携程等第三方网站买。这个时候,我们就把火车站叫做目标对象或者委托对象,也可以叫被代理对象,而火车票代售点和携程就叫做代理对象。

一、静态代理

静态代理是最简单的代理模式。需要定义一个接口,然后委托类和代理类分别实现这个接口

//待实现的接口
public interface UserManager {
    public void getName(String name);
    public void getId(int id);
}
//委托类
public class UserManagerImpl implements UserManager {

    @Override
    public void getName(String name) {
        System.out.println("UserManagerImpl.getName:" + name);
    }

    @Override
    public void getId(int id) {
        System.out.println("UserManagerImpl.getId:" + id);
    }
}
//代理类
public class UserManagerProxy implements UserManager {

    UserManager userManager;

    public UserManagerProxy(UserManager userManager) {
        this.userManager = userManager;
    }

    @Override
    public void getName(String name) {
        System.out.println("before getName");
        userManager.getName(name);
        System.out.println("after getName");
    }

    @Override
    public void getId(int id) {
        userManager.getId(id);
    }

    public static void main(String[] args) {
        UserManagerProxy proxy = new UserManagerProxy(new UserManagerImpl());
        proxy.getName("zhangsan");
    }
}
//before getName
//UserManagerImpl.getName:zhangsan
//after getName

可以看到,在编译成class之前,就已经确定了委托类UserManagerImpl和代理类UserManagerProxy。因此,才叫静态代理。这样虽然定义比较方便,实现也简单,但是有一个弊端。当接口再新加一个方法时,委托类和代理类都需要同步地去实现方法,因此维护起来比较麻烦。而动态代理解决了这个问题。

二、JDK动态代理

动态代理分为JDK动态代理和cglib动态代理。动态是指,代理类是通过反射等机制动态生成的,委托类和代理类的关系在运行时才确定。他们的主要区别就是,JDK动态代理需要实现接口,而cglib是通过继承来实现的,不需要定义接口。

JDK动态代理,需要定义一个类去实现InvocationHandler接口

public class LogHandler implements InvocationHandler {

    private Object targetObj;

    public Object newProxyObject(Object targetObj){
        this.targetObj = targetObj;
        return Proxy.newProxyInstance(
                targetObj.getClass().getClassLoader(), //获取委托类的类加载器
                targetObj.getClass().getInterfaces(), //获取委托类实现的所有接口
                this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object ret;

        try {
            System.out.println("before method");
            ret = method.invoke(targetObj, args);
            System.out.println("after method");
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            System.out.println("error");
            throw e;
        }

        return ret;
    }
}

public class TestProxy {
    public static void main(String[] args) {
        LogHandler logHandler = new LogHandler();
        UserManager o = (UserManager)logHandler.newProxyObject(new UserManagerImpl());
        o.getName("ls");
        o.getId(2);
    }
}
/**
运行结果如下:
before method
UserManagerImpl.getName:ls
after method
before method
UserManagerImpl.getId:2
after method
*/

JDK动态代理其实是在运行时动态生成了一个代理类去实现接口,只是隐藏了这个过程,我们不知道而已。

class $JDKProxy implements UserManager{}

需要注意的是,实现JDK动态代理的一个前提就是,需要定义一个接口,然后委托类去实现这个接口。那如果我不想定义接口,只定义一个委托类能不能实现呢?这就需要用到cglib代理了。(因为cglib是通过继承方式)

三、cglib动态代理

需要定义一个类实现MethodInterceptor接口(注意,这个类可不是代理类,也不是委托类哦)。

//委托类,不需要实现接口
public class CgTarget {
    public void getContent(){
        System.out.println("cglib被代理类getContent方法");
    }
}

public class CglibProxy implements MethodInterceptor {

    private Object target;

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("cglib开始");
        Object invoke = method.invoke(target, objects);
        System.out.println("cglib结束");
        return invoke;
    }
	//代理方法
    public Object getCglibProxy(Object target){
        this.target = target;
        Enhancer enhancer = new Enhancer();
        //设置增强类的父类,即被代理类
        enhancer.setSuperclass(target.getClass());
        //设置回调函数
        enhancer.setCallback(this);
        //返回创建的代理类
        return enhancer.create();
    }
}

public class TestCglib {
    public static void main(String[] args) {
        CglibProxy cglibProxy = new CglibProxy();
        CgTarget o = (CgTarget)cglibProxy.getCglibProxy(new CgTarget());
        o.getContent();
    }
}
/**
打印结果如下:
cglib开始
cglib被代理类getContent方法
cglib结束
*/

可以看到,cglib动态代理是通过Enhancer类的create方法创建了代理类。其实,其内部是通过继承委托类来动态生成代理类的。它隐藏了以下过程

class $cglibProxy extends CgTarget{}

因此,委托类不能定义成final类型的,因为final修饰的类是不能被继承的。

了解spring AOP的同学应该知道,AOP是面向切面编程,在管理事物的时候会用到。其实,AOP就是通过动态代理来实现的,具体是用的JDK动态代理还是cglib动态代理,感兴趣的小伙伴可以继续深入研究哦。

posted @ 2019-12-27 20:24  烟雨星空  阅读(...)  评论(...编辑  收藏