spring作为一个轻量级容器,spring bean容器

　　00-1010什么是国际奥委会？工厂和Spring容器顺序：Bean定义获取顺序：资源加载顺序分发：Bean注册生产车间：对象工厂生产销售：测试大家好，我是第三个。Spring是我们最常用的开源框架。经过多年的发展，春天已经发展成为一棵枝繁叶茂的树，我们很难看到全貌。

　　这一节，我们回归春天的本质，五分钟内亲手挑选一个春天的容器，揭开春天的神秘面纱！

目录

春天——春天，Java编程世界的春天是由一位音乐家————罗德约翰逊带来的。

　　Rod Johnson写了两本很棒的书，《Expert One-on-One J2EE Design and Development》和《Expert One-on-One J2EE Development without EJB》，他们举起了挑战正统Java EE框架EJB的大旗。

　　Rod Johnson不仅是旗手，还开发了轻量级框架Spring。像一个勇敢的龙骑兵，他向EJB发起了进攻，并最终击败了EJB，使Spring成为Java EE事实上的标准。

　　Spring的两个核心是IOC和AOP，其中最重要的是IOC。

　　所谓IOC(Control Inversion):容器负责控制对象的生命周期和对象之间的关系。我们过去创造我们想要的，但现在我们需要的，容器会带给我们。

　　也就是说，引用它的不是对象，而是控制对象生命周期的容器。对于特定的对象，它过去控制其他对象，但现在所有的对象都由容器控制，所以这被称为控制反转.

　　你可能还会听到另一个概念，DI(dependency injection)，意思是当实例化一个对象时，容器会将它的依赖类注入其中。我们也可以认为DI是IOC的补充和实现。

从什么是IOC开始？

Spring是一个成熟的框架。为了满足扩展性，实现各种功能，它的实现就像一棵大树，枝干交织。现在让我们把目光从Spring本身移开，看看一个萌芽版本的Spring容器是如何实现的。

　　春天IOC的本质是一个大工厂。让我们想想一个工厂是如何运作的。

　　生产产品:工厂的核心功能是生产产品。在Spring中，Bean不是自己实例化的，而是交给Spring。应该如何实施？答案是毫无疑问的，反射.那么这个工厂的生产管理是怎么做的呢？你也应该知道工厂模式. 3354号

　　库存产品:一般来说，工厂都有储存产品的仓库。毕竟生产出来的产品不能马上带走。众所周知，Spring是一个容器，这个容器里存放的就是对象。不能每次都拿对象，要当场体现对象的创建，还要保存创建的对象。订单处理:还有最重要的一点，工厂提供产品的依据是什么？秩序。这些订单可能五花八门，有网签、厂签、上门销售……最后经过处理，指导工厂出货。在Spring中，也有这样的命令，它们是我们bean的定义和依赖。它们可以是xml形式或最常见的注释形式。

　　我们萌芽版对应的Spring容器是什么？

工厂和Spring容器

Bean可以由配置文件定义，我们将把它解析成一个类型。

　　beans.properties

　　为了偷懒，这里直接用了最方便的属性，Bean的定义用一个key和value类型的配置来表示，其中key是beanName，value是class。

　　userDao:cn.fighter3.bean.UserDaoBeanDefinition.java

　　bean定义了类，配置文件中的bean定义了相应的实体。

　　公共类BeanDefinition {私有字符串beanName私人中情局

　　ss beanClass; //省略getter、setter }

获取订单：资源加载

接下订单之后，就要由销售向生产部门交接，让生产部门知道商品的规格、数量之类。

　　资源加载器，就是来完成这个工作的，由它来完成配置文件中配置的加载。

public class ResourceLoader { public static Map<String, BeanDefinition> getResource() { Map<String, BeanDefinition> beanDefinitionMap = new HashMap<>(16); Properties properties = new Properties(); try { InputStream inputStream = ResourceLoader.class.getResourceAsStream("/beans.properties"); properties.load(inputStream); Iterator<String> it = properties.stringPropertyNames().iterator(); while (it.hasNext()) { String key = it.next(); String className = properties.getProperty(key); BeanDefinition beanDefinition = new BeanDefinition(); beanDefinition.setBeanName(key); Class clazz = Class.forName(className); beanDefinition.setBeanClass(clazz); beanDefinitionMap.put(key, beanDefinition); } inputStream.close(); } catch (IOException ClassNotFoundException e) { e.printStackTrace(); } return beanDefinitionMap; }}

订单分配：Bean注册

对象注册器，这里用于单例bean的缓存，我们大幅简化，默认所有bean都是单例的。可以看到所谓单例注册，也很简单，不过是往HashMap里存对象。

public class BeanRegister { //单例Bean缓存 private Map<String, Object> singletonMap = new HashMap<>(32); /** * 获取单例Bean * * @param beanName bean名称 * @return */ public Object getSingletonBean(String beanName) { return singletonMap.get(beanName); } * 注册单例bean * @param beanName * @param bean public void registerSingletonBean(String beanName, Object bean) { if (singletonMap.containsKey(beanName)) { return; } singletonMap.put(beanName, bean);}

生产车间：对象工厂

好了，到了我们最关键的生产部门了，在工厂里，生产产品的是车间，在IOC容器里，生产对象的是BeanFactory。

　　对象工厂，我们最核心的一个类，在它初始化的时候，创建了bean注册器，完成了资源的加载。获取bean的时候，先从单例缓存中取，如果没有取到，就创建并注册一个bean

public class BeanFactory { private Map<String, BeanDefinition> beanDefinitionMap = new HashMap<>(); private BeanRegister beanRegister; public BeanFactory() { //创建bean注册器 beanRegister = new BeanRegister(); //加载资源 this.beanDefinitionMap = new ResourceLoader().getResource(); } /** * 获取bean * * @param beanName bean名称 * @return */ public Object getBean(String beanName) { //从bean缓存中取 Object bean = beanRegister.getSingletonBean(beanName); if (bean != null) { return bean; } //根据bean定义，创建bean return createBean(beanDefinitionMap.get(beanName)); } /** * 创建Bean * * @param beanDefinition bean定义 * @return */ private Object createBean(BeanDefinition beanDefinition) { try { Object bean = beanDefinition.getBeanClass().newInstance(); //缓存bean beanRegister.registerSingletonBean(beanDefinition.getBeanName(), bean); return bean; } catch (InstantiationException IllegalAccessException e) { e.printStackTrace(); } return null; }}

生产销售：测试

UserDao.java

　　我们的Bean类，很简单

public class UserDao { public void queryUserInfo(){ System.out.println("A good man."); }}

单元测试

public class ApiTest { @Test public void test_BeanFactory() { //1.创建bean工厂(同时完成了加载资源、创建注册单例bean注册器的操作) BeanFactory beanFactory = new BeanFactory(); //2.第一次获取bean（通过反射创建bean，缓存bean） UserDao userDao1 = (UserDao) beanFactory.getBean("userDao"); userDao1.queryUserInfo(); //3.第二次获取bean（从缓存中获取bean） UserDao userDao2 = (UserDao) beanFactory.getBean("userDao"); userDao2.queryUserInfo(); }}

运行结果

A good man.A good man.

 

　　

至此，我们一个萌芽版的Spring容器就完成了。

　　考虑一下，它有哪些不足呢？是否还可以抽象、扩展、解耦……

　　细细想想这些东西，你是不是对真正的Spring IOC容器为何如此复杂，有所理解了呢？

　　参考：

　　[1]. 《Spring揭秘》

　　[2].小傅哥 《手撸Spring》

　　[3].《精通Spring4.X企业应用开发实战》

　　到此这篇关于五分钟，手撸一个Spring容器的文章就介绍到这了,更多相关Spring容器内容请搜索盛行IT以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。