java基础加强_代理

最新推荐文章于 2016-11-01 22:08:59 发布

大盼

最新推荐文章于 2016-11-01 22:08:59 发布

阅读量485

点赞数

分类专栏： Java 文章标签：代理黑马程序员

本文链接：https://blog.csdn.net/a254830856/article/details/27231451

版权

Java 专栏收录该内容

33 篇文章 0 订阅

订阅专栏

代理的概念：

要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如，异常处理、日志、计算方法的运行时间、事务管理、等等，这种做法就是代理

如何使用代理：
编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能的代码。

代理的作用
如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是使用目标类、还是代理类，这样以后很容易切换，譬如，想要日志功能时就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段时间后，又想去掉系统功能也很容易。

代理架构图

面向方面编程AOP（Aspect oriented program）

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

安全事务日志

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

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

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

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

method1 method2 method3

{ { {

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

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

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

} } }

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

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

func1 func2 func3

{ { {

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

} } }

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

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

动态代理

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

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

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

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

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

1.在调用目标方法之前

2.在调用目标方法之后

3.在调用目标方法前后

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

编写一个程序，实现获取动态代理类的构造方法和普通方法的名称列表

步骤：

创建实现了Collection接口的动态类和查看其名称，分析Proxy.getProxyClass方法的各个参数。

编码列出动态类中的所有构造方法和参数签名

编码列出动态类中的所有方法和参数签名

代码示例：

package cn.itheima.Proxy;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Collection;

public class ProxyTest
{

	public static void main(String[] args)
	{
		// 创建动态代理类
		Class clazzProxy = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class); 
		//获得动态代理类的类名
		System.out.println(clazzProxy.getName()); 
		//获取动态代理类中的构造函数
		System.out.println("--------begin constructors list-------"); 

		Constructor[] constructors = clazzProxy.getConstructors(); 

		for (Constructor constructor : constructors) 
		{ 

			String name = constructor.getName(); 
			//将名称存入字符串容器StringBuilder中
			StringBuilder sb = new StringBuilder(name); 
	
			sb.append("("); 
	
			Class[] clazzParams = constructor.getParameterTypes(); 

			for(Class clazzParam : clazzParams) 
			{ 
	
				sb.append(clazzParam.getName()).append(","); 
	
			} 
			//排除无构造函数的情况
			if (clazzParams !=null && clazzParams.length != 0) 
			{ 
	
				sb.deleteCharAt(sb.length()-1); 
	
			} 
	
			sb.append(")"); 
	
			System.out.println(sb.toString()); 

		} 

		  //获取动态代理类中的所有方法和接收参数的类型。 
		System.out.println("--------begin method list-------"); 

		Method [] methods = clazzProxy.getMethods(); 

		for (Method method : methods) 
		{ 

			String name = method.getName(); 
	
			StringBuilder sb =new StringBuilder(name); 
	
			sb.append("("); 
	
			Class[] clazzParams = method.getParameterTypes(); 
	
			for (Class clazzParam : clazzParams) 
			{ 
	
				sb.append(clazzParam.getName()).append(","); 
	
			} 
	
			if(clazzParams !=null && clazzParams.length != 0) 
			{ 
	
				sb.deleteCharAt(sb.length()-1); 
	
			} 
	
			sb.append(")"); 
	
			System.out.println(sb.toString()); 
		}	

	}

}

输出结果：

$Proxy0
--------begin constructors list-------
$Proxy0(java.lang.reflect.InvocationHandler) //唯一的一个构造函数（有一个参数）
--------begin method list-------
hashCode() //以下是Collection中的方法
equals(java.lang.Object)
toString()
add(java.lang.Object)
contains(java.lang.Object)
isEmpty()
size()
toArray()
toArray([Ljava.lang.Object;)
addAll(java.util.Collection)
iterator()
remove(java.lang.Object)
clear()
containsAll(java.util.Collection)
removeAll(java.util.Collection)
retainAll(java.util.Collection)
isProxyClass(java.lang.Class)//以下是java.lang.reflect.Proxy类中的方法
getProxyClass(java.lang.ClassLoader,[Ljava.lang.Class;)
getInvocationHandler(java.lang.Object)
newProxyInstance(java.lang.ClassLoader,[Ljava.lang.Class;,java.lang.reflect.InvocationHandler)
getClass()
notify()
notifyAll()
wait()
wait(long,int)
wait(long)

注意：

动态生成的类的名字$Proxy0，最后的序号从0开始。依次递增。

创建动态类的实例对象
用反射获得构造方法
编写一个最简单的InvocationHandler类
调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传进去
打印创建的对象和调用对象的没有返回值的方法和getClass方法，演示调用其他有返回值的方法报告了异常。
将创建动态类的实例对象的代理改成匿名内部类的形式编写，锻炼大家习惯匿名内部类。

package cn.itheima.Proxy;

import java.lang.reflect.InvocationHandler; 

import java.lang.reflect.Method; 

import java.lang.reflect.Proxy; 

import java.util.Collection; 

public class ProxyTest2 
{ 
	public static void main(String[] args)throws Exception 
	{ 
		//使用动态代理类创建一份字节码文件
		Class<?> clazzProxy =
				Proxy.getProxyClass(Collection.class.getClassLoader(),  Collection.class); 
		//创建动态代理类的对象
		Collection<?> proxy = 	
				(Collection<?>)clazzProxy.getConstructor(InvocationHandler.class).newInstance( 	
			new InvocationHandler()
			{ 
				@Override 		
				public Object invoke(Object proxy,Method method,Object[] args) throws Throwable
				{ 
					return null; 
				} 
		}); 
		
		System.out.println(proxy); //结果：null 
	
		 
		proxy.clear(); //执行没有返回值的方法，不会报告异常
		
		//proxy.size(); //执行有返回值的方法，会报告异常 	因为newInstance()是一个空参数的方法
		
	} 
}

总结：

让jvm创建动态类及其实例对象的三个方面：

1.生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知；

2.产生的类字节码必须有一个关联的类加载器对象；

3.生成的类中的方法的代码是怎样的，也得由我们提供。把我们的代码写在一个约定好了接口对象的方法中，把对象传给它，它调用我的方法，即相当于插入了我的代码。提供执行代码的对象就是那个InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的。在上面的InvocationHandler对象的invoke方法中加一点代码，就可以看到这些代码被调用运行了。

用Proxy.newInstance方法创建出代理对象

代码示例：

package cn.itheima.Proxy;

import java.lang.reflect.InvocationHandler; 

import java.lang.reflect.Method; 

import java.lang.reflect.Proxy; 

import java.util.ArrayList; 

import java.util.Collection; 

public class ProxyTest3 
{ 

@SuppressWarnings("unchecked") 

	public static void main(String[] args) throws Exception 
	{ 
		@SuppressWarnings("rawtypes") 
		//使用newProxyInstance()方法创建代理类的实例对象
		Collection proxy = (Collection)Proxy.newProxyInstance( 
				
		Collection.class.getClassLoader(), new Class[] {Collection.class },
		
		new InvocationHandler() 
		{ 
			ArrayList<String> target =new ArrayList<String>(); //此段代码放在放在成员变量位置上，可返回正确结果
			@Override 
			public Object invoke(Object proxy,Method method,Object[] args) throws Throwable 
			{ 
			
				long startTime = System.currentTimeMillis(); 
				
				Object retVal = method.invoke(target, args); 
				
				long endTime =System.currentTimeMillis(); 
				
				System.out.println(method.getName() +" running time is " 
				
				+ (endTime - startTime)); 
				
				return retVal; 
			
			} 
		
		});
		
		proxy.add("zhangsan"); 
		
		proxy.add("lisi"); 
		
		proxy.add("wangwu"); 
		
		System.out.println(proxy.size()); //结果：3 	
	}

}

注意：

如果作为target的ArrayList对象放置在invoke方法内部定义，那么每次调用代理的某个方法，都会调用invoke 方法，这样作为target的ArrayList对象每次都会被创建，这样就导致最后调用proxy.size()的时候，结果为0。将ArrayList定义在成员位置，就不会出现这种情况，最终结果也就变为了3.

分析动态生成的类的内部代码

动态生成的类实现了Collection接口（可以实现若干接口），生成的类有Collection接口中的所有方法和一个如下接受InvocationHandler参数的构造方法。

构造方法接受一个InvocationHandler对象，接受对象了要干什么用呢？该方法内部的代码会是怎样的呢？
$Proxy0 implements Collection
{
	InvocationHandler handler;
	public $Proxy0(InvocationHandler handler)
	{
		this.handler = handler;
	}
}
实现Collection接口的动态类中的各个方法的代码又是怎样的呢？InvocationHandler接口中定义的invoke方法接受的三个参数又是什么意思？

图解说明如下：

分析先前打印动态类的实例对象时，结果为什么会是null呢？

因为实际输出的是proxy.toString()，代理对象将调用请求转发给invocationHandler对象，执行如下代码：

String toString()

{
return handler.invoke(this,this.getClass().getMethod("toString"),null);
}

返回值是null,所以输出null；

调用有基本类型返回值的方法时为什么会出现NullPointerException异常？

例如：size()方法。代理类调用size()方法，将目标方法传入invoke()方法中，就是如下代码：

int size()

{
return handler.invoke(this,this.getClass().getMethod("size"),null);
}

返回值类型是null，转换为int型数据就会报空指针异常

分析为什么动态类的实例对象的getClass()方法返回了正确结果呢？

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

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

动态代理的工作原理图：

怎样将目标类传进去？

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

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

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

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

代码示例：

package cn.itheima.Proxy;

import java.lang.reflect.Method;

public interface Advice
{
	void beforeMethod();
	void afterMethod(Object target,Method method);
}

package cn.itheima.Proxy;

import java.lang.reflect.Method;

public class MyAdvice implements Advice
{
	private long startTime; 
	@Override
	public void beforeMethod()
	{
		startTime = System.currentTimeMillis(); 
	}

	@Override
	public void afterMethod(Object target, Method method)
	{
		long endTime =System.currentTimeMillis(); 
		System.out.println("The target is "+target.getClass().getName()+"target调用方法："+method.getName() +" running time is " + (endTime - startTime)); 
	}

}

package cn.itheima.Proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collection;

public class ProxyTest4 
{
	@SuppressWarnings("unchecked") 
	public static void main(String[] args) throws Exception 
	{
			ArrayList<String> target =new ArrayList<String>(); 
			
			Collection<String> proxy = (Collection<String>) getProxy(target,new MyAdvice());
			
			proxy.add("zhangsan"); 
			
			proxy.add("lisi"); 
			
			proxy.add("wangwu"); 
			
			System.out.println(proxy.size()); 	
	}

	private static Object getProxy(final Object target,final Advice advice)
	{
		Object proxy = Proxy.newProxyInstance( 
				
		Collection.class.getClassLoader(), 
		
		new Class[] {Collection.class },
		
		new InvocationHandler() 
		{ 
			
			@Override 
			public Object invoke(Object proxy,Method method,Object[] args) throws Throwable 
			{ 
			
				advice.beforeMethod();
				
				Object retVal = method.invoke(target, args); 
				
				advice.afterMethod(target, method);
				
				return retVal; 
			
			} 
		
		});
		return proxy;
	}

}

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

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

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

实现AOP功能的封装与配置

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

BeanFactory的构造方法接收代表配置文件的输入流对象，配置文件格式如下：
#xxx=java.util.ArrayList
xxx=cn.itcast.ProxyFactoryBean
xxx.target=java.util.ArrayList
xxx.advice=cn.itcast.MyAdvice

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

编写客户端应用：
编写实现Advice接口的类和在配置文件中进行配置
调用BeanFactory获取对象

代码示例：

package cn.itheima.Proxy;

import java.lang.reflect.Method;

public interface Advice
{
	void beforeMethod();
	void afterMethod(Object target,Method method);
}

package cn.itheima.Proxy;

import java.lang.reflect.Method;

public class MyAdvice implements Advice
{
	private long startTime; 
	@Override
	public void beforeMethod()
	{
		startTime = System.currentTimeMillis(); 
	}

	@Override
	public void afterMethod(Object target, Method method)
	{
		long endTime =System.currentTimeMillis(); 
		System.out.println("The target is "+target.getClass().getName()+"target调用方法："+method.getName() +" running time is " + (endTime - startTime)); 
	}

}

package cn.itheima.Proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyFactoryBean
{
	private Advice advice;
	private Object target;
	ProxyFactoryBean(){}
	public Object getTarget()
	{
		return target;
	}
	public void setTarget(Object target)
	{
		this.target = target;
	}
	public Advice getAdvice()
	{
		return advice;
	}
	public void setAdvice(Advice advice)
	{
		this.advice = advice;
	}
	public Object getProxy()
	{
		Object proxy = Proxy.newProxyInstance( 
				
				target.getClass().getClassLoader(),  

				target.getClass().getInterfaces(),  

				new InvocationHandler() { 

				@Override 

				public Object invoke(Object proxy,Method method,Object[] args) throws Throwable { 

				advice.beforeMethod(); 

				Object retVal = method.invoke(target, args);  

				advice.afterMethod(target ,method); 

				return retVal; 

			} 
		
		});
		return proxy;
	}
}

package cn.itheima.Proxy;

import java.io.InputStream;
import java.util.Properties;

public class BeanFactory
{
	
	private Properties prop = new Properties(); 
	public BeanFactory(InputStream ips) 
	{ 
		try 
		{ 
			prop.load(ips); 
		} 
		catch (Exception e) 
		{ 
		e.printStackTrace(); 
		} 
	} 
	public Object getBean(String name) 
	{ 
		String className = prop.getProperty(name); 
		Object bean =null; 
		try 
		{ 
			Class<?> clazz =Class.forName(className); 
			bean = clazz.newInstance(); 
		} 
		catch (Exception e) 
		{ 
			e.printStackTrace(); 
		} 
		if(bean instanceof ProxyFactoryBean) 
		{ 
		ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean) bean; 
		Object proxy = null; 
		try 
		{ 
			Advice advice = (Advice)Class.forName( 
			prop.getProperty(name + ".advice")).newInstance(); 
			Object target =Class.forName( 
			prop.getProperty(name + ".target")).newInstance(); 
			proxyFactoryBean.setAdvice(advice); 
			proxyFactoryBean.setTarget(target); 
			proxy = proxyFactoryBean.getProxy(); 
		} 
		catch (Exception e) 
		{ 
			e.printStackTrace(); 
		} 
		return proxy;
	} 
	return bean; 
	} 

}

package cn.itheima.Proxy;

import java.io.InputStream;

public class AopFramworkTest
{

	public static void main(String[] args)
	{
		// TODO Auto-generated method stub
		InputStream ips = AopFramworkTest.class.getResourceAsStream("config.properties"); 

		Object Proxy = new BeanFactory(ips).getBean("proxy"); 

		System.out.println(Proxy.getClass().getName()); 


	}

}

config.properties配置文件内容：

当proxy的值为java.util.ArrayList时，程序输出结果：java.util.ArrayList

当proxy的值为cn.itheima.ProxyFactoryBean时，程序输出结果：$Proxy0

大盼

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java基础加强_代理

要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如，异常处理、日志、计算方法的运行时间、事务管理、等等，你准备如何做？编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能的代码。（参看下页的原理图）如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是使用目标类、还是代理类，这样以后很容易切
复制链接

扫一扫

专栏目录