51dev.com IT技术开发者社区

51dev.com 技术开发者社区

设计模式-代理模式

代码星球阅读(15)2020-05-23 收藏0次评论

分类:

  代理模式通常来说有三种类型,分别是静态代理、JDK动态代理、Cglib代理

组成:   抽象角色:通过接口或抽象类声明真实角色实现的业务方法。   代理角色:实现抽象角色,是真实角色的代理,通过真实角色的业务逻辑方法来实现抽象方法,并可以附加自己的操作。   真实角色:实现抽象角色,定义真实角色所要实现的业务逻辑,供代理角色调用。

代理模式主要功能:

  为其他对象提供一种代理以控制对这个对象的访问。在某些情况下,一个对象不适合或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用。

简单来说就是屏蔽掉用户的直接操作对象,提供一个第三方api来完成操作。

 

静态代理DEMO:

  接口-抽象类:

public interface IUserDao {
    void save();
}

  实现类:

public class UserDao implements IUserDao {
    @Override
    public void save() {
        System.out.println("数据插入到数据库!");
    }

}

  代理类:

public class DaoProxy implements IUserDao{

    private IUserDao userDao;

    public DaoProxy(IUserDao userDao) {
        this.userDao=userDao;
    }


    @Override
    public void save() {
        System.out.println("开启事物");
        userDao.save();
        System.out.println("关闭事物");
    }
}

  测试:

public class MainTest {
    public static void main(String[] args){

        DaoProxy proxy= new DaoProxy(new UserDao());
        proxy.save();
    }
}
//打印数据
  开启事物
  数据插入到数据库!
  关闭事物

  这是静态代理,可以在不修改目标对象代码的情况下,对目标进行扩展。

  但是静态代理维护起来比较麻烦,如果在接口中增加方法,实现类与代理类同时需要维护,

  并且静态代理基本都是作用于类已知的状态下,目标类是已知才可以使用静态代理,如果目标类很多的话,很多时候就要写很多代理类,这就比较麻烦。

JDK的动态代理:

  先来看一下需要用到的类,接上一章反射用到的类

  java.lang.reflect.Proxy //Proxy 提供用于创建动态代理类和实例的静态方法,它还是由这些方法创建的所有动态代理类的超类。

 

  看一下这个类的API,有这么一个方法,使用这个方法可以返回代理类的实例;

 

  java.lang.reflect.InvocationHandler //看一下这个接口的api介绍

  

  实现这个类为我们具体执行方法的处理器类。

在接静态代理的基础上,去除掉针对每个目标类的代理类,建立一个类工厂

  工厂类:

public class ProxyFactory {

    //维护一个目标对象
    private Object target;

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

    //给目标对象生成代理对象
    public Object getProxyInstance() {
        Object proxy = null;
        Class classObj=  target.getClass(); //动态代理里面反射是必须的
        proxy= Proxy.newProxyInstance(classObj.getClassLoader(),//获取类加载器
                classObj.getInterfaces(),
                new InsertHandler(target)//根据传入的对象创建处理器类
        );
        return proxy;
    }
}

  处理器类:

public class InsertHandler implements InvocationHandler {

    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("开始事物!");
        Object invoke = method.invoke(target, args);
        System.out.println("提交事物!");
        return invoke;
    }
}

  测试:

public class MainTest {
    public static void main(String[] args){
        IUserDao target = new UserDao();
        IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
        proxy.save();//执行这个方法的时候实际上是去执行了代理类中的invoke方法
        System.out.println("---------分割线-----------");
        proxy.delete();
    }
}

//打印
  开始事物!
  数据插入到数据库!
  提交事物!
  ---------分割线-----------
  开始事物!
  数据库删除数据!
  提交事物!

  使用jdk的动态代理还是很方便的,不过有个前提条件,就是目标对象一定要实现接口。

 Cglib动态代理:

  看一下介绍:

  CGLIB是一个强大的,高性能,高质量的Code生成类库,它可以在运行期扩展Java类与实现Java接口。

  CGLIB是一个强大的高性能的代码生成包。它广泛的被许多AOP的框架使用,例如Spring AOP和dynaop,为他们提供方法的interception(拦截)。最流行的OR Mapping 工具hibernate也使用CGLIB来代理单端single-ended(多对一和一对一)关联(对集合的延迟抓取,是采用其他机制实现的)。EasyMock和jMock是通过使用模仿(mock)对象 来测试java代码的包。它们都通过使用CGLIB来为那些没有接口的类创建模仿(mock)对象。   CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM,来转换字节码并生成新的类。(摘自百度百科)      我没有在网上找到它的api或者官方文档,只是一个开源项目。   而且单独的使用CGLIB的话需要引用其jar包,不过因为我是在web中写的,在spring-core包含着CGLIB的包,就不贴怎么加jar包了。      注意:   要代理的方法不能为final fina方法无法执行代理操作,同时static方法 也无法被代理,static方法是属于类的,不是对象的。      DEMO:   修改目标类,无接口或者有接口。   
public class UserDao {
    public void save() {
        System.out.println("数据插入到数据库!");
    }

    public void delete() {
        System.out.println("数据库删除数据!");
    }
    public static void update() {
        System.out.println("修改数据库数据!");
    }
    public final void finalMethod() {
        System.out.println("final方法!");
    }

}

  代理工厂类:

  

public class ProxyFactory implements MethodInterceptor {


    private Object target; //维护一个目标对象

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

    /**
     * 给目标对象创建一个代理对象
     * @return
     */
    public Object getProxyInstance() {
        Enhancer en = new Enhancer();
        en.setSuperclass(target.getClass());
        en.setCallback(this);
        return en.create();

    }
    /**
     * 用于目标方法
     * @return
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("开始事务");
        Object invoke = method.invoke(target, objects);
        System.out.println("提交事务");
        return invoke;
    }
}

  测试:

public class MainTest {
    public static void main(String[] args) {
        UserDao userDao = new UserDao();
        UserDao proxy = (UserDao) new ProxyFactory(userDao).getProxyInstance();
        proxy.save();
        System.out.println("--------分割线---------");
        proxy.delete();
        System.out.println("--------分割线---------");
        proxy.finalMethod();

    }
}

//打印
  开始事务
  数据插入到数据库!
  提交事务
  --------分割线---------
  开始事务
  数据库删除数据!
  提交事务
  --------分割线---------
  final方法!

 

     像spring-mybatis中事物控制,就是使用的动态代理,类似的aop编程,默认是有接口使用jdk动态代理,没有接口则使用的CGLIB,不过可以更改其默认强制使用CGLIB.                              

 

 

 

 

 

 

 

    

 

以上就是设计模式-代理模式的全部内容。