java 高新技术【11.2】 动态代理类 编写类似 AOP 与 BeanFactory。初试Spring框架

1.切面(aspect):    要实现的交叉功能，是系统模块化的一个切面或领域。如日志记录。
2.连接点:    应用程序执行过程中插入切面的地点，可以是方法调用，异常抛出，或者要修改的
字段。
3.通知:    切面的实际实现，他通知系统新的行为。如在日志通知包含了实
现日志功能的代码，如向日志文件写日志。通知在连接点插入到应用系统中。
4.切入点:    定义了通知应该应用在哪些连接点，通知可以应用到AOP框架支持的任何连接点。
5.引入:    为类添加新方法和属性。
6.目标对象:    被通知的对象。既可以是你编写的类也可以是第三方类。
7.代理:    将通知应用到目标对象后创建的对象，应用系统的其他部分不用为了支持代理对象而
改变。
8.织入:    将切面应用到目标对象从而创建一个新代理对象的过程。织入发生在目标
对象生命周期的多个点上：
编译期：  切面在目标对象编译时织入.这需要一个特殊的编译器.
类装载期：  切面在目标对象被载入JVM时织入.这需要一个特殊的类载入器.
运行期：  切面在应用系统运行时织入.

AOP的几个重点概念：

1、Spring只支持方法拦截，也就是说，只能在方法的前后进行拦截，而不能在属性前后进行拦截。
2、Spring支持四种拦截类型：目标方法调用前（before），目标方法调用后（after），目标方法调用前后（around），以及目标方法抛出异常（throw）。
3、前置拦截的类必须实现MethodBeforeAdvice接口，实现其中的before方法。
4、后置拦截的类必须实现AfterReturningAdvice接口，实现其中的afterReturning方法。
5、前后拦截的类必须实现MethodInterceptor接口，实现其中的invoke方法。前后拦截是唯一可以控制目标方法是否被真正调用的拦截类型，也可以控制返回对象。而前置拦截或后置拦截不能控制，它们不能印象目标方法的调用和返回。

但是以上的拦截的问题在于，不能对于特定方法进行拦截，而只能对某个类的全部方法作拦截。

所以下面引入了两个新概念：“切入点”和“引入通知”。

6、”切入点“的定义相当于更加细化地规定了哪些方法被哪些拦截器所拦截，而并非所有的方法都被所有的拦截器所拦截。在ProxyFactoryBean的属性中，interceptorNames属性的对象也由拦截（Advice）变成了引入通知（Advisor），正是在Advisor中详细定义了切入点（PointCut）和拦截（Advice）的对应关系，比如常见的基于名字的切入点匹配（NameMatchMethodPointcutAdvisor类）和基于正则表达式的切入点匹配（RegExpPointcutAdvisor类）。这些切入点都属于”静态切入点“，因为他们只在代理创建的时候被创建一次，而不是每次运行都创建。

import java.lang.reflect.Method;

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

import java.lang.reflect.Method;

public class MyAdvice implements Advice {
	long beginTime = 0;
	public void afterMethod(Method method) {
		System.out.println("操作方法后");		
		long endTime = System.currentTimeMillis();
		System.out.println(method.getName() + " running time of " + (endTime - beginTime));

	}

	public void beforeMethod(Method method) {
		System.out.println("操作方法前");
		beginTime = System.currentTimeMillis();
	}

}

package com.itm.day3.aopframework;

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

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

}

package com.itm.day3.aopframework;

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


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) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		if(bean instanceof ProxyFactoryBean){
			
			Object proxy = null;
			
			 // 这时就可以  创建  那个代理对象的。。。
			try {
				ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean)bean;
				
				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;
	}
	
}

public class AopFrameworkTest {

	/**
	 * @param args
	 */
	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();
		System.out.println("-----");
	}

}

说明：

#xxx=java.util.ArrayList   注释这一段代码 就会去找 代理类。

#xxx=com.itm.day3.aopframework.ProxyFactoryBean  注释这一段代码，就不用找代理类了 就去真正的类。