java代理模式

最新推荐文章于 2024-07-21 10:53:18 发布

还能坚持

最新推荐文章于 2024-07-21 10:53:18 发布

阅读量137

点赞数 1

分类专栏： Spring 文章标签： java mvc

本文链接：https://blog.csdn.net/qq_35091353/article/details/119929819

版权

Spring 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

1、代理

1.1 什么是代理

某 p2p 老板突然携款带着小姨子跑路了，可怜了下面一堆的程序员背负一身房贷，上有老下有小，程序员只能被迫去申请劳动仲裁，劳动局就会为其指派一位代理律师全权负责程序员的仲裁事宜（PS:p2p 跑路仲裁拿回工资的可能性非常低，没让你把工资退回就算好的了）。那这里面就是使用了代理模式，因为在劳动仲裁这个活动中，代理律师会全权代理程序员。
又比如：房东要将房子出售，于是到房地产中介公司找一个中介（代理），由他来帮房东完成销售房屋，签订合同、网签、贷款过户等等事宜。

1.2 Java中的代理模式

代理模式是常用的 java 设计模式

代理类主要负责为目标对象（目标类、委托类）预处理消息、过滤消息、把消息转发给目标对象，以及事后处理消息等，代理模式这提供了对目标对象另外的访问方式，即通过代理对象访问目标对象。这样做的好处是：可以在目标对象的基础上，增强额外的功能操作，即扩展目标对象的功能。
代理类与目标对象之间通常会存在关联关系，一个代理类的对象与一个目标类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用目标类对象的相关方法，来提供特定的服务。
这里使用到编程中的一个思想：不要随意去修改别人已经写好的代码或者方法，如果需要修改，可以通过代理的方式来扩展该方法。

代理模式的关键点：
- 代理模式本质上的目的是为了增强现有代码的功能。
- 代理对象与目标对象。代理对象是对目标对象的扩展，并会调用目标对象。
- 用户只关心接口功能，而不在乎谁提供了功能
- 服务真正实现者是上图的目标对象，但是它不与用户直接接触，而是通过代理对象
- 代理又可以分为静态代理和动态代理两种，静态代理和动态代理的区别是在于要不要开发者自己定义代理类
  - 静态代理，代理类需要自己编写代码。
  - 动态代理，代理类通过 Proxy.newInstance() 方法生成。

2、两种代理模式

2.1 静态代理

静态代理在使用时需要定义接口或者父类，目标对象与代理对象一起实现相同的接口或者是继承相同父类，通过调用相同的方法来调用目标对象的方法。下面举个例子（模拟保存动作）来解释：

定义一个保存动作的接口IUserDao
目标对象实现这个接口IUserDao中的方法save()
如果使用静态代理方式，就需要在代理对象(UserDaoProxy.java)中也实现IUserDao接口
调用的时候通过调用代理对象的方法来调用目标对象.

2.1.1 接口：IUserDao.java

/**
 * 接口
 */
public interface IUserDao { 
	void save();
}

2.1.2 目标对象：UserDao.java

/**
 * 目标对象实现接口
 */
public class UserDao implements IUserDao { 
	public void save() { 
		System.out.println("----已经保存数据!----"); 
	}
}

2.1.3 代理对象：UserDaoProxy.java

/**
 * 代理对象,静态代理
 */
public class UserDaoProxy implements IUserDao{ 
	//接收保存目标对象 
	private IUserDao target; 
	public UserDaoProxy(IUserDao target){ 
		this.target=target; 
	} 
	public void save() { 
		System.out.println("开始事务..."); 
		target.save();//执行目标对象的方法 
		System.out.println("提交事务..."); 
	}
}

2.1.4 测试类:App.java

/**
 * 测试类
 */
public class App { 
	public static void main(String[] args) { 
		//目标对象 
		UserDao target = new UserDao(); 
		//代理对象,把目标对象传给代理对象,建立代理关系 
		UserDaoProxy proxy = new UserDaoProxy(target); 
		proxy.save();//执行的是代理的方法 
	}
}

2.1.5 静态代理总结

可以做到在不修改目标对象的功能前提下，对目标功能扩展。
缺点：因为代理对象需要与目标对象实现一样的接口，所以会有很多代理类。同时，一旦接口增加方法，目标对象与代理对象都要维护。

2.2 动态代理

动态代理有以下特点：

代理对象不需要实现接口
- JDK 动态代理：目标对象需要实现接口
- cglib 动态代理：目标对象不需要实现接口
代理对象的生成是利用JDK的API，动态地在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)

2.2.1 JDK 动态代理

① JDK中生成代理对象的API

代理类所在包为 java.lang.reflect.Proxy。JDK实现代理只需要使用newProxyInstance方法，但是该方法需要接收三个参数，完整的写法是:

static Object newProxyInstance(ClassLoader loader, Class[] interfaces,InvocationHandler h )

注意该方法是Proxy类中的静态方法，且接收的三个参数依次为:

ClassLoader loader：指定当前目标对象使用类加载器，获取加载器的方法是固定的
Class[] interfaces：目标对象实现的接口的类型，使用泛型方式确认类型
InvocationHandler h：事件处理，执行目标对象的方法时，会触发事件处理器的方法，会把当前执行目标对象的方法作为参数传入

② 接口：IUserDao.java

/**
 * 接口
 */
public interface IUserDao { 
	void save();
}

③ 目标对象：UserDao

/**
 * 目标对象实现接口
 */
public class UserDao implements IUserDao { 
	public void save() { 
		System.out.println("----已经保存数据!----"); 
	}
}

④ 代理工厂类：ProxyFactory.java

将代理类写在这里

/**
 * 创建动态代理对象
 * 动态代理不需要实现接口,但是需要指定接口类型
 */
public class ProxyFactory{ 
	//维护一个目标对象 
	private Object target; 
	public ProxyFactory(Object target){ 
		this.target=target; 
	} 
	//给目标对象生成代理对象 
	public Object getProxyInstance(){ 
		return Proxy.newProxyInstance(target.getClass().getClassLoader(),
					target.getClass().getInterfaces(), 
					new InvocationHandler() { 
						@Override 
						public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
							System.out.println("开始事务2"); 
							//执行目标对象方法 
							Object returnValue = method.invoke(target, args); 
							System.out.println("提交事务2"); 
							return returnValue; 
						} 
					} 
		); 
	}

}

⑤ 测试类：App.java

在测试类(需要使用到代理的代码)中先建立目标对象和代理对象的联系，然后代用代理对象的中同名方法

/**
 * 测试类
 */
public class App { 
	public static void main(String[] args) { 
		// 目标对象 
		IUserDao target = new UserDao(); 

		// 【原始的类型 class cn.itcast.b_dynamic.UserDao】 
		System.out.println(target.getClass()); 

		// 给目标对象，创建代理对象 
		IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();

		 // class $Proxy0   内存中动态生成的代理对象 
		System.out.println(proxy.getClass()); 

		// 执行代理对象的方法
		proxy.save(); 
	}
}

⑥ 总结

代理对象不需要实现接口，但是目标对象一定要实现接口，否则不能用动态代理
JDK动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口，如果想代理没有实现接口的类，就可以使用Cglib实现

2.2.2 Cglib动态代理

上面的静态代理和动态代理模式都要求目标对象实现一个接口，但是有时候目标对象只是一个单独的对象，并没有实现任何的接口，这个时候就可以使用Cglib代理，也叫作子类代理，它是在内存中构建一个子类对象（目标对象的子类对象）从而实现对目标对象功能的扩展.

① Cglib包

Cglib是一个强大的高性能的代码生成包，它可以在运行期扩展java类与实现java接口。它被许多AOP的框架使用，例如Spring AOP和synaop，为他们提供方法的interception(拦截)
Cglib包的底层是通过使用一个小而快的字节码处理框架ASM来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。
Cglib子类代理实现方法:
- 需要引入cglib的jar文件,但是Spring的核心包中已经包括了Cglib功能,所以直接引入spring-core-3.2.5.jar即可
- 引入功能包后，就可以在内存中动态构建子类
- 目标对象不能为final，否则报错
- 目标对象的方法如果为final/static，那么就不会被拦截，即不会执行目标对象额外的业务方法。

② 没有接口

③ 目标对象：UserDao.java

/**
 * 目标对象,没有实现任何接口
 */
public class UserDao { 
	public void save() { 
		System.out.println("----已经保存数据!----"); 
	}
}

④ Cglib代理工厂：ProxyFactory.java

/**
 * Cglib子类代理工厂
 * 对UserDao在内存中动态构建一个子类对象
 */
public class ProxyFactory implements MethodInterceptor{ 
	//维护目标对象 
	private Object target; 
	public ProxyFactory(Object target) { 
		this.target = target; 
	} 

	//给目标对象创建一个代理对象 
	public Object getProxyInstance(){ 
		//1.工具类 
		Enhancer en = new Enhancer(); 
		//2.设置父类 
		en.setSuperclass(target.getClass()); 
		//3.设置回调函数 
		en.setCallback(this); 
		//4.创建子类(代理对象) 
		return en.create(); 
	} 

	@Override 
	public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { 
		System.out.println("开始事务..."); 
		//执行目标对象的方法 
		Object returnValue = method.invoke(target, args); 
		System.out.println("提交事务..."); 
		return returnValue; 
	}
}

⑤ 测试类：App.java

/**
 * 测试类
 */
public class App { 
	@Test 
	public void test(){ 
	//目标对象 
	UserDao target = new UserDao(); 
	
	//代理对象 UserDao 
	proxy = (UserDao)new ProxyFactory(target).getProxyInstance(); 
	
	//执行代理对象的方法 
	proxy.save(); }
}