黑马程序员 Java高新技术代理总结-CSDN博客

本文链接：https://blog.csdn.net/gbc499590301/article/details/8600567

------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------

Java中的代理
如果要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如，异常处理、日志、计算方法的运行时间、等等，
就可以编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能的代码。
如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中可以配置使用目标类还是代理类，这样，
以后可以很方便的切换，增加系统功能很容易，以后运行一段时间后，又想去掉系统功能也很容易。

静态代理

class X
{
	void sayHello(){
		System.out.println(hello,itcast);
	}
}
XProxy
{
	void sayHello(){
		starttime
		X.sayHello();
		endtime
	}
}

AOP

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

安全事务日志

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块中

分析JVM动态生成的类

创建实现了Collection接口的动态类和查看其名称，分析Proxy.getProxyClass方法的各个参数。
编码列出动态类中的所有构造方法和参数列表
编码列出动态类中的所有方法和参数列表

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

总结思考：让jvm创建动态类及其实例对象，需要给它提供哪些信息?
三个方面：
1.生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知；
2.产生的类字节码必须有个一个关联的类加载器对象；
3.生成的类中的方法的代码是怎样的，也得由我们提供。把我们的代码写在一个约定好了接口对象的方法中，
把对象传给它，它调用我的方法，即相当于插入了我的代码。提供执行代码的对象就是那个InvocationHandler对象，
它是在创建动态类的实例对象的构造方法时传递进去的。在上面的InvocationHandler对象的invoke方法中加一点代码，
就可以看到这些代码被调用运行了。

用Proxy.newInstance方法直接一步就创建出代理对象。

package cn.itcast.day3;
import java.lang.reflect.Constructor;
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 ProxyTest {


	public static void main(String[] args) throws Exception {
		//创建实现了Collection接口的动态类
		Class clazzProxy1 = Proxy.getProxyClass(
				Collection.class.getClassLoader(),Collection.class);
			//动态类的名称为$Proxy0
			System.out.println(clazzProxy1.getName());	
			
		System.out.println("---------begin constructors list---------");
		//编码列出动态类中的所有构造方法和参数列表	
		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+",");		
			}
			if(clazzParams.length!=0){
			sBuilder.deleteCharAt(sBuilder.length()-1);
			}
			sBuilder.append(')');
			
			System.out.println(sBuilder);
		}		
		
		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+",");			
			}
			if(clazzParams.length!=0){
			sBuilder.deleteCharAt(sBuilder.length()-1);
			}
			sBuilder.append(')');
			
			System.out.println(sBuilder);
		}
		System.out.println("---------begin create instance list---------");	
		
		//获得构造方法constructor
		Constructor constructor = clazzProxy1.getConstructor(InvocationHandler.class);


		//编写一个最简单的InvocationHandler类
		class MyInvocationHandler1 implements InvocationHandler{
			
			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {				
				return null;
			}		
		}
		//获得动态类的实例对象
		Collection proxy1 =(Collection)constructor.newInstance(new MyInvocationHandler1());
		System.out.println(proxy1);//结果为null，因为方法中返回的是null
		proxy1.clear();//没有返回值，运行没问题
		//proxy1.size();//有返回值，运行报错
		
		//直接用匿名内部类创建InvocationHandler的实例对象，获得动态类的实例
		Collection proxy2 =(Collection)constructor.newInstance(new InvocationHandler(){
			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				return null;
			}		
		});
		
		
		// 用Proxy.newInstance方法直接一步就创建出代理对象。
		Collection proxy3 =(Collection)Proxy.newProxyInstance(
				Collection.class.getClassLoader(),
				new Class[]{Collection.class},
				new InvocationHandler(){
					ArrayList target = new ArrayList();
					public Object invoke(Object proxy, Method method,Object[] args)
							throws Throwable {	
						//ArrayList target = new ArrayList();
						long beginTime = System.currentTimeMillis();
						Object retVal = method.invoke(target, args);
						//Thread.sleep(3000);
						long endTime = System.currentTimeMillis();
						System.out.println("running time"+": "+(endTime - beginTime)/1000+"秒");
						return retVal;
				}		
		});
		proxy3.add("gbc");
		proxy3.add("wxy");
		System.out.println(proxy3.size());
	}
}

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

动态生成的类实现了Collection接口（可以实现若干接口），生成的类有Collection接口中的所有方法

和一个接受InvocationHandler参数的构造方法。

构造方法接受一个InvocationHandler对象，接受对象了要干什么用呢？该方法内部的代码会是怎样的呢？
实现Collection接口的动态类中的各个方法的代码又是怎样的呢？
InvocationHandler接口中定义的invoke方法接受的三个参数又是什么意思？

Client程序调用objProxy.add("abc")方法时，涉及三个要素： objProxy对象、add方法、"abc"参数
三个要素分别对应invoke方法中的三个参数。

Class Proxy$ {
	add(Object object) {
return handler.invoke(Object proxy, Method method, Object[] args);
	}
}

分析先前打印动态类的实例对象时，结果为什么会是null呢？调用有基本类型返回值的方法时为什么会出现NullPointerException异常？
分析为什么动态类的实例对象的getClass()方法返回了正确结果呢？
调用代理对象的方法时，如果是从Object类继承的方法，代理对象会把hashCode, equals, toString这三个方法的
调用请求转发给InvocationHandler对象，对于其他方法，则不转发调用请求。

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

怎样将目标类传进去？
1.直接在InvocationHandler实现类中创建目标类的实例对象，可以看运行效果和加入日志代码，但没有实际意义。
2.为InvocationHandler实现类注入目标类的实例对象，不能采用匿名内部类的形式了。
3.让匿名的InvocationHandler实现类访问外面方法中的目标类实例对象的final类型的引用变量。

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

将系统功能代码模块化，即将切面代码也改为通过参数形式提供，怎样把要执行的系统功能代码以参数形式提供？
1.把要执行的代码装到一个对象的某个方法里，然后把这个对象作为参数传递，
接收者只要调用这个对象的方法，即等于执行了外界提供的代码！
2.为bind方法增加一个Advice参数。

package cn.itcast.day3;

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 ProxyTest {

	public static void main(String[] args) {
		
		//创建目标类的实例对象
		final ArrayList target = new ArrayList();
		//获得代理类的实例对象，传入目标类的实例对象，Advice的实例对象
		Collection proxy3 = (Collection)getProxy(target, new MyAdvice());
		proxy3.add("gbc");
		proxy3.add("wxy");
		System.out.println(proxy3.size());
	}
	//重构出一个getProxy方法绑定接收目标同时返回代理对象，从外部传入target和advice即可。
	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();
						Object retVal = method.invoke(target, args);
						advice.afterMethod();
						return retVal;
				}		
		});
		return proxy3;
	}
}

//创建Advice接口的子类，实现方法
public class MyAdvice implements Advice {

	long beginTime = 0;
	
	public void beforeMethod() {
		
		System.out.println("到黑马训练营学习了");
		beginTime = System.currentTimeMillis();

	}	
	public void afterMethod() {
		
		System.out.println("从黑马训练营毕业了");
		long endTime = System.currentTimeMillis();
		System.out.println("running time"+": "+(endTime - beginTime)/1000+"秒");
	}
}

//实际开发中应该定义四个方法，对应放置系统功能代码的四个位置
public interface Advice {
	void beforeMethod();
	void afterMethod();
}

实现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充当封装生成动态代理的工厂，需要为工厂类提供哪些配置参数信息？
1.目标
2.通知
编写客户端应用：
1.编写实现Advice接口的类和在配置文件中进行配置
2.调用BeanFactory获取对象

import java.io.InputStream;
import java.util.Collection;

public class AopFrameworkTest {

	public static void main(String[] args) throws Exception {

		InputStream ips = AopFrameworkTest.class.getResourceAsStream("config.properties");
		Object bean = new BeanFactory(ips).getBean("xxx");
		System.out.println(bean.getClass().getName());
	}
}
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

import cn.itcast.day3.Advice;

public class BeanFactory {
	Properties props = new Properties();
	public BeanFactory(InputStream ips){
		try {
			props.load(ips);
		} catch (IOException e) {
	
			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) {
		
			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) {
				e.printStackTrace();
			}
			return proxy;
		}
		return bean;
	}
}

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

import cn.itcast.day3.Advice;

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() {

		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;
	}
}

------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------