Spring手写实现笔记
本篇文章并不是教你如何基于XML注解实现Spring，仅仅是自己手写实现Spring XML注解注入的时候一点心得，如果发现有谬误，还望告知，github链接：https://github.com/laowenruo/... （目前仅仅实现了XML，之后还会实现其余形式）
基于XML注解实现
原理
- IOC的作用就是把每个bean之间的关系交给第三方容器进行治理，bean的初始化等交给容器解决，即管制反转
- 所有配置文件只有是配置了全门路，咱们就能够了解为其是反射失去的（如：spring.xml中配置的bean中的class属性）
- SpringIOC的XML版本采纳的是dom4j+反射技术实现的
- 反射的结构对象，必定会走无参构造函数的。（无论构造函数是否公有）
外围实现
定义ApplicationContext
因为咱们应用Spring的Xml注入的时候，咱们是通过ApplicationContext，即利用上下文来加载Xml后获取对象的，所以咱们第一步先定义一个ApplicaitionContext的接口（为什么要定义成接口，次要是为了类的设计--繁多职责准则）
public interface ApplicationContext{ /** * 依据类名获取对象，即ByClass * @param clazz * @return * @throws Exception */ Object getBean(Class clazz) throws Exception; /** * 依据名字获取对象，即ByName * @param beanName * @return * @throws Exception */ Object getBean(String beanName) throws Exception;}
定义AbstractApplicationContext
这里实现得就有点像代理模式了，并且也要引入一个BeanFactory，因为咱们获取的对象都在BeanFatory外面结构，说到这里，咱们可能会想到了局部原理，即ApplicationContext传入一个XML文件----XML文件转换为Resource流-----初始化工厂------读取Resource流中配置信息到BeanDefinition-----注册到工厂类----由之前的工厂类创立Bean对象，并且设置各种属性等
public class AbstractApplicationContext implements ApplicationContext{ public BeanFactory beanFactory; //工厂类，实现了工厂模式 @Override public Object getBean(Class clazz) throws Exception { return beanFactory.getBean(clazz); } @Override public Object getBean(String beanName) throws Exception { return beanFactory.getBean(beanName); }}
定义BeanDefinition
public class BeanDefinition { private Object bean; //实例化后的对象 private Class beanClass; private String beanClassName; private Boolean singleton; //是否为单例模式 private PropertyValues propertyValues; //这个也就是属性的键值对了 public Object getBean() { return bean; } public void setBean(Object bean) { this.bean = bean; } public Class getBeanClass() { return beanClass; } public void setBeanClass(Class beanClass) { this.beanClass = beanClass; } public String getBeanClassName() { return beanClassName; } public void setBeanClassName(String beanClassName) { this.beanClassName = beanClassName; try { this.beanClass = Class.forName(beanClassName); } catch (ClassNotFoundException e) { e.printStackTrace(); } } public PropertyValues getPropertyValues() { if(propertyValues == null) { propertyValues = new PropertyValues(); } return propertyValues; } public void setPropertyValues(PropertyValues propertyValues) { this.propertyValues = propertyValues; } public Boolean isSingleton() { return singleton; } public void setSingleton(Boolean singleton) { this.singleton = singleton; }}
定义ClassPathXmlApplicationContext
public class ClassPathXmlApplicationContext extends AbstractApplicationContext { private final Object startupShutdownMonitor = new Object(); private String location; public ClassPathXmlApplicationContext(String location) throws Exception { super(); this.location = location; refresh(); } public void refresh() throws Exception { synchronized (startupShutdownMonitor) { AbstractBeanFactory beanFactory = obtainBeanFactory(); prepareBeanFactory(beanFactory); this.beanFactory = beanFactory; } } private void prepareBeanFactory(AbstractBeanFactory beanFactory) throws Exception { beanFactory.populateBeans(); } private AbstractBeanFactory obtainBeanFactory() throws Exception { XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(new ResourceLoader()); beanDefinitionReader.loadBeanDefinitions(location); AbstractBeanFactory beanFactory = new AutowiredCapableBeanFactory(); for (Map.Entry<String, BeanDefinition> beanDefinitionEntry : beanDefinitionReader.getRegistry().entrySet()) { beanFactory.registerBeanDefinition(beanDefinitionEntry.getKey(), beanDefinitionEntry.getValue()); } return beanFactory; }}
定义XmlBeanDefinitionReader
/** * XML配置文件模式的Bean定义读取类 * * @author ziyang */public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader { public XmlBeanDefinitionReader(ResourceLoader resourceLoader) { super(resourceLoader); } @Override public void loadBeanDefinitions(String location) throws Exception { InputStream inputStream = getResourceLoader().getResource(location).getInputStream(); doLoadBeanDefinitions(inputStream); } protected void doLoadBeanDefinitions(InputStream inputStream) throws Exception { DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); DocumentBuilder documentBuilder = factory.newDocumentBuilder(); Document document = documentBuilder.parse(inputStream); // 解析xml document并注册bean registerBeanDefinitions(document); inputStream.close(); } public void registerBeanDefinitions(Document document) { Element root = document.getDocumentElement(); // 从文件根递归解析 parseBeanDefinitions(root); } protected void parseBeanDefinitions(Element root) { NodeList nodeList = root.getChildNodes(); for(int i = 0; i < nodeList.getLength(); i ++) { Node node = nodeList.item(i); if(node instanceof Element) { processBeanDefinition((Element) node); } } } protected void processBeanDefinition(Element ele) { String name = ele.getAttribute("id"); String className = ele.getAttribute("class"); boolean singleton = true; if(ele.hasAttribute("scope") && "prototype".equals(ele.getAttribute("scope"))) { singleton = false; } BeanDefinition beanDefinition = new BeanDefinition(); processProperty(ele, beanDefinition); beanDefinition.setBeanClassName(className); beanDefinition.setSingleton(singleton); getRegistry().put(name, beanDefinition); } private void processProperty(Element ele, BeanDefinition beanDefinition) { NodeList propertyNode = ele.getElementsByTagName("property"); for(int i = 0; i < propertyNode.getLength(); i ++) { Node node = propertyNode.item(i); if(node instanceof Element) { Element propertyEle = (Element) node; String name = propertyEle.getAttribute("name"); String value = propertyEle.getAttribute("value"); if(value != null && value.length() > 0) { // 优先进行值注入 beanDefinition.getPropertyValues().addPropertyValue(new PropertyValue(name, value)); } else { String ref = propertyEle.getAttribute("ref"); if(ref == null || ref.length() == 0) { throw new IllegalArgumentException("Configuration problem: <property> element for property '" + name + "' must specify a ref or value"); } BeanReference beanReference = new BeanReference(ref); beanDefinition.getPropertyValues().addPropertyValue(new PropertyValue(name, beanReference)); } } } }}
总结
- ClassPathXmlApplication传入xml文件的门路，并且在构造函数中调用refresh办法
- 在这个办法中由AbstractBeanFactory定义了一个工厂类，并且调用了obtainBeanFatcory办法，在办法中调用了XmlBeanDefinitionReader类，这个类将XML转换成Resource流，并且读取了其中的key和value值，value值就是BeanDefinition
- 由AutowiredCapableBeanFactory（主动装配工厂类）定义一个工厂，将上述的Key和Value注册到工厂中并且返回到下面定义的工厂类，行将BeanDefinition注册到工厂类中
- 最初调用prepareBeanFactory办法，层层嵌套后是调用doCreateBean办法，将对象中的属性注入对象中，返回Bean到工厂中，此时BeanDefinition中的bean中就是一个实例化后、具备属性设置的对象了
- 之后，你就能够通过ByName或者ByClass来获取你的对象了