Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。
首先，Spring框架中实现注入的方式有注解注入和XML配置文件注入。基于注解的配置优点是更短、更简洁，开发效率高，缺点是配置嵌入到各个文件中，比较分散不易于管理。而XML配置优点是配置比较集中、方便管理，缺点是配置冗长、不够简洁。为了达到练习和理解的目的，在此仅通过难度较高的注解注入方式。
之前粗略的实现了基于JDK动态代理和CGLIB动态代理的拦截器，这是Spring框架中AOP的核心，通过此次模拟将拦截器做了改进。而注解是仿照Spring框架中的注解形式（此次模拟涉及的注解）：AutoWired、Component、Bean、Qualifier。
（部分解释在代码中已标注）
使用简单工厂模式来处理注解，建立BeanDefinition类和BeanFactory类。
package com.chy.spring.core;
import java.lang.reflect.Method;
// 将类中的方法和拦截器耦合，实现拦截器的添加和方法执行
public class BeanDefinition {
Class<?> klass;
ProxyInvoker proxyInvoker;
boolean done;
private static final ChyProxy CHY_PROXY = new ChyProxy();
BeanDefinition(Class<?> klass) throws Exception {
this.klass = klass;
Object object = klass.newInstance();
Object proxy = CHY_PROXY.getProxy(klass);
this.proxyInvoker = new ProxyInvoker(object, proxy);
this.done = false;
}
BeanDefinition(Object object) {
this.klass = object.getClass();
Object proxy = CHY_PROXY.getProxy(object);
this.proxyInvoker = new ProxyInvoker(object, proxy);
this.done = false;
}
void addIntercepter(Method method, ChyIntercepter chyIntercepter) {
chyIntercepter.addMethod(method);
proxyInvoker.addIntercepter(chyIntercepter);
}
Object invoke(Method method, Object[] args) throws Throwable {
return proxyInvoker.invoke(method, args);
}
boolean isDone() {
return done;
}
Class<?> getKlass() {
return klass;
}
void setKlass(Class<?> klass) {
this.klass = klass;
}
Object getObject() {
return proxyInvoker.getObject();
}
Object getProxy() {
return proxyInvoker.getProxy();
}
@Override
public String toString() {
return klass + ":" + getObject();
}
}
BeanFactory中的基本思路是：将带有Component的类加入Map中，再将带有Bean注解的方法存入方法池中，通过检查AutoWired注解和Qualifier注解完成对成员的赋值注入。
package com.chy.spring.core;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import com.chy.spring.annotation.AutoWired;
import com.chy.spring.annotation.Bean;
import com.chy.spring.annotation.Component;
import com.chy.spring.annotation.Qualifier;
import com.mec.util.PackageScanner;
import com.mec.util.ValueParser;
public class BeanFactory {
// <类名， BeanDefinition对象>
private static final Map<String, BeanDefinition> beanFactory;
// <类编号， 类名>
private static final Map<String, String> beanIdMap;
// 实例化两个Map，因为存在按类名查找和按可能设定的类的编号查找两种方式
static {
beanFactory = new ConcurrentHashMap<>();
beanIdMap = new ConcurrentHashMap<>();
}
private BeanMethodPool beanMethodPool;
public BeanFactory() {
beanMethodPool = new BeanMethodPool() {
@Override
public void setBeanMethodValue(BeanDefinition beanDefinition) {
try {
setBeanValue(beanDefinition);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public Map<String, BeanDefinition> getBeanFactory() {
return beanFactory;
}
};
}
// 设置拦截器
public void setIntercepter(Class<?> klass, Method method, ChyIntercepter chyIntercepter)
throws Exception {
String className = klass.getName();
BeanDefinition beanDefinition = beanFactory.get(className);
if (beanDefinition == null) {
throw new Exception("Bean(" + className + ")不存在！");
}
beanDefinition.addIntercepter(method, chyIntercepter);
}
// 对包扫描，扫描带有Component注解的类，实现BeanFactory的初始化
public void initBeanFactory(String packageName) {
new PackageScanner() {
@Override
public void dealClass(Class<?> klass) {
if (klass.isPrimitive() || klass.isInterface() || klass.isEnum()
|| klass.isAnnotation() || klass.isArray()
|| !klass.isAnnotationPresent(Component.class)) {
return;
}
String klassName = klass.getName();
String beanId = klassName;
Component component = klass.getAnnotation(Component.class);
String id = component.id();
// 判断该类是否有编号
// 有编号则将该类存入beanMap中
if (id.length() > 0) {
beanId = id;
beanIdMap.put(beanId, klassName);
}
try {
BeanDefinition bd = new BeanDefinition(klass);
beanFactory.put(klassName, bd);
collectBeanMethods(klass, bd.getObject());
} catch (Exception e) {
e.printStackTrace();
}
}
}.scannerPackage(packageName);
try {
beanMethodPool.scanPool();
} catch (Exception e) {
e.printStackTrace();
}
}
// 收集带有Bean注解的方法
private void collectBeanMethods(Class<?> klass, Object object) throws Exception {
Method[] methods = klass.getDeclaredMethods();
for (Method method : methods) {
if (!method.isAnnotationPresent(Bean.class)) {
continue;
}
Bean bean = method.getAnnotation(Bean.class);
Class<?> returnType = method.getReturnType();
if (returnType.equals(void.class)) {
throw new Exception("[" + method.getName() + "]不能对void方法加@Bean注解！");
}
String name = bean.name();
BeanMethodDefinition beanMethodDefinition = new BeanMethodDefinition(name, returnType, object, method);
String className = returnType.getName();
if (name.length() > 0) {
beanIdMap.put(name, className);
}
if (beanMethodDefinition.getParameterCount() <= 0) {
Object beanObj = method.invoke(object);
BeanDefinition bd = new BeanDefinition(beanObj);
beanFactory.put(className, bd);
continue;
}
beanMethodPool.addBeanMethod(className, beanMethodDefinition);
}
}
// 给BeanDefinition对象赋值
private void setBeanValue(BeanDefinition bean) throws Exception {
if (bean.isDone()) {
return;
}
// 若该语句放在该方法的结尾，则会造成无穷递归
bean.done = true;
Class<?> klass = bean.getKlass();
Field[] fields = klass.getDeclaredFields();
for (Field field : fields) {
// 遍历寻找含有AutoWired注解的成员
if (!field.isAnnotationPresent(AutoWired.class)) {
continue;
}
// 得到该注解，并取其值
AutoWired autoWired = field.getAnnotation(AutoWired.class);
String value = autoWired.value();
System.out.println(value + "====" + field);
boolean singleton = autoWired.singleton();
setValue(bean, field, value.length() <= 0 ? null : value, singleton);
}
}
// 赋值过程，若成员中存在BeanDefinition类成员，则需要调用setBeanValue方法，对该类内的成员赋值。间接递归！
private void setValue(BeanDefinition bean, Field field,
String value, boolean singleton) throws Exception {
if (value != null) {
setFieldWithValue(bean.getObject(), bean.getKlass(), field, value);
return;
}
// 如果注解的value没有值，则在beanFactory中通过查找该成员的类是否被注入
Class<?> type = field.getType();
System.out.println(type);
BeanDefinition bd = beanFactory.get(type.getName());
if (bd == null) {
BeanDefinition[] beans = searchBeanBySuperType(type);
if (beans.length == 1) {
bd = beans[0];
} else if(beans.length <= 0 || !field.isAnnotationPresent(Qualifier.class)) {
throw new Exception("类" + bean.getKlass() + "中的成员" + field.getName() + "注入失败！");
} else {
Qualifier qualifier = field.getAnnotation(Qualifier.class);
String beanName = qualifier.value();
bd = getBeanDefinition(beanName);
if (bd == null) {
throw new Exception("类" + bean.getKlass() + "的成员" + field.getName() + "注入失败！");
}
}
}
if (!singleton) {
bd = new BeanDefinition(type);
}
if (!bd.isDone()) {
setBeanValue(bd);
System.out.println(bd + "竟然没注入？？？？？");
}
setFieldValue(bean.getObject(), bean.getKlass(), field, bd.getObject());
}
// 按父类或超类中寻找BeanDefinition
private BeanDefinition[] searchBeanBySuperType(Class<?> klass) {
List<BeanDefinition> beanList = new ArrayList<>();
for (BeanDefinition bean : beanFactory.values()) {
Class<?> beanClass = bean.getKlass();
if (klass.isAssignableFrom(beanClass)) {
beanList.add(bean);
}
}
BeanDefinition[] beans = new BeanDefinition[beanList.size()];
// 集合转数组
beanList.toArray(beans);
return beans;
}
// 设置成员的值(值为String类型，转换为Object类型)
private void setFieldWithValue(Object object, Class<?> klass, Field field, String value) throws Exception {
Class<?> type = field.getType();
Object val = ValueParser.stringToObject(type, value);
setFieldValue(object, klass, field, val);
}
// 设置成员的值(值为对象类型)
private void setFieldValue(Object object, Class<?> klass, Field field, Object val) throws Exception {
Class<?> type = field.getType();
String fieldName = field.getName();
// 通过反射机制创建set方法
String methodName = "set" + fieldName.substring(0, 1).toUpperCase()
+ fieldName.substring(1);
try {
Method method = klass.getDeclaredMethod(methodName, new Class<?>[] {type});
method.invoke(object, val);
} catch (Exception e) {
// 访问private修饰的成员
field.setAccessible(true);
field.set(object, val);
}
}
// 供内部使用的得到BeanDefinition对象的方法(按对象查找)
static BeanDefinition getBeanDefinition(Object object) {
String beanId = object.getClass().getName();
return getBeanDefinition(beanId);
}
// 供内部使用的得到BeanDefinition对象的方法(按编号查找)
static BeanDefinition getBeanDefinition(String beanId) {
BeanDefinition bean = beanFactory.get(beanId);
if (bean == null) {
String className = beanIdMap.get(beanId);
if (className == null) {
return null;
}
bean = beanFactory.get(className);
}
return bean;
}
// 供外部使用的getBean方法，提供编号或类名即可从BeanFactory中获取
@SuppressWarnings("unchecked")
public <T> T getBean(String beanId) throws Exception {
BeanDefinition bean = beanFactory.get(beanId);
// 懒汉模式
setBeanValue(bean);
return (T) bean.getProxy();
}
@SuppressWarnings("unchecked")
public <T> T getBean(Class<?> klass) throws Exception {
String beanId = klass.getName();
BeanDefinition bean = beanFactory.get(beanId);
if (bean == null) {
throw new Exception("类" + klass.getName() + "不存在");
}
BeanDefinition bd = beanFactory.get(beanId);
// 懒汉模式
setBeanValue(bd);
return (T) bd.getProxy();
}
}
接下来需要对在BeanFactory中的类和方法进行规范处理，包括一个方法池、规范方法和参数。
package com.chy.spring.core;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
public abstract class BeanMethodPool {
static final Map<String, BeanMethodDefinition> beanMethodPool
= new ConcurrentHashMap<>();
BeanMethodPool() {
}
void addBeanMethod(String id, BeanMethodDefinition beanMethodDefinition) {
if (beanMethodPool.containsKey(id)) {
return;
}
beanMethodPool.put(id, beanMethodDefinition);
}
// 对池子扫描，考虑线程安全
synchronized void scanPool() throws Exception {
Set<String> ids = beanMethodPool.keySet();
// 执行标志，若有方法执行失败或其他异常，则停止后续方法的执行
boolean hasOne = true;
while (hasOne) {
hasOne = false;
for (String id : ids) {
BeanMethodDefinition beanMethodDefinition = beanMethodPool.get(id);
if (!checkParameter(beanMethodDefinition)) {
continue;
}
// 得到参数，并获取每个参数的值
Object[] args = new Object[beanMethodDefinition.getParameterCount()];
for (int i = 0; i < args.length; i++) {
ChyParameter cp = beanMethodDefinition.parameters.get(i);
args[i] = cp.getValue();
}
// 执行方法
Object beanObject = beanMethodDefinition.getMethod().invoke(beanMethodDefinition.getObject(), args);
// 将方法所在类以及调用该方法的对象加入BeanFactory中
getBeanFactory().put(beanMethodDefinition.getClassName(), new BeanDefinition(beanObject));
// 从方法池中删除该方法
beanMethodPool.remove(id);
hasOne = true;
}
if (beanMethodPool.size() <= 0) {
return;
}
}
}
// 错误处理，包括无法执行的方法
String errorMessage() {
if (beanMethodPool.size() <= 0) {
return null;
}
StringBuffer res = new StringBuffer();
for (String id : beanMethodPool.keySet()) {
BeanMethodDefinition bmd = beanMethodPool.get(id);
Class<?> klass = bmd.getObject().getClass();
res.append("类:" + klass.getName() + "的方法:")
.append(bmd.getMethod().getName() + "无法执行\n");
}
return res.toString();
}
// 需要从BeanFactory中获得BeanDefinition，以及设置需要注入的方法
public abstract Map<String, BeanDefinition> getBeanFactory();
public abstract void setBeanMethodValue(BeanDefinition beanDefinition);
// 核对方法参数，从beanMethodDefinition获取
private boolean checkParameter(BeanMethodDefinition beanMethodDefinition) {
for (ChyParameter para : beanMethodDefinition.parameters) {
if (para.value != null) {
continue;
}
Class<?> beanType = para.getType();
String beanName = beanType.getName();
BeanDefinition bd = getBeanFactory().get(beanName);
setBeanMethodValue(bd);
if (bd == null) {
return false;
}
para.value = bd.getObject();
}
return true;
}
}
参数规范：
package com.chy.spring.core;
import java.lang.reflect.Parameter;
// 参数规范
public class ChyParameter {
Class<?> type;
Object value;
ChyParameter(Parameter parameter) {
this.type = parameter.getType();
this.value = null;
}
Class<?> getType() {
return type;
}
Object getValue() {
return value;
}
}
方法的定义和成员规范：
package com.chy.spring.core;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.ArrayList;
import java.util.List;
public class BeanMethodDefinition {
String name;
String className;
Class<?> type;
Object object;
Method method;
List<ChyParameter> parameters;
BeanMethodDefinition(String name, Class<?> type,
Object object, Method method) {
this.name = name;
this.type = type;
this.className = type.getName();
this.object = object;
this.method = method;
parameters = new ArrayList<>();
Parameter[] parameterList = method.getParameters();
for (Parameter parameter : parameterList) {
// 以ChyParameter对象加入List
parameters.add(new ChyParameter(parameter));
}
}
int getParameterCount() {
return parameters.size();
}
String getName() {
return name;
}
String getClassName() {
return className;
}
Object getObject() {
return object;
}
Method getMethod() {
return method;
}
}
下来是改进后的拦截器：
package com.chy.spring.core;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class JDKProxy {
JDKProxy() {
}
// 类类型参数处理
<T> T getProxy(Class<?> klass) throws Exception {
Object object = klass.newInstance();
return getProxy(object, klass.getClassLoader(), klass.getInterfaces());
}
// 对象类型参数处理
<T> T getProxy(Object object) {
Class<?> klass = object.getClass();
return getProxy(object, klass.getClassLoader(), klass.getInterfaces());
}
@SuppressWarnings("unchecked")
private <T> T getProxy(Object object, ClassLoader classLoader, Class<?>[] interfaces) {
return (T) Proxy.newProxyInstance(classLoader, interfaces, new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 同理CGLIB
BeanDefinition bean = BeanFactory.getBeanDefinition(object);
if (bean == null) {
return method.invoke(object, args);
}
return bean.invoke(method, args);
}
});
}
}
package com.chy.spring.core;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class CglibProxy {
CglibProxy() {
}
<T> T getProxy(Class<?> klass) throws Exception {
return getProxy(klass, klass.newInstance());
}
<T> T getProxy(Object object) {
return getProxy(object.getClass(), object);
}
@SuppressWarnings("unchecked")
private <T> T getProxy(Class<?> klass, Object object) {
try {
// 通过参数类型的所有构造器，判断是否有可操作的参数
Constructor<?> constructor =
klass.getDeclaredConstructor(new Class<?>[] {});
int modifiers = constructor.getModifiers();
if ((modifiers & Modifier.PRIVATE) != 0) {
return (T) object;
}
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
}
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(klass);
enhancer.setCallback(new MethodInterceptor() {
// 未来执行（无法知道BeanFactory的情况，只能根据当前的object反取BeanFactory中的BeanDefinition）
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
// TODO 预留操作，从BeanFactory()中获取ProxyInvoker对象
// return new BeanFactory().getBeanDefinition(klass.getName())
// .proxyInvoker.invoke(object, method, args);
BeanDefinition bean = BeanFactory.getBeanDefinition(object);
if (bean == null) {
return method.invoke(object, args);
}
return bean.invoke(method, args);
}
});
return (T) enhancer.create();
}
}
package com.chy.spring.core;
import java.lang.reflect.Method;
public class ProxyInvoker {
// 对三者的捆绑
// 金初始化一个
Object object;
Object proxy;
IntercepterChain intercepterChain;
ProxyInvoker(Object object, Object proxy) {
this.object = object;
this.proxy = proxy;
intercepterChain = new IntercepterChain(null);
}
public Object getObject() {
return object;
}
public Object getProxy() {
return proxy;
}
// 拦截器的添加采用头插的方式
void addIntercepter(IIntercepter intercepter) {
IntercepterChain newChain = new IntercepterChain(intercepter);
if (intercepterChain.next == null) {
intercepterChain.next = newChain;
} else {
newChain.next = intercepterChain.next;
intercepterChain.next = newChain;
}
}
IntercepterChain getIntercepterChain() {
return intercepterChain;
}
// 将拦截器链和截获的参数一同交给doChain()方法执行
Object invoke(Method method, Object[] args)
throws Throwable {
return intercepterChain.doChain(intercepterChain.next, object, method, args);
}
}
package com.chy.spring.core;
import java.lang.reflect.Method;
public class IntercepterChain {
private IIntercepter intercepter;
// 链域
IntercepterChain next;
boolean beforeOk;
// proxyInvoker和拦截器作为参数传进来，并完成初始化
IntercepterChain(IIntercepter intercepter) {
this.intercepter = intercepter;
this.next = null;
}
IntercepterChain getNext() {
return next;
}
Object doChain(IntercepterChain chain, Object object, Method method, Object[] args)
throws Throwable {
Object result = null;
if (chain != null) {
IIntercepter intercepter = chain.intercepter;
if (intercepter.isMethod(method)) {
if (beforeOk = intercepter.before(args)) {
try {
// 间接递归，再次执行带有拦截器链的invoke方法，走完整个链将退出
result = doChain(chain.next, object, method, args);
// result = proxyInvoker.invoke(chain, method, args);
// 每次退出来的执行后置拦截，若无后置拦截，则结果不变
if (beforeOk) {
result = intercepter.after(result);
}
} catch (Throwable e) {
intercepter.dealException(e);
}
} else {
// 若不是需要拦截的方法，或不进行前置拦截，则直接执行
return result;// = proxyInvoker.invoke(chain, method, args);
}
} else {
result = doChain(chain.next, object, method, args);
}
} else {
result = method.invoke(object, args);
}
return result;
}
}
其中设置了IIntercepter接口，为了达到工具的完整性和实用性，需要一个适配器以及适配器的继承实现类。
package com.chy.spring.core;
import java.lang.reflect.Method;
public interface IIntercepter {
// 前置拦截！
boolean before(Object[] args);
// 后置拦截
Object after(Object result);
// 异常处理
void dealException(Throwable e) throws Throwable;
// 判断是不是需要拦截的方法
public boolean isMethod(Method method);
}
package com.chy.spring.core;
public abstract class ChyIntercepterAdapter implements IIntercepter {
@Override
public boolean before(Object[] args) {
return true;
}
@Override
public Object after(Object result) {
return result;
}
@Override
public void dealException(Throwable e) throws Throwable {
}
//
// @Override
// public boolean isMethod(Method method) {
// return false;
// }
}
package com.chy.spring.core;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
public abstract class ChyIntercepter extends ChyIntercepterAdapter{
private List<Method> methods;
public ChyIntercepter() {
methods = new ArrayList<>();
}
void addMethod(Method method) {
methods.add(method);
}
@Override
public boolean isMethod(Method method) {
return methods.contains(method);
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
