Spring 学习日记（二）BeanFactory小议

最新推荐文章于 2024-01-19 20:22:20 发布

大萌萌德

最新推荐文章于 2024-01-19 20:22:20 发布

阅读量332

点赞数

分类专栏： spring 文章标签： spring

本文链接：https://blog.csdn.net/u011685720/article/details/49861657

版权

spring 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

首先IOC 有四步骤初始化 - 定位 - 载入 - 解析 -注册

首先看一段配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns:aop="http://www.springframework.org/schema/aop"
         xmlns:tx="http://www.springframework.org/schema/tx"
         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd">

    <!-- 使用spring管理对象的创建，还有对象的依赖关系 -->
    <bean id="userDao4Mysql" class="com.tgb.spring.dao.UserDao4MysqlImpl"/>

    <bean id="userDao4Oracle" class="com.tgb.spring.dao.UserDao4OracleImpl"/>

    <bean id="userManager" class="com.tgb.spring.manager.UserManagerImpl">
        <!-- (1)userManager使用了userDao，Ioc是自动创建相应的UserDao实现，都是由容器管理-->
        <!-- (2)在UserManager中提供构造函数，让spring将UserDao实现注入（DI）过来 -->
        <!-- (3)让spring管理我们对象的创建和依赖关系，必须将依赖关系配置到spring的核心配置文件中 -->

        <property name="userDao" ref="userDao4Oracle"></property>
    </bean>

</beans>

可以看出容器之中是根据配置文件自动桥接的并且是注入的方式导入Dao层

    public static void main(String[] args){  

        BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");  
        //到IOC容器中获取UserManager  
        UserManager userManager = (UserManager) factory.getBean("userManager");  
        //UserManager使用UserDao，在配置文件已经有依赖关系  
        userManager.addUser("jiuqiyuliang", "123456");        
    }

最后直接通过容器或者可以理解成工厂模式调用dao层的方法

附上这一类接口层的关系图

这里写图片描述

ListableBeanFactory 接口表示这些 Bean 是可列表的而 HierarchicalBeanFactory 表示的是这些 Bean 是有继承关系的所以每一个接口都是有自己的用处的具体的还是多查API 有很大帮助的

附上一个小栗子

public interface BeanFactory {

    /**
     * Used to dereference a {@link FactoryBean} instance and distinguish it from
     * beans <i>created</i> by the FactoryBean.
     * 对FactoryBean的转义定义，因为如果使用bean的名字检索FactoryBean得到的对象是工厂生成的对象，    
     * 如果需要得到工厂本身，需要转义 
     */
    String FACTORY_BEAN_PREFIX = "&";

    /**
     * Return an instance, which may be shared or independent, of the specified bean.
     * 根据bean的名字，获取在IOC容器中得到bean实例
     */
    Object getBean(String name) throws BeansException;

    /**
     * Return an instance, which may be shared or independent, of the specified bean.
     * 根据bean的名字和Class类型来得到bean实例，增加了类型安全验证机制。
     */
    <T> T getBean(String name, Class<T> requiredType) throws BeansException;

    /**
     * Return the bean instance that uniquely matches the given object type, if any.
     * 根据Class类型来得到bean实例，增加了类型安全验证机制。
     */
    <T> T getBean(Class<T> requiredType) throws BeansException;

    /**
     * Return an instance, which may be shared or independent, of the specified bean.
     *
     */
    Object getBean(String name, Object... args) throws BeansException;

    /**
     * Return an instance, which may be shared or independent, of the specified bean.

     */
    <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

    /**
     * Does this bean factory contain a bean definition or externally registered singleton
     * instance with the given name?
     * 提供对bean的检索，看看是否在IOC容器有这个名字的bean  
     */
    boolean containsBean(String name);

    /**
     * Is this bean a shared singleton? That is, will {@link #getBean} always
     * return the same instance?
     * 根据bean名字得到bean实例，并同时判断这个bean是不是单例 
     */
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

    /**
     * Is this bean a prototype? That is, will {@link #getBean} always return
     * independent instances?
     */
    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

    /**
     * Check whether the bean with the given name matches the specified type.
     * More specifically, check whether a {@link #getBean} call for the given name
     * would return an object that is assignable to the specified target type.
     * 
     */
    boolean isTypeMatch(String name, Class<?> targetType) throws NoSuchBeanDefinitionException;

    /**
     * Determine the type of the bean with the given name. More specifically,
     * determine the type of object that {@link #getBean} would return for the given name.
     * 得到bean实例的Class类型
     */
    Class<?> getType(String name) throws NoSuchBeanDefinitionException;

    /**
     * Return the aliases for the given bean name, if any.
     * All of those aliases point to the same bean when used in a {@link #getBean} call.
     * 得到bean的别名，如果根据别名检索，那么其原名也会被检索出来
     */
    String[] getAliases(String name);

具体来看一两个方法吧

loadBeanDefinitions();//加载bean的定义，同样是通过用被指定的编码方式来读取流xml资源文件。同样返回定义的bean的数量

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
        Assert.notNull(encodedResource, "EncodedResource must not be null");
        if (logger.isInfoEnabled()) {
            logger.info("Loading XML bean definitions from " + encodedResource.getResource());
        }

        try {
            InputStream inputStream = encodedResource.getResource().getInputStream();
            try {
                InputSource inputSource = new InputSource(inputStream);
                if (encodedResource.getEncoding() != null) {//如果指定了编码方式，就用指定的编码为流的编码                    inputSource.setEncoding(encodedResource.getEncoding());
                }//这类调用该方式真正的做到了加载bean定义
                return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
            }
            finally {//关闭流
                inputStream.close();
            }
        }
        catch (IOException ex) {
            throw new BeanDefinitionStoreException(
                    "IOException parsing XML document from " + encodedResource.getResource(), ex);
        }
    }

doLoadBeanDefinitions();该方法真正完成加载bean定义的工作

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
            throws BeanDefinitionStoreException {
        try {//取得xml文件的文档验证方式，比如dtd，xsd。
            int validationMode = getValidationModeForResource(resource);//加载器加载xml文件。
            Document doc = this.documentLoader.loadDocument(
                    inputSource, this.entityResolver, this.errorHandler, validationMode, this.namespaceAware);//调用下面介绍的方法注册bean到工厂
            return registerBeanDefinitions(doc, resource);
        }
        catch (BeanDefinitionStoreException ex) {
            throw ex;
        }
        catch (ParserConfigurationException ex) {
            throw new BeanDefinitionStoreException(
                    "Parser configuration exception parsing XML from " + resource, ex);
        }
        catch (SAXParseException ex) {
            throw new BeanDefinitionStoreException(
                    "Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
        }
        catch (SAXException ex) {
            throw new BeanDefinitionStoreException("XML document from " + resource + " is invalid", ex);
        }
        catch (IOException ex) {
            throw new BeanDefinitionStoreException("IOException parsing XML document from " + resource, ex);
        }
        catch (Throwable ex) {
            throw new BeanDefinitionStoreException("Unexpected exception parsing XML document from " + resource, ex);
        }
    }

registerBeanDefinitions();这里完成注册bean到工厂的工作。

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
                if (this.parserClass != null) {//拿到解析器负责从xml解析定义的bean，并负责将它们注册到工厂
            XmlBeanDefinitionParser parser =
                    (XmlBeanDefinitionParser) BeanUtils.instantiateClass(this.parserClass);
            return parser.registerBeanDefinitions(this, doc, resource);
        }//若解析器为null，就创建一个documentReader ，把解析bean定义并注册bean到工厂的工作交给它完成
        BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
        int countBefore = getBeanFactory().getBeanDefinitionCount();
        documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
        return getBeanFactory().getBeanDefinitionCount() - countBefore;
    }

其实仔细看一下的话这个和之前那个源码解析的差不多大概就是这么个顺序

附录几个读取资源的方法

//一: XmlBeanFactory 引用资源 

Resource resource = new ClassPathResource("appcontext.xml"); 
BeanFactory factory = new XmlBeanFactory(resource); 

//二: ClassPathXmlApplicationContext  编译路径 

ApplicationContext factory=new ClassPathXmlApplicationContext("classpath:appcontext.xml"); 
// src目录下的 
ApplicationContext factory=new ClassPathXmlApplicationContext("appcontext.xml"); 
ApplicationContext factory=new ClassPathXmlApplicationContext(new String[] {"bean1.xml","bean2.xml"}); 
// src/conf 目录下的 
ApplicationContext factory=new ClassPathXmlApplicationContext("conf/appcontext.xml"); 
ApplicationContext factory=new ClassPathXmlApplicationContext("file:G:/Test/src/appcontext.xml"); 

//三: 用文件系统的路径 

ApplicationContext factory=new FileSystemXmlApplicationContext("src/appcontext.xml"); 
//使用了  classpath:  前缀,作为标志,  这样,FileSystemXmlApplicationContext 也能够读入classpath下的相对路径 
ApplicationContext factory=new FileSystemXmlApplicationContext("classpath:appcontext.xml"); 
ApplicationContext factory=new FileSystemXmlApplicationContext("file:G:/Test/src/appcontext.xml"); 
ApplicationContext factory=new FileSystemXmlApplicationContext("G:/Test/src/appcontext.xml"); 

//四: XmlWebApplicationContext是专为Web工程定制的。 

ServletContext servletContext = request.getSession().getServletContext(); 
ApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(servletContext ); 

//五: 使用BeanFactory 

BeanDefinitionRegistry reg = new DefaultListableBeanFactory(); 
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(reg); 
reader.loadBeanDefinitions(new ClassPathResource("bean1.xml")); 
reader.loadBeanDefinitions(new ClassPathResource("bean2.xml")); 
BeanFactory bf=(BeanFactory)reg; 

//六：Web 应用启动时加载多个配置文件 

//通过ContextLoaderListener 也可加载多个配置文件，在web.xml文件中利用 
//<context-pararn>元素来指定多个配置文件位置，其配置如下: 

<context-param>  
    <!-- Context Configuration locations for Spring XML files -->  
       <param-name>contextConfigLocation</param-name>  
       <param-value>  
       ./WEB-INF/**/Appserver-resources.xml,  
       classpath:config/aer/aerContext.xml,  
       classpath:org/codehaus/xfire/spring/xfire.xml,  
       ./WEB-INF/**/*.spring.xml  
       </param-value>  
   </context-param>  

//这个方法加载配置文件的前提是已经知道配置文件在哪里，虽然可以利用“*”通配符，但灵活度有限。

大萌萌德

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring 学习日记（二）BeanFactory小议

首先IOC 有四步骤初始化 - 定位 - 载入 - 解析 -注册首先看一段配置文件<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instan
复制链接

扫一扫

专栏目录