一、工厂类BeanFactory：

1、工厂类BeanFactory负责创建目标类或代理类的实例对象，并通过配置文件实现切换。

2、getBean方法根据参数字符串返回一个相应的实例对象，如果参数字符串在配置文件中对应的类名不是ProxyFactoryBean，则直接返回该类的实例对象，否则返回该类示例对象的getProxy方法返回的对象。

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

#xxx=java.util.ArrayList

xxx=cn.itcast.test3.aopframework.ProxyFactoryBean

xxx.advice=cn.itcast.test3.MyAdvice

xxx.target=java.util. ArrayList

注意：其中的#代表注释当前行。

4、ProxyFactoryBean充当封装成动态的工厂，需为工厂提供的配置参数信息包括：

目标（target）

通告（advice）

5、BeanFactory和ProxyFactoryBean：

1）BeanFactory是一个纯粹的bean工程，就是创建bean即相应的对象的工厂。

2）ProxyfactoryBean是BeanFactory中的一个特殊的Bean，是创建代理的工厂。

二、实现类似spring的可配置的AOP框架的思路：

1、创建BeanFactory类：

1）构造方法：接受一个配置文件，通过Properties对象加载InputStream流对象获得。

2）创建getBean(String name)方法，接收Bean的名字，从上面加载后的对象获得。

3）通过其字节码对象创建实例对象bean。

4）判断bean是否是特殊的Bean即ProxyFactoryBean，如果是，就要创建代理类，并设置目标和通告，分别得到各自的实例对象，并返回代理类实例对象。如果不是在返回普通类的实例对象。

2、创建ProxyFactoryBean(接口)，此处用类做测试，其中有一个getProxy方法，用于获得代理类对象。

3、对配置文件进行配置，如上面配置一样。

4、作一个测试类：AopFrameworkTest进行测试。

//创建BeanFactory类

package cn.itcast.test3.aopframework;

import java.io.IOException;

import java.io.InputStream;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import java.util.Properties;

public class BeanFactory {

Properties prop = new Properties();

//创建对象时需要传入一个配置文件中的数据，所以需要在构造方法中接受一个参数

public BeanFactory(InputStream ips) {

try {

//将配置文件加载进来

prop.load(ips);

} catch (IOException e) {

e.printStackTrace();

}

}

//创建getBean方法，通过配置文件中的名字获取bean对象

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

}

//判断bean是特殊的bean即ProxyFactoryBean还是普通的bean

if(bean instanceof ProxyFactoryBean){

Object proxy = null;

try {

//是ProxyFactoryBean的话，强转，并获取目标和通告

ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean)bean;

//获取advice和target

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

//通过类ProxyFactoryBean（开发中是作为接口存在）中获得proxy对象

proxy = proxyFactoryBean.getProxy();

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

//是ProxyFactoryBean的话，返回proxy对象

return proxy;

}

//否则返回普通bean对象

return bean;

}

}

//创建ProxyFactoryBean类

package cn.itcast.test3.aopframework;

import java.lang.reflect.*;

import cn.itcast.test3.Advice;

public class ProxyFactoryBean {

private Object target;

private Advice advice;

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实现相同的接口

target.getClass().getInterfaces(),

new InvocationHandler() {

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

throws Throwable {

//通过契约，使用其方法--before和after方法

advice.beforeMethod(method);

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

advice.afterMethod(method);

return value;

}

}

);

return proxy;

}

}

//创建测试类AopFrameworkTest

package cn.itcast.test3.aopframework;

import java.io.InputStream;

public class AopFramewrorkTest {

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

//读取配置文件的数据

InputStream ips =

AopFramewrorkTest.class.getResourceAsStream("config.property");

//获取bean对象

Object bean = new BeanFactory(ips).getBean("xxx");

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

}

}