黑马程序员-代理

最新推荐文章于 2023-04-17 13:15:24 发布

黑马_飞飞

最新推荐文章于 2023-04-17 13:15:24 发布

阅读量529

点赞数

分类专栏：黑马 java学习笔记文章标签： java 黑马程序员

本文链接：https://blog.csdn.net/u011030537/article/details/19419127

版权

java学习笔记同时被 2 个专栏收录

17 篇文章 0 订阅

订阅专栏

黑马

16 篇文章 0 订阅

订阅专栏

代理：

代理：一个角色代表另一个角色完成某些特定功能。

比如：生产商，中间商，客户这三者之间的关系

客户买产品并不直接与生产商打交道，也不用知道产品是如何产生的，客户只与中间商打交道，而中间上就可以对产品进行一些包装，提供一些售后的服务。

代理模式有三个角色：（抽象接口），代理类，实际类。

其他类通过访问代理来访问实际类。代理为实际类增加一些系统功能，例如，异常处理、日志、计算方法的运行时间、事务管理、等等

AOP

1，系统中存在交叉业务，一个交叉业务就是要切入到系统中的一个方面，如下所示：

安全事务日志

StudentService ------|----------|------------|-------------

CourseService ------|----------|------------|-------------

MiscService ------|----------|------------|-------------

2，用具体的程序代码描述交叉业务：

method1 method2 method3

{ { {

------------------------------------------------------切面

.... .... ......

------------------------------------------------------切面

} } }

3，交叉业务的编程问题即为面向方面的编程（Aspect oriented program ,简称AOP），AOP的目标就是要使交叉业务模块化。可以采用将切面代码移动到原始方法的周围，这与直接在方法中编写切面代码的运行效果是一样的，如下所示：

------------------------------------------------------切面

func1 func2 func3

{ { {

.... .... ......

} } }

------------------------------------------------------切面

使用代理技术正好可以解决这种问题，代理是实现AOP功能的核心和关键技术。

动态代理：

动态代理的引入：要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方式，将是一件非常麻烦的事情！动态代理解决了这个问题。

JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类。

JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。

CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么可以使用CGLIB库。

（CGLIB库是开源技术，不是JDK原有。现在不是不代表未来不是！）

代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置加上系统功能代码：

1.在调用目标方法之前

2.在调用目标方法之后

3.在调用目标方法前后

4.在处理目标方法异常的catch块中

分析JVM动态生成的类：

//1，创建实现了Collection接口的动态类和查看其名称，分析Proxy.getProxyClass方法的各个参数。
public static void main(String[] args) throws Exception{
		//使用Proxy类的getProxyClass方法获取代理类
		Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
		System.out.println(clazzProxy1.getName());
//2，编码列出动态类中的所有构造方法和参数签名
		System.out.println("----------begin constructors list----------");
		/*//打印格式：
		$Proxy0()
		$Proxy0(InvocationHandler,int)
		*/
		Constructor[] constructors = clazzProxy1.getConstructors();
		for(Constructor constructor : constructors){
			String name = constructor.getName();
			StringBuilder sBuilder = new StringBuilder(name);
			sBuilder.append('(');
			Class[] clazzParams = constructor.getParameterTypes();
			for(Class clazzParam : clazzParams){
				sBuilder.append(clazzParam.getName()).append(',');
			}
			if(clazzParams!=null && clazzParams.length != 0)
				sBuilder.deleteCharAt(sBuilder.length()-1);
			sBuilder.append(')');
			System.out.println(sBuilder.toString());			
		}
		//3,编码列出动态类中的所有方法和参数签名
		System.out.println("----------begin methods list----------");
		Method[] methods = clazzProxy1.getMethods();
		for(Method method : methods){
			String name = method.getName();
			StringBuilder sBuilder = new StringBuilder(name);
			sBuilder.append('(');
			Class[] clazzParams = method.getParameterTypes();
			for(Class clazzParam : clazzParams){
				sBuilder.append(clazzParam.getName()).append(',');
			}
			if(clazzParams!=null && clazzParams.length != 0)
				sBuilder.deleteCharAt(sBuilder.length()-1);
			sBuilder.append(')');
			System.out.println(sBuilder.toString());			
		}
//4,创建动态类的实例对象
//(1,用反射获得构造方法
//(2,编写一个最简单的InvocationHandler类
//(3,调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传进去


	System.out.println("----------begin create instance object----------");
		//Object obj = clazzProxy1.newInstance();报错，代理类没有无参构造方法。
		Constructor constructor = clazzProxy1.getConstructor(InvocationHandler.class);
		class MyInvocationHander1 implements InvocationHandler{

			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				// TODO Auto-generated method stub
				return null;
			}
		
		}
}

创建动态生成的类的方式：

1，Proxy.getProxyClass（ClassLoader loader, Class<?>... interfaces）得到代理类，通过反射创建实例对象。

例：

Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
Constructor constructor = clazzProxy1.getConstructor(InvocationHandler.class);
Collection proxy = (Collection)constructor.newInstance(new InvocationHandler(){

			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				return null;
			}
			
		});

2，Proxy.newProxyInstance（ClassLoader loader, Class<?>[] interfaces, InvocationHandler h）直接创建代理实例。

例：

Collection proxy = Proxy.newProxyInstance(
				Collection.class.getClassLoader()，
				Collection.class,
				new InvocationHandler(){
				
					public Object invoke(Object proxy, Method method, Object[] args)
							throws Throwable {
						long beginTime = System.currentTimeMillis();
						Object retVal = method.invoke(target, args);
						long endTime = System.currentTimeMillis();
						System.out.println(method.getName() + " running time of " + (endTime - beginTime));
						return retVal;				
					}
				}
				);

InvocationHandler接口中定义的invoke方法接受的三个参数的含义：

Client程序调用objProxy.add(“abc”)方法时，涉及三要素：objProxy对象、add方法、“abc”参数，invoke方法接受的就是这三个元素。

Class Proxy$ {

add(Object object) {

return handler.invoke(Object proxy, Method method, Object[] args);

}

注意：调用代理对象的从Object类继承的hashCode, equals, 或toString这几个方法时，代理对象将调用请求转发给InvocationHandler对象，对于其他方法，则不转发调用请求。

让动态生成的类成为目标类的代理：

怎样将目标类传进去？

直接在InvocationHandler实现类中创建目标类的实例对象，可以看运行效果和加入日志代码，但没有实际意义。

为InvocationHandler实现类注入目标类的实例对象，不能采用匿名内部类的形式了。

让匿名的InvocationHandler实现类访问外面方法中的目标类实例对象的final类型的引用变量。

将创建代理的过程改为一种更优雅的方式，eclipse重构出一个getProxy方法绑定接收目标同时返回代理对象，让调用者更懒惰，更方便，调用者甚至不用接触任何代理的API。

将系统功能代码模块化，即将切面代码也改为通过参数形式提供，怎样把要执行的系统功能代码以参数形式提供？

把要执行的代码装到一个对象的某个方法里，然后把这个对象作为参数传递，接收者只要调用这个对象的方法，即等于执行了外界提供的代码！

为bind方法增加一个Advice参数。

public interface Advice {
	void beforeMethod(Method method);
	void afterMethod(Method method);
}
public class MyAdvice implements Advice {
	long beginTime = 0;
	public void afterMethod(Method method) {
		// TODO Auto-generated method stub
				long endTime = System.currentTimeMillis();
		System.out.println(method.getName() + " running time of " + (endTime - beginTime));

	}

	public void beforeMethod(Method method) {
		// TODO Auto-generated method stub
		beginTime = System.currentTimeMillis();
	}
}
public class ProxyTest {
	private static Object getProxy(final Object target,final Advice advice) {
		Object proxy3 = Proxy.newProxyInstance(
				target.getClass().getClassLoader(),
				target.getClass().getInterfaces(),
				new InvocationHandler(){
					public Object invoke(Object proxy, Method method, Object[] args)
							throws Throwable {						
						advice.beforeMethod(method);
						Object retVal = method.invoke(target, args);
						advice.afterMethod(method);
						return retVal;						
						
					}
				}
				);
		return proxy3;
	}
}

实现AOP功能的封装与配置:

工厂类BeanFactory负责创建目标类或代理类的实例对象，并通过配置文件实现切换。其getBean方法根据参数字符串返回一个相应的实例对象，如果参数字符串在配置文件中对应的类名不是ProxyFactoryBean，则直接返回该类的实例对象，否则，返回该类实例对象的getProxy方法返回的对象。

BeanFactory的构造方法接收代表配置文件的输入流对象，配置文件格式如下：

#xxx=java.util.ArrayList

xxx=day2_14.aopframework.ProxyFactoryBean

xxx.target=java.util.ArrayList

xxx.advice=day2_14.MyAdvice

ProxyFacotryBean充当封装生成动态代理的工厂，需要为工厂类提供哪些配置参数信息？

目标

通知

编写客户端应用：

编写实现Advice接口的类和在配置文件中进行配置

调用BeanFactory获取对象

BeanFactory类：

public class BeanFactory {
	Properties props = new Properties();
	public BeanFactory(InputStream ips){
		try {
			props.load(ips);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	public Object getBean(String name){
		String className = props.getProperty(name);
		Object bean = null;
		try {
			Class clazz = Class.forName(className);
			bean = clazz.newInstance();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} 
		if(bean instanceof ProxyFactoryBean){
			Object proxy = null;
			ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean)bean;
			try {
				Advice advice = (Advice)Class.forName(props.getProperty(name + ".advice")).newInstance();
				Object target = Class.forName(props.getProperty(name + ".target")).newInstance();
				proxyFactoryBean.setAdvice(advice);
				proxyFactoryBean.setTarget(target);
				proxy = proxyFactoryBean.getProxy();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			return proxy;
		}
		return bean;
	}
}

ProxyFactoryBean类：

public class ProxyFactoryBean {

	private Advice advice;
	private Object target;
	
	public Advice getAdvice() {
		return advice;
	}

	public void setAdvice(Advice advice) {
		this.advice = advice;
	}

	public Object getTarget() {
		return target;
	}

	public void setTarget(Object target) {
		this.target = target;
	}

	public Object getProxy() {
		// TODO Auto-generated method stub
		Object proxy3 = Proxy.newProxyInstance(
				target.getClass().getClassLoader(),
				/*new Class[]{Collection.class},*/
				target.getClass().getInterfaces(),
				new InvocationHandler(){
				
					public Object invoke(Object proxy, Method method, Object[] args)
							throws Throwable {						
						advice.beforeMethod(method);
						Object retVal = method.invoke(target, args);
						advice.afterMethod(method);
						return retVal;						
						
					}
				}
				);
		return proxy3;
	}

}

测试程序类：

public class AopFrameworkTest {
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		InputStream ips = AopFrameworkTest.class.getResourceAsStream("config.properties");
		Object bean = new BeanFactory(ips).getBean("xxx");
		System.out.println(bean.getClass().getName());
		((Collection)bean).clear();
	}          
}

黑马_飞飞

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员-代理

代理：代理：一个角色代表另一个角色完成某些特定功能。比如：生产商，中间商，客户这三者之间的关系客户买产品并不直接与生产商打交道，也不用知道产品是如何产生的，客户只与中间商打交道，而中间上就可以对产品进行一些包装，提供一些售后的服务。代理模式有三个角色：（抽象接口），代理类，实际类。其他类通过访问代理来访问实际类。代理为实际类增加一些系统功能，例如，异常处理、日志、计算方
复制链接

扫一扫