首页 > 技术交流 > 手撸一个 Spring —— 2. 基于注解

手撸一个 Spring —— 2. 基于注解

头像
何人听我楚狂声
编辑于 2021-02-26 22:53:18 APP内打开
赞 7 | 收藏 12 | 回复1 | 浏览1694

上一篇中,读取 xml 解析为 BeanDefinition 的类 XmlBeanDefinitionReader 的代码在如下链接:https://github.com/CN-GuoZiyang/My-Spring-IOC/blob/82967670e5/src/main/java/top/guoziyang/springframework/reader/XmlBeanDefinitionReader.java,微信公众号似乎不允许内置链接。

上一节我们已经实现了一个包含基本功能的 IOC 容器,并且也解决了各种依赖问题。没看过上一篇的同学可以在我的讨论帖记录中查找。

这一节我们来对这个框架进行扩展,实现基于注解自动注入 bean 的方式,免去繁琐的配置文件。

本节最终的代码为:https://github.com/CN-GuoZiyang/My-Spring-IOC/tree/8a3a9c640e532c5d4aa8d62f18b42fa336c94f2e

定义注解

首先我们需要定义一些注解类,仿照 Spring,我们定义如下的五个注解:、@Component@Scope@Autowired@Qualifier@Value。他们分别的作用如下:

  • @Component:这个注解用于类,表示这个类是一个需要被注册进容器的 bean
  • @Scope:这个注解用于类,默认值是 "singleton",还可使用 "prototype",标明这个 bean 是单例还是多例的
  • @Autowired:这个注解用于属性,表示向属性自动注入容器中对应类型的 bean
  • @Qualifier:这个注解用于属性,需要传递一个字符串,表示给这个属性注入对应名称的 bean
  • @Value:这个注解用于属性,表示向这个属性注入某个值(基本类型)

我们来定义注解,如下:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Component {
    String name() default "";
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Scope {
    String value() default "singleton";
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Autowired{}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Qualifier {
    String value();
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Value {
    public String value();
}

定义注解同样需要一些注解(禁止套娃),@Retention 注解用来标示注解类型的生命周期,由于我们的这些注解都是需要在运行时通过反射获取的,所以这个注解的值都是 RetentionPolicy.RUNTIME@Target 注解用来定义注解能够被应用于源码的哪些位置,例如 ElementType.FIELD 为属性,ElementType.TYPE 是类。

由于不是 SpringBoot,我们仍然需要在配置文件中书写自动注入的扫描范围,来指导框架扫描。配置文件如下:

<?xml version="1.0" encoding="UTF-8"?>
<beans>
    <component-scan base-package="top.guoziyang.main"></component-scan>
</beans>

启动后,框架会自动扫描该包及其子包下所有使用注解标明的 Bean,并注入容器。

扫描注解

由于配置文件发生了改变,自然我们需要改变 xml 文件的解析方式,在 XmlBeanDefinitionReader 类的 parseBeanDefinitions() 方法中,一旦我们发现了 component-scan 标签,说明我们是使用注解来注入 Bean 的:

protected void parseBeanDefinitions(Element root) {
  ...
  for(int i = 0; i < nodeList.getLength(); i ++) {
      if(nodeList.item(i) instanceof Element) {
          Element ele = (Element)nodeList.item(i);
          if(ele.getTagName().equals("component-scan")) {
              basePackage = ele.getAttribute("base-package");
              break;
          }
      }
  }
  if(basePackage != null) {
      parseAnnotation(basePackage);
      return;
  }
  ...
}

parseAnnotation() 方***获取到目标包下所有的类,并遍历解析:

protected void parseAnnotation(String basePackage) {
    Set<Class<?>> classes = getClasses(basePackage);
    for(Class clazz : classes) {
        processAnnotationBeanDefinition(clazz);
    }
}

getClass() 就是用来获取到包下的所有类,它的实现较为繁琐,具体代码在:https://github.com/CN-GuoZiyang/My-Spring-IOC/blob/8a3a9c640e/src/main/java/top/guoziyang/springframework/reader/XmlBeanDefinitionReader.java#L141,当然这个功能也可以用 guava 直接实现。

processAnnotationBeanDefinition() 这个方法利用了反射机制来获取类上的注解,以判断对应的类是否是需要注册的 bean,并寻找相关的注解,如 @Scope,形成对应的 BeanDefinition:

protected void processAnnotationBeanDefinition(Class<?> clazz) {
    if(clazz.isAnnotationPresent(Component.class)) {
        String name = clazz.getAnnotation(Component.class).name();
        if(name == null || name.length() == 0) {
            name = clazz.getName();
        }
        String className = clazz.getName();
        boolean singleton = true;
        if(clazz.isAnnotationPresent(Scope.class) && "prototype".equals(clazz.getAnnotation(Scope.class).value())) {
            singleton = false;
        }
        BeanDefinition beanDefinition = new BeanDefinition();
        processAnnotationProperty(clazz, beanDefinition);
        beanDefinition.setBeanClassName(className);
        beanDefinition.setSingleton(singleton);
        getRegistry().put(name, beanDefinition);
    }
}

processAnnotationProperty() 则是对类的每一个属性进行判断,来确定每个属性是否需要注入等:

protected void processAnnotationProperty(Class<?> clazz, BeanDefinition beanDefinition) {

    Field[] fields = clazz.getDeclaredFields();
    for(Field field : fields) {
        String name = field.getName();
        if(field.isAnnotationPresent(Value.class)) {
            Value valueAnnotation = field.getAnnotation(Value.class);
            String value = valueAnnotation.value();
            if(value != null && value.length() > 0) {
                // 优先进行值注入
                beanDefinition.getPropertyValues().addPropertyValue(new PropertyValue(name, value));
            }
        } else if(field.isAnnotationPresent(Autowired.class)) {
            if(field.isAnnotationPresent(Qualifier.class)) {
                Qualifier qualifier = field.getAnnotation(Qualifier.class);
                String ref = qualifier.value();
                if(ref == null || ref.length() == 0) {
                    throw new IllegalArgumentException("the value of Qualifier should not be null!");
                }
                BeanReference beanReference = new BeanReference(ref);
                beanDefinition.getPropertyValues().addPropertyValue(new PropertyValue(name, beanReference));
            } else {
                String ref = field.getType().getName();
                BeanReference beanReference = new BeanReference(ref);
                beanDefinition.getPropertyValues().addPropertyValue(new PropertyValue(name, beanReference));
            }
        }
    }
}

其实就是将原本从 xml 获取到的各种信息,通过反射的方式从注解中获取了出来。整体的逻辑并没有什么变化。

实际上,由于产生的结果一致(生成 beanDefinition 并存入 registry),可以仿照 Spring 的实现使用委托模式,这样耦合度就不会太高。但是由于使用注解同样还需要读取配置文件,较为繁琐,就没有解耦(实际上是我偷懒了)。

写了这么多,其实都仅仅是对 XmlBeanDefinitionReader 这个类的改动,因为这个类的职责就是,从文件中解析出 BeanDefinition。这个类的实现在 https://github.com/CN-GuoZiyang/My-Spring-IOC/blob/8a3a9c640e/src/main/java/top/guoziyang/springframework/reader/XmlBeanDefinitionReader.java 中。

看看效果

由于我们使用了注解,就需要修改相应的 bean,加上上面定义的注解即可:

@Component(name = "helloWorldService")
@Scope("prototype")
public class HelloWorldServiceImpl implements HelloWorldService {
    @Value("Hello, world")
    private String text;

    @Override
    public void saySomething() {
        System.out.println(text);
    }
}
@Component(name = "wrapService")
public class WrapService {
    @Autowired
    private HelloWorldService helloWorldService;

    public void say() {
        helloWorldService.saySomething();
    }
}

测试代码如下:

public class Main() {
  public static void annotationTest() throws Exception {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application-annotation.xml");
        WrapService wrapService = (WrapService) applicationContext.getBean("wrapService");
        wrapService.say();
        HelloWorldService helloWorldService = (HelloWorldService) applicationContext.getBean("helloWorldService");
        HelloWorldService helloWorldService2 = (HelloWorldService) applicationContext.getBean("helloWorldService");
        System.out.println("prototype验证:相等" + (helloWorldService == helloWorldService2));
        WrapService wrapService2 = (WrapService) applicationContext.getBean("wrapService");
        System.out.println("singleton验证:相等" + (wrapService == wrapService2));
    }
}

其实和第一节的测试一样,结果也是一致的。

结束语

到这里,自己手写的 IOC 容器的简单实现就完成了!还是挺有成就感的。使用体验和 Spring 基本没啥差别(误)。

下一篇文章,会基于已经实现的 IOC 容器,在其上层手撸一个 SpringMVC 的简单实现。

所以,不要停下来啊!

1条回帖

回帖
加载中...
话题 回帖

推荐话题

相关热帖

技术交流近期热帖

热门推荐