目标
在这篇文章中会实现几个相对复杂的功能，包括依赖注入，getBean方法，构建单例对象池。这篇文章内容应该会比较多，难度也较大，但咬牙拿下，对理解spring又会上一个新台阶，下面就直接开始吧
自定义注解
由于我们要实现依赖注入，所以肯定要提供相应的注解，这里我选择实现@Resource
@Target(value = {ElementType.FIELD})
@Retention(value = RetentionPolicy.RUNTIME)
public @interface Resource {
String value() default "";
}创建singletonObjects
这个容器用来存储单例对象，k-v的形式
private ConcurrentHashMap<String, Object> singletonObjects;
//代码块初始化集合
{
singletonObjects = new ConcurrentHashMap<>();
}实现singletonObjects的初始化
我们创建一个initSingletonObjects的方法，这个方法根据beanDefinitionMap实现singletonObjects的初始化。（提醒：这个方法要放入到构造器中，在初始化beanDefinitionMap后进行调用）
protected void initSingletonObjects() {
Set<Map.Entry<String, BeanDefinition>> entries = this.beanDefinitionMap.entrySet();
//遍历beanDefinitionMap所有信息
for (Map.Entry<String, BeanDefinition> entry : entries) {
//如果是单例模式，创建对象放入singletonObjects,此时没有解决依赖问题
if (entry.getValue().getType().equals("singleton")) {
Object bean = null;
try {
bean = (entry.getValue().getClazz().newInstance());
} catch (InstantiationException | IllegalAccessException e) {
e.printStackTrace();
}
String name = entry.getKey();
singletonObjects.put(name, bean);
}
}
}实现createBean方法
故名思意，这个方法用于创建bean，传入一个class对象，返回一个Object
protected Object createBean(Class<?> classes, String beanName) {
Object o = null;
try {
//创建实例对象
o = classes.newInstance();
//对每个字段进行判断，查看是否需要依赖注入
for (Field field : classes.getDeclaredFields()) {
//判断是否具有@Resource注解
if (field.isAnnotationPresent(Resource.class)) {
//得到@Resource注解
Resource resource = field.getAnnotation(Resource.class);
//得到配置的值，为空则使用属性名作为name
String name = resource.value();
if ("".equals(name)) {
name = field.getName();
}
//开放字段访问权限，用于对属性值进行注入
field.setAccessible(true);
//判断beanDefinitionMap中是否存在该name
if (beanDefinitionMap.containsKey(name)) {
//得到该beanDefinition
BeanDefinition beanDefinition = beanDefinitionMap.get(name);
Object o1 = null;
//判断是不是单例模式
if (beanDefinition.getType().equals("singleton")) {
//是单例模式直接获取
o1 = singletonObjects.get(name);
} else {
//不是单例模式需要进行创建
o1 = createBean(beanDefinition.getClazz(), beanName);
}
//注入属性值
field.set(o, o1);
} else {
throw new RuntimeException(name + "在容器中不存在，无法注入");
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
return o;
}我们上面这个方法传入了2个参数，其中一个是beanName，现在没有用到，但是后面需要，这里先不解释原因。
上面代码的就表示我们通过class创建对象，并且对属性进行遍历，看是否需要进行注入，并且还要考虑要注入的属性是否为单例的，是单例那么就直接从singletonObjects获取，如果不是，那么就实例化一个。
我们在这里实现依赖注入是通过byName的方式实现的，通过获取@Resource注解的value，如果没有填value，那么就使用属性名作为name。
解决singletonObjects的依赖注入
在上面的初始化singletonObjects的过程中，我们并没有考虑依赖注入的问题，现在我们来实现依赖注入。我们对singletonObjects中的每一个对象的属性进行遍历，检查是否需要进行注入。
//解决依赖问题
for (Map.Entry<String, Object> entry : this.singletonObjects.entrySet()) {
Object o = entry.getValue();
String beanName = entry.getKey();
//对每一个字段进行遍历，看是否存在@Resource注解
for (Field field : o.getClass().getDeclaredFields()) {
if (field.isAnnotationPresent(Resource.class)) {
Resource resource = field.getAnnotation(Resource.class);
//得到配置的值，为空则使用属性名作为name
String name = resource.value();
if ("".equals(name)) {
name = field.getName();
}
//开放字段访问权限，用于对属性值进行注入
field.setAccessible(true);
if (beanDefinitionMap.containsKey(name)) {
//得到该beanDefinition
BeanDefinition beanDefinition = beanDefinitionMap.get(name);
Object o1 = null;
//判断是不是单例模式
if (beanDefinition.getType().equals("singleton")) {
//是单例模式直接获取
o1 = singletonObjects.get(name);
} else {
//不是单例模式需要进行创建
o1 = createBean(beanDefinition.getClazz(), name);
}
//注入属性值
try {
field.set(o, o1);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
} else {
throw new RuntimeException(name + "在容器中不存在，无法注入");
}
}
}
}实现getBean方法
我们通过getBean，通过一个name可以获取到对象。这里有3种情况，如果该对象是单例的，那么直接从singletonObjects中进行返回。如果是多例的，那么就创建一个。如果该name在beanDefinitionMap中不存在，那么就报错。
public <T> T getBean(String name, Class<T> tClass) {
if (beanDefinitionMap.containsKey(name)) {
//通过name得到beanDefinition
BeanDefinition beanDefinition = beanDefinitionMap.get(name);
//判断是不是单例模式
if (beanDefinition.getType().equals("singleton")) {
return (T) singletonObjects.get(name);
} else {
return (T) createBean(beanDefinition.getClazz(), name);
}
} else {
throw new NullPointerException("没有名称为：" + name + "的bean");
}
}测试
在这里，我们需要测试单例模式和多例模式下的getBean获取到的对象是否为同一个，还要测试依赖注入是否成功。我们构造一些bean用于测试。
@Component
@Scope(type = "prototype")
public class MemberDao {
}@Component("myUserDao")
public class UserDao {
public void show(){
System.out.println("我是userDao");
}
}@Component
public class UserService {
@Resource("myUserDao")
private UserDao userDao;
public void show(){
userDao.show();
System.out.println("我是userService");
}
}@Component
public class UserController {
@Resource
private UserService userService;
public void show(){
userService.show();
System.out.println("我是userController");
}
}上面几个类在项目中的位置如下
初始化singletonObjects，实现依赖注入](http://dev-img.mos.moduyun.com/20231112/18464f1c-a49c-44a2-89bc-3f1245cdbbc7.png "[手写spring](3)初始化singletonObjects，实现依赖注入")
下面是在测试类中的内容
public class MySpringTest {
public static void main(String[] args) {
ApplicationContext ioc = new ApplicationContext(ComponentScanPathConfig.class);
//测试依赖注入
UserController userController1 = ioc.getBean("userController", UserController.class);
userController1.show();
System.out.println("----------------------");
//测试单例多例模式的getBean
UserController userController2 = ioc.getBean("userController", UserController.class);
System.out.println("单例模式userController1 userController2相等？" + (userController1 == userController2));
System.out.println("----------------------");
MemberDao memberDao1 = ioc.getBean("memberDao", MemberDao.class);
MemberDao memberDao2 = ioc.getBean("memberDao", MemberDao.class);
System.out.println("多例模式memberDao1 memberDao2相等？" + (memberDao1 == memberDao2));
}
}
输出如下
初始化singletonObjects，实现依赖注入](http://dev-img.mos.moduyun.com/20231112/33e334bb-2340-4670-a8d2-d6216701da32.png "[手写spring](3)初始化singletonObjects，实现依赖注入")
可以发现，代码没有问题，测试成功
总结
到现在，我们已经将自己的spring的框架基本搭好了，我们在这里实现依赖注入的方式和原本的spring不一样，我是尽量简化的，但是我们依赖注入的功能实现是没有任何问题的，原生实在有点麻烦，就不考虑了。在下一篇文章中将会实现bean的后置处理器，后置处理器是AOP的关键！！！后面的文章基本都是在现在的框架上进行功能的增添了。
手写spring系列
[手写spring](1)构建框架，实现包扫描
[手写spring](2)初始化BeanDefinitionMap
[手写spring](3)初始化singletonObjects，实现依赖注入
[手写spring](4)实现后置处理器
[手写spring](5)实现AOP机制（完结）
