BeanFactory.java
package com.itheima.aopframwork;
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) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//生产bean
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(); //从配置文件获得advice和target用于传递给代理工厂
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; //不需要代理就直接返回bean本体
}
}
ProxyFactoryBean.java
package com.itheima.aopframwork;
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 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(method) ;
Object retVal = method.invoke(target, args) ;
advice.afterMethod(method) ;
return retVal;
}
}) ;
return proxy;
}
}
Advice.java
package com.itheima.aopframwork;
import java.lang.reflect.Method;
public interface Advice {
public void beforeMethod(Method method) ;
public void afterMethod(Method method) ;
}
MyAdvice.java
package com.itheima.aopframwork;
import java.lang.reflect.Method;
public class MyAdvice implements Advice {
long beginTime = 0;
public void afterMethod(Method method) {
// TODO Auto-generated method stub
System.out.println("从传智播客毕业上班啦!");
long endTime = System.currentTimeMillis();
System.out.println(method.getName() + " running time of " + (endTime - beginTime));
}
public void beforeMethod(Method method) {
// TODO Auto-generated method stub
System.out.println("到传智播客来学习啦!");
beginTime = System.currentTimeMillis();
}
}
advice只是打酱油的。。。。
config.properties
用注释可以来回切换两种类来看效果。
#xxx=java.util.ArrayList
xxx=com.itheima.aopframwork.ProxyFactoryBean
xxx.advice=com.itheima.aopframwork.MyAdvice
xxx.target=java.util.ArrayList
AopFramworkTest.java
package com.itheima.aopframwork;
import java.io.InputStream;
public class AopFramworkTest {
public static void main(String[] args) throws Exception{
InputStream ips = AopFramworkTest.class.getResourceAsStream("config.properties"); //流读取配置文件
Object bean = new BeanFactory(ips).getBean("xxx") ; //以配置文件中的信息生产一个对象
System.out.println(bean.getClass().getName());
}
}
这里两个工厂一个管理bean一个管理proxy,其中bean以构造方法为入口,获取配置文件里的信息,在得到所有参数后,把这些参数又交给proxy去处理。
如果不想代理还提供了if判断。
这样就完成spring的可配置的AOP框架。