java之代理模式

最新推荐文章于 2022-01-06 14:38:05 发布
最新推荐文章于 2022-01-06 14:38:05 发布
阅读量159 收藏
点赞数
分类专栏： java 设计模式 文章标签： java 设计模式 代理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30325833/article/details/90312951
版权

代理模式

代理

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

静态代理

特点

由程序员创建或由特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。

示例

dao接口类

public interface UserDao {

	public void setUser();
	
	public void getUser();
}

接口实现类

public class UserDaoImpl implements UserDao {

	@Override
	public void setUser() {
		
		System.out.println("设置user");
	}

	@Override
	public void getUser() {
		
		System.out.println("获取user");
	}

}

静态代理类

public class MyStaticProxy implements UserDao {

	private UserDao userDao;
	public MyStaticProxy(UserDao userDao) {
		this.userDao = userDao;
	}
	@Override
	public void setUser() {
		System.out.println("开启事务");
		userDao.setUser();
		System.out.println("提交事务");
	}

	@Override
	public void getUser() {
		System.out.println("开启事务");
		userDao.getUser();
		System.out.println("提交事务");
	}

}

测试类

public class MyStaticProxyTest {

	public static void main(String[] args) {
		UserDaoImpl userDaoImpl = new UserDaoImpl();
		
		UserDao myStaticProxy = new MyStaticProxy(userDaoImpl);
		
		myStaticProxy.setUser();
		
		myStaticProxy.getUser();
	}
}

分析

  1. 跟适配器，装饰器模式类似，在代理类（MyStaticProxy）中传入被代理类对象（UserDaoImpl），然后实现被代理类接口（UserDao），然后在实现的接口方法中调用被代理类的相应方法，当然在调用方法的前后可以做一些其他操作（类似上面的事务操作），从而保证在原有逻辑不变的情况下插入逻辑；

动态代理

特点

动态代理类：在程序运行时，运用反射机制动态创建而成。

JDK自带Proxy

JDK的动态代理必须具备四个条件：1、目标接口 2、目标类 3、拦截器 4、代理类
目标接口跟目标类沿用静态代理的UserDao跟UserDaoImpl

示例

事务类

public class Transaction {

	public void beginTransaction(){
		System.out.println("开启事务");
	}
	
	public void endTransaction(){
		System.out.println("关闭事务");
	}
	
	public void rollback(){
		System.out.println("回滚事务");
	}
}

拦截类

public class MyProxyHandler implements InvocationHandler {

	private Transaction transaction;
	private UserDao userDao;
	public MyProxyHandler(Transaction tansTransaction,UserDao userDao) {
		this.transaction = tansTransaction;
		this.userDao = userDao;
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		Object object = null;
		try {
			transaction.beginTransaction();
			object = method.invoke(this.userDao, args);
			transaction.endTransaction();
		} catch (Exception e) {
			transaction.rollback();
			e.printStackTrace();
		}
		return object;
	}
}

jdk自带代理测试类

public class MyJdkProxyTest {

	public static void main(String[] args) {
		UserDao userDao = new UserDaoImpl();
		MyProxyHandler myProxyHandler = new MyProxyHandler(new Transaction(), userDao);
		userDao = (UserDao)Proxy.newProxyInstance(userDao.getClass().getClassLoader(), 
				userDao.getClass().getInterfaces(), myProxyHandler);
		userDao.setUser();
		userDao.getUser();
	}
}

分析

  1. Proxy类利用newProxyInstance方法传入被目标类接口跟类加载器构造一个代理对象，然后代理对象调用目标接口中的方法时会通过MyProxyHandler 对象的invoke方法调用目标实现类的相应方法，而MyProxyHandler 中的invoke方法只需要我们自己编写即可，可以理解成策略模式，依赖倒置原则；

cglib动态代理

jar包下载

  1. cglib下载
  2. asm下载

示例

设置拦截器

public class MyInterceptor implements MethodInterceptor {
	
	private UserDao userDao;
	private Transaction transaction;
	public MyInterceptor(UserDao userDao,Transaction transaction) {
		this.userDao = userDao;
		this.transaction = transaction;
	}
	
	public Object create(){
		Enhancer enhancer = new Enhancer();//该类用于生成代理对象
		
		enhancer.setCallback(this);// 参数为拦截器 
		enhancer.setSuperclass(userDao.getClass());// 设置父类
		return enhancer.create();// 创建代理对象
	}
	
    /**
     * @param obj 目标对象代理类的实例
     * @param method 代理实例上 调用父类方法的Method实例
     * @param args 传入到代理实例上方法参数值的对象数组
     * @param methodProxy 使用它调用父类的方法
     * @return
     * @throws Throwable
     */
	public Object intercept(Object obj, Method method, Object[] args,
			MethodProxy proxy) throws Throwable {
		Object object = null;
		try {
			this.transaction.beginTransaction();
			object = method.invoke(userDao,args);
			this.transaction.endTransaction();
		} catch (Exception e) {
			this.transaction.rollback();
			e.printStackTrace();
		}
		return object;
	}
	
	
}

测试类

public class MyCglibProxyTest {

	public static void main(String[] args) {
		UserDaoImpl userDao = new UserDaoImpl();
		Transaction transaction = new Transaction();
		
		MyInterceptor myInterceptor = new MyInterceptor(userDao, transaction);
		userDao = (UserDaoImpl)myInterceptor.create();
		userDao.setUser();
		userDao.getUser();
	}
}

可以在方法中调用生成字节码的方法查看生成的代理类class字节码文件

    /**
     * 把代理类的字节码写到硬盘上 
     * @param path 保存路径 
     */
    public static void writeProxyClassToHardDisk(String path) {
        // 第一种方法
    	//System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true"); 
 
        // 第二种方法  
 
        // 获取代理类的字节码  
        byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy1", UserDaoImpl.class.getInterfaces());
 
        FileOutputStream out = null;
 
        try {
            out = new FileOutputStream(path);
            out.write(classFile);
            out.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

最终生成的代理类class

public final class $Proxy1 extends Proxy
  implements UserDao
{
  private static Method m1;
  private static Method m4;
  private static Method m3;
  private static Method m0;
  private static Method m2;

  public $Proxy1(InvocationHandler paramInvocationHandler)
    throws 
  {
    super(paramInvocationHandler);
  }

  public final boolean equals(Object paramObject)
    throws 
  {
    try
    {
      return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

  public final void getUser()
    throws 
  {
    try
    {
      this.h.invoke(this, m4, null);
      return;
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

  public final void setUser()
    throws 
  {
    try
    {
      this.h.invoke(this, m3, null);
      return;
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

  public final int hashCode()
    throws 
  {
    try
    {
      return ((Integer)this.h.invoke(this, m0, null)).intValue();
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

  public final String toString()
    throws 
  {
    try
    {
      return (String)this.h.invoke(this, m2, null);
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

  static
  {
    try
    {
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m4 = Class.forName("com.huzd.study.proxy.staticproxy.UserDao").getMethod("getUser", new Class[0]);
      m3 = Class.forName("com.huzd.study.proxy.staticproxy.UserDao").getMethod("setUser", new Class[0]);
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      return;
    }
    catch (NoSuchMethodException localNoSuchMethodException)
    {
      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
      throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
    }
  }
}

区别

  1. JDK：
    1. 目标类和代理类实现了共同的接口
    2. 拦截器必须实现InvocationHandler接口,而这个接口中invoke方法体的内容就是代理对象方法体的内容
  2. CGLIB：
    1. 目标类 是代理类的父类
    2. 拦截器必须实现MethodInterceptor接口,而接口中的intercept方法就是代理类的方法体,使用字节码增强机制创建代理对象的.

springAop代理机制

  1. 若目标对象实现了若干接口，spring使用JDK的java.lang.reflect.Proxy类代理。
    1. 优点：因为有接口，所以使系统更加松耦合
    2. 缺点：为每一个目标类创建接口
  2. 若目标对象没有实现任何接口，spring使用CGLIB库生成目标对象的子类。
    1. 优点：因为代理类与目标类是继承关系，所以不需要有接口的存在。
    2. 缺点：因为没有使用接口，所以系统的耦合性没有使用JDK的动态代理好。
$dreamer
关注
专栏目录
java代理模式
02-06
java代理模式
JAVA 代理模式（Proxy）
热门推荐
jianghuxiaoxiami的专栏
11-28 3万+
1.代理模式代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。代理模式一般涉及到的角色有：抽象角色：声明真实对象和代理对象的共同接口；代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代
Java代理模式
管子（zero）的杂乱空间
02-28 315
1. 简介 代理模式(Proxy Pattern)是GoF 23种Java常用设计模式之一。代理模式的定义：Provide a surrogate or placeholder for another object to controlaccess to it(为其他对象提供一种代理以控制对这个对象的访问)。使用代理模式创建代理对象，让代理对象控制目标对象的访问(目标对象可以是远程的对象、创...
JAVA 代理模式
zybb166的博客
01-06 160
代理模式介绍 概念 代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象，这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。代理对象一般称为代理方，目标对象一般称为被代理方,后文也会这样称呼。 实际的栗子 我们可以想象一个场景：在我们买二手房的时候，可能并不是直接去联系房屋卖家，直接给房屋卖家钱，而是通过一个中间商，（我爱我家）这样的机构购买，但是实际上我们给钱最终还是给的卖家。这样抽象出来也就是代理模式的作用，通过代理对象
java的代理模式
qq_40820916的博客
10-29 1917
java的三种代理模式简介静态代理jdk动态代理cglib实现动态代理 简介 代理模式的定义： 为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。 以上为百度百科对代理模式的定义；通俗一点讲，java中的代理模式就是你想要访问一个目标对象，但是不直接访问它，而是通过它的代理对象访问（因为代理对象可以对目标对象做增强操作），这就是java的代理模式。示意图如下： 在java中，有三种代理模式，分别为静态代
Java设计模式——代理设计模式（静态代理和动态代理）
04-15
在Java编程中，设计模式是一种解决常见问题的模板或最佳实践，它可以帮助开发者编写更加灵活、可维护和可扩展的代码。代理设计模式是其中的一种，它的主要作用是在...在实际开发中，应根据项目需求选择合适的代理模式。
JAVA设计模式之代理模式实例
07-09
在本实例中，我们将深入探讨Java中的代理模式及其应用。 代理模式的核心思想是为一个对象创建一个代理对象，这个代理对象在客户端和目标对象之间起到中介的作用。它可以控制目标对象的访问，也可以在调用目标对象的...
Java Spring代理模式AOP-IOC分析
最新发布
10-01
Java Spring代理模式AOP-IOC分析 一、代理模式概述 在软件设计中，代理模式是一种常用的设计模式。它可以在不修改原始代码的情况下，扩展或修改原始对象的行为。代理模式可以分为静态代理和动态代理两种。静态代理...
JAVA代理模式
帅哥威的博客
09-03 656
JAVA代理模式 通过本文将学习到 前言 前面一段时间辛辛苦苦把创建型的设计模式给抄了一遍，但是这远远不够！不过这也还好，毕竟我现在的理解都是基础需要不断的练习才能更好的理解！从今天开始进行结构型的设计模式学习。代理模式，就像是海淘代购之类的，一般就是客户买不到，或者不知道怎么买，所以同过代理（海外代购）来买。设计模式的代理模式与此作用相似！ 1、代理模式的概念 代理模式：给某一个对象...
java 代理模式
一只疯狂的蜗牛
01-03 188
代理分为静态代理和动态代理 1.静态代理 2.动态代理 动态代理是通过Proxy.newProxyInstance来创建代理方法，会调用invoke方法，不用为每个代理方法创建一个代理类
Java 代理模式
zhangyupeng的博客
05-13 109
1、基本概念 官方术语：代理模式就是找一个代理类替原对象进行操作。 意义：如果在使用的时候需要对原有的方法进行改进，可以采用一个代理类调用原有方法，并对生产结果进行控制，这种就是代理模式。 与装饰模式的区别：装饰模式需要把原对象（需要被装饰的对象）传给装饰对象的构造器，而代理模式是在代理类里创建了一个被代理的对象。 代理模式关注一个对象动态添加方法，代理模式关注于控制对对象的访问。 2...
给女朋友讲解什么是代理模式
weixin_34245749的博客
05-07 388
前言 只有光头才能变强 回顾前面： ThreadLocal就是这么简单 多线程三分钟就可以入个门了！ 多线程基础必要知识点！看了学习多线程事半功倍 Java锁机制了解一下 AQS简简单单过一遍 Lock锁子类了解一下 线程池你真不来了解一下吗？ 多线程之死锁就是这么简单 多线程就先告一段落了，昨天写完多线程，本来打算是看IO的知识点的，后来看了一下IO的几种模型，又翻了一下《Java编程思...
设计模式--代理模式
追梦者
11-16 177
代理模式:给某一对象提供代理对象,并由代理对象控制具体对象的引用. 代理,指的就是一个角色代表另一个角色采取行动,就象生活中,一个红酒厂商,是不会直接把红酒零售客户的,都是通过代理来完成他的销售业务的.而客户,也不用为了喝红酒而到处找工厂,他只要找到厂商在当地的代理就行了,具体红酒工厂在那里,客户不用关心,代理会帮他处理. [size=large][color=red]代理模式涉及的角...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值