模拟实现Spring中的注解装配

在Spring中,XML文件中的bean配置是实现Spring IOC的核心配置文件,在早版本的Spring中,只能基于XML配置文件,配置各个对象之间的依赖关系。在Spring 2.5以后出现了注解,使用注解结合XML的方式,简化了XML配置的复杂度。

老版本中纯XML配置实现IOC

在配置文件中配置如下:

<bean id="userDao" class="com.springapp.mvc.dao.UserDao">
</bean>
<bean id="userService" class="com.springapp.mvc.service.impl.UserServiceImpl"> 
  <property name="userDao" ref="userDao"></property> 
</bean>

UserServiceImpl的实现如下:

public class UserServiceImpl implements UserService {
    public UserDao getUserDao() {
        return userDao;
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    private UserDao userDao;

    public User getUserById(int id){

        return userDao.getUserById(id);
    }

    public int getUserCount(){
        return userDao.getUserCount();
    }
} 

配置的意思是:<property name="userDao" ref="userDao"></property>这行配置是为UserServiceImpl类中的userDao指定userDao这个bean,这样在UserServiceImpl类中调用userDao的方法,其实就是调用com.springapp.mvc.dao.UserDao的方法。

结合注解的实现方式

配置文件简化如下:

<bean id="userDao" class="com.springapp.mvc.dao.UserDao">
</bean>
<bean id="userService" class="com.springapp.mvc.service.impl.UserServiceImpl"> 
</bean>

UserServiceImpl的实现如下:

public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;

    public User getUserById(int id){
        return userDao.getUserById(id);
    }

    public int getUserCount(){
        return userDao.getUserCount();
    }
}

利用@Autowired注解,实现在xml中<property name="userDao" ref="userDao"></property>的配置,从而实现了自动注入。@Autowired自动注入的规则为byType,意思就是按照被注解字段的类型和xml中配置的bean的类型相匹配,即在UserServiceImpl 类中的userDao为UserDao类型,匹配的时候会在所有bean中查找类型同样为UserDao的bean。

那么既然是按照类型匹配,如果存在两个相同类型的bean呢,这时候,就会启用第二个匹配规则ByName,即根据字段的名字来匹配相同id的bean。如下XML配置:

<bean id="userDao1" class="com.springapp.mvc.dao.UserDao">
</bean>

<bean id="userDao2" class="com.springapp.mvc.dao.UserDao">
</bean>

<bean id="userService" class="com.springapp.mvc.service.impl.UserServiceImpl">
</bean>

那么在UserServiceImpl类中应该使用以下这种方式来自动注入:

@Autowired
private UserDao userDao1;

@Autowired
private UserDao userDao2;

这样好像不是很灵活的样子,看起来有些不爽,有没有办法可以指定要匹配的bean呢?没错,是有的。可以使用这样的方式,通过@Autowired和@Qualifier相结合的方式,@Qualifier后跟的参数就是bean的名称:

@Autowired
@Qualifier("userDao1")
private UserDao userDao;

还有更常用的方式,@Resource:

@Resource(name = "userDao1")
private UserDao userDao;

关于注解IOC的内容可以参看这篇文章,写的很详细。

注解在Spring中的用法讲完了,下面来自己实习一个简单的类,来模拟Spring利用注解实现IOC的原理。

Spring IOC实现原理

1.首先Spring根据bean配置文件,收集所有bean的实例;

2.Spring根据配置文件中的context:component-scan,扫描需要被注入的包(递归包中的所有待注入类);

3.扫描待注入类时,判断是否有特定的注解(例如@Autowired、@Resource),如果有,则进行第4步,注入;

4.注入:根据注解类型或参数,利用反射,为被注解的字段或属性等设置对应的bean实例。

以上是我个人理解,可能和Spring真正的实现有些出入。

模拟利用注解实现注入

这里要定义一个类似于@Resource的注解,命名为@MyAutowired,定义如下:

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE,ElementType.FIELD})
@Documented
public @interface MyAutowired {
	public String name() default "";
	
	public String value() default "";
}

定义配置文件:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:context="http://www.springframework.org/schema/context">
	<context:component-scan id="test" class="fengzheng.Test"/>
	<bean id="tomoto" class="fengzheng.Tomoto"></bean>
</beans>

其中bean和Spring中bean的定义是一样的,而context:component-scan在Spring是定义属性base-package,之后根据这个属性,扫描这个包下的所有类,这里为做演示,也定义为一个类,之后会根据这个class属性,对这个类进行注入。

配置文件中的tomoto bean的定义:

package fengzheng;


public class Tomoto {
	public void SayHello(){
		System.out.println("hello I'm tomoto");
	}
}

配置文件中fengzheng.Test类定义,这个即为要被注入的类:

package fengzheng;

import fengzheng.fzAnnotation.MyAutowired;

public class Test {
	@MyAutowired(name = "tomoto")
	private Tomoto tomoto; 
	

	public void Say(){
		tomoto.SayHello();
	}
}

核心注解分析并实现注入的类:

import java.lang.reflect.Field;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import fengzheng.fzAnnotation.MyAutowired;

import java.util.stream.*;

public class FzClassPathXMLApplication {

	//xml配置文件中 bean定义的集合
	private List<BeanDefine> beanList = new ArrayList<BeanDefine>();

	// 存储bean实例和bean的id的对应关系 以便可以根据注解名称找到对应的实例
	Map<String, Object> beanInstanceList = new HashMap<String, Object>();

	//xml配置文件中 被扫描类的定义的集合  在Spring框架中 直接扫描一个或多个包
	List<ScanDefine> scanList = new ArrayList<ScanDefine>();
	
	// 存储被扫描的待注入的实体集合
	Map<String, Object> annotationInstanceList = new HashMap<String, Object>();
	
	public FzClassPathXMLApplication(String xmlName) {
		ReadXml(xmlName);

		//实例化所有定义的bean
		BeanInstance();
		
		//实例化所有的待注入类
		ScanClassInstance();
	
		//开始根据注解实现依赖注入
		InjectAnnotation();
	}

	/**
	 * 读取配置文件  收集bean集合和待注入类的集合
	 * @param xmlFileName
	 */
	public void ReadXml(String xmlFileName) {
		URL xmlPath = this.getClass().getClassLoader().getResource(xmlFileName);
		System.out.println(xmlPath);
		SAXReader reader = new SAXReader();
		try {
			Document dom = reader.read(xmlPath);
			Element root = dom.getRootElement();
			List<Element> iters = root.elements();
			Stream<Element> beans = iters.stream().filter(bean -> bean.getName().equals("bean"));
			Iterator<Element> iterBeans = beans.iterator();

			while (iterBeans.hasNext()) {
				Element bean = iterBeans.next();
				String id = bean.attributeValue("id");
				String clsName = bean.attributeValue("class");
				//System.out.println("id:" + id + "\nclass:" + clsName);
				BeanDefine bd = new BeanDefine();
				bd.setId(id);
				bd.setClsName(clsName);
				beanList.add(bd);
			}
			
			Stream<Element> scanClasses = iters.stream().filter(scan -> scan.getName().equals("component-scan"));
			//iters.stream().forEach(scan -> System.out.println(scan.getName()));
			Iterator<Element> iterScans = scanClasses.iterator();

			while (iterScans.hasNext()) {
				Element scan = iterScans.next();
				String id = scan.attributeValue("id");
				String clsName = scan.attributeValue("class");
				ScanDefine sd = new ScanDefine();
				sd.setId(id);
				sd.setClassName(clsName);
				scanList.add(sd);
			}
			System.out.println("scanList.size():"+scanList.size());
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 收集bean实例
	 */
	private void BeanInstance() {
		for (BeanDefine bd : beanList) {
			try {
				Object beanInstance = Class.forName(bd.getClsName()).newInstance();
				System.out.println(beanInstance.getClass().getName());
				beanInstanceList.put(bd.getId(), beanInstance);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 收集被扫描的待注入的类的实例
	 */
	private void ScanClassInstance(){
		for(ScanDefine sd:scanList){
			try {
				Object scanInstance = Class.forName(sd.getClassName()).newInstance();
				System.out.println(scanInstance.getClass().getName());
				annotationInstanceList.put(sd.getId(), scanInstance);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
	
	/**
	 * 循环遍历待注入的类 
	 */
	public void InjectAnnotation() {
		Iterator<Map.Entry<String, Object>> iters = annotationInstanceList.entrySet().iterator();
		while (iters.hasNext()) {
			Map.Entry<String, Object> iter = iters.next();
			Object scanInstance = iter.getValue();
			InjectField(scanInstance);
		}
		
	}

	/**
	 * 注入:把需要注入类中的注解为MyAutowired的字段 注入bean实例
	 * @param injectClass
	 */
	private void InjectField(Object injectClass) {
		try {
			Field[] fields = injectClass.getClass().getDeclaredFields();
			
			for (Field field : fields) {
				
				if (field != null && field.isAnnotationPresent(MyAutowired.class)) {
					System.out.println(field.getName());
					MyAutowired myAutowired = field.getAnnotation(MyAutowired.class);
					String beanName = myAutowired.name();
					
					Object value = null;
					if (beanName != null && !beanName.equals("")) {
						value = beanInstanceList.get(beanName);
					} else {
						Class<?> fType = field.getType();
						for (String key : beanInstanceList.keySet()) {
							if (fType.isAssignableFrom(beanInstanceList.get(key).getClass())) {
								value = beanInstanceList.get(key);
								break;
							}
						}
					}
					field.setAccessible(true);
					field.set(injectClass, value);
				}
				
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public Object getScan(String scanName){
		return this.annotationInstanceList.get(scanName);
	}
}

注解处理类中用到的两个实体类:

package fengzheng.simpleSpring;

public class BeanDefine {
	private String id;
	
	private String clsName;

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getClsName() {
		return clsName;
	}

	public void setClsName(String clsName) {
		this.clsName = clsName;
	}
}


package fengzheng.simpleSpring;

public class ScanDefine {
	public String id;
	
	public String className;

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getClassName() {
		return className;
	}

	public void setClassName(String className) {
		this.className = className;
	}
}

对这段程序逻辑的解释:

1.首先通过ReadXml()方法读取配置文件beans.xml,找到其中的bean节点和context:component-scan节点,然后把bean节点实例化为BeanDefine,并加入beanList集合,把component-scan节点实例化为ScanDefine,并加入scanList集合;

2.通过BeanInstance()方法,把配置文件中的bean都实例化存储到Map集合beanInstanceList中;

3.通过ScanClassInstance()方法,把配置文件中的component-scan节点(即待注入的类)实例化并处处到Map集合annotationInstanceList中;

4.通过InjectAnnotation()方法,遍历annotationInstanceList集合,为其中的被@MyAutowired注解的字段赋值(即对应的bean的实例)

最后调用实现如下:

FzClassPathXMLApplication ctx = new FzClassPathXMLApplication("beans.xml");
Test test =(Test) ctx.getScan("test");
test.Say();

输出结果:

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

扫码关注云+社区