模仿Spring框架进行方法的注入

上一篇文章之中，我们对于成员进行了注入，自动生成了bean
这次我们考虑一下特殊情况有的成员（也就是要注入的类）可能是jar包里面的类，如果想要进行注入应该怎么办呢？
我们想到利用方法进行传入并且对方法进行注解

@Retention(RUNTIME)
@Target(METHOD)
public @interface Bean {
	String name() default "";
}
/*@Bean是放在方法的注释，它会告诉Spring这个方***返回一个对象，
 * 该对象要注册为Spring应用上下文中的bean。换句话说，
 * 它很明确地告诉被注释的方法，你给我产生一个Bean，
/
再来看看 被注解的类
@Component
public class Configuration {
	public Configuration() {
	}
	@Bean
	public Point getPoint(Complex complex) {
		Point point = new Point(complex);
		return point;
	}
//	假设 Complex  是jar包里面的 一个类 ，不能进行注解
//	利用 这个类  
//	构造方法里面  进行 单参构造 传入 Complex 类到Point类里面
//  想要实现注入
}

我们的做法是先将普通的Component注解类放到beanpool里去
包扫描包扫描的博客（附源码）：

public void scanBeanByPackage(String packageName) {
		OnReadyBeanMethodDefinition orbmd = new OnReadyBeanMethodDefinition();
		ParameterDependance parameterDependance = new ParameterDependance();
		
		new PackageScanner() {
			@Override
			public void dealClass(Class<?> klass) {
				if (klass.isPrimitive()
						|| klass.isInterface()
						|| klass.isAnnotation()
						|| klass.isEnum()
						|| klass.isArray()
						|| !klass.isAnnotationPresent(Component.class)) {
					return;
				}
				
				Object object = null;
				try {
					object = klass.newInstance();
					BeanDefinition bd = new BeanDefinition();
					bd.setKlass(klass);
					bd.setObject(object);
					
					beanPool.put(klass.getName(), bd);
				} catch (InstantiationException e) {
					e.printStackTrace();
				} catch (IllegalAccessException e) {
					e.printStackTrace();
				}
				
				// 查找并处理Bean注解的方法
				// 现在只能将所有Bean注解的方法收集起来
				collectBeanMethod(klass, object, orbmd);
			}
		}.packageScanner(packageName);
		
		// 现在开始处理Bean注解的方法
		parameterDependance.checkOnReady(orbmd);
		processBeanMethod(parameterDependance, orbmd);
	}

将所有的方法进行收集，
其中
方法里面有无参，单参，多参并且同样一个方法的参数类型也可能一样
由于可能方法参数之间存在着依赖关系：

（一个方法的成功返回结果有可能使得另一个函数的参数得到满足）
所以我们想到了利用方法的参数类型为作为key 将所有需要参数的方法组成一个list作为值，作为值，建立一个 Map
如图：

（1）建立一个 ParameterDependance类

private static final Map<Class<?>, List<BeanMethodDefinition>> parameterDependance;
	static {
		parameterDependance = new HashMap<Class<?>, List<BeanMethodDefinition>>();
	}

添加依赖关系
boolean addDependance(BeanMethodDefinition methodDefinition) {
		Method method = methodDefinition.getMethod();
		int parameterCount = method.getParameterCount();
//		如果参数为0 或者小于0 那么就无须考虑依赖关系
		if (parameterCount <= 0) {
			return false;
		}
		
		Parameter[] parameters = method.getParameters();
		for (Parameter parameter : parameters) {
			Class<?> type = parameter.getType();
			if (!parameterDependance.containsKey(type)) {
//				用参数类型作为键，若多个函数包含同一类型的参数
//				则将这几个函数形成List
				parameterDependance.put(type, new ArrayList<BeanMethodDefinition>());
			}
			List<BeanMethodDefinition> bmdList = parameterDependance.get(type);
			bmdList.add(methodDefinition);
		}
		
		return true;
	}

有了依赖关系在利用反射机制bean注解的方法时，若是有一个方法的参数它已经被放到beanpool里面我们应该怎样处理呢
看代码：

	void matchDependance(Class<?> klass, OnReadyBeanMethodDefinition onReady) {
		List<BeanMethodDefinition> bmdList = parameterDependance.get(klass);
		if (bmdList == null) {
			return;
		}
		for (BeanMethodDefinition bmd : bmdList) {
//即将  对应处理了的参数 后面的BeanMethodDefinition里面的 paraCount--；
			int paraCount = bmd.decrease();
			if (paraCount == 0) {
				onReady.in(bmd);
			}
// 因为 这个BeanMethodDefinition对应的此参数已经满足 所以此参数对应的//List<BeanMethodDefinition>里面就不应该有此BeanMethodDefinition			bmdList.remove(bmd);
			if (bmdList.isEmpty()) {
				parameterDependance.remove(klass);
//parameterDependce 容器中每处理完一个参数键对应的list就该销毁整条记录
			}
		}
	}

（2）OnReadyBeanMethodDefinition 里面存着已经处理好的方法
（3）MethodBeanDefination
private Class<?> klass;
private Object object;
private Method method;
private int paraCount;
其中：用map的键不可以重复的特性来计算有的参数类型个数

protected Method getMethod() {
		Map<Class<?>, Object> map = new HashMap<Class<?>, Object>();
		Parameter[] parameters = method.getParameters();
		for (Parameter parameter : parameters) {
			map.put(parameter.getType(), null);
		}
		paraCount = map.size();
		
		return method;

反观包扫描里面的代码

先扫描，扫描到普通类时处理完存入BeanPool；扫描到方法时先分情况保存下来，无参不用进行参数互相依赖关系的处理
，带参的先保存到parameterDependce容器中等加工完成后在加入到ready容器中，然后对reday容器中准备好的方法进行处理在保存到map中以供使用。

collectBeanMethod 里面形成了一个个的MethodBeanDefination
并且形成调用 ParameterDependance里面的 addDependce 方法
底下的 processBeanMethod 利用反射机制执行收集的方法并将
结果作为BeanPool里面的键，值为其defination
这样也放入BeanPool里面

BeanPool准备完成就可以进行注入其中 Inject的方法与getBean方法相互调用

这样就实现了方法的注入！