编码剖析Spring装配基本属性的原理

上回我们已经讲到了Spring依赖注入的第一种方式,现在我们来详解第二种方式,须知这一切都是以编码剖析Spring依赖注入的原理案例为基础的。 
我们将Spring的配置文件——beans.xml的内容改为:

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

    <!-- 依赖注入的第一种方式 -->
    <!--
    <bean id="personDao" class="cn.itcast.dao.impl.PersonDaoBean"></bean>
    <bean id="personService" class="cn.itcast.service.impl.PersonServiceBean">
        <property name="personDao" ref="personDao"></property>
    </bean>
    -->
    <!-- 依赖注入第二种方式: -->
    <bean id="personService" class="cn.itcast.service.impl.PersonServiceBean">
        <property name="personDao">
            <bean class="cn.itcast.dao.impl.PersonDaoBean"></bean>
        </property>
    </bean>

</beans>

这种方式是使用内部bean依赖注入,其缺点就是:该bean不能被其他bean使用。 
接下来将测试类——SpringTest.java的代码改为:

public class SpringTest {

    @Test
    public void test() {
        AbstractApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
        PersonService personService = (PersonService) ctx.getBean("personService");
        personService.save();
        ctx.close(); // 正常关闭Spring容器
    }

}

测试test()方法,将发现Eclipse控制台打印: 

接下来,我们将讲解基本类型对象的依赖注入。

Spring装配基本属性

首先我们将PersonServiceBean类的代码改为:

public class PersonServiceBean implements PersonService {
    private PersonDao personDao;
    private String name;
    private Integer id;

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public PersonDao getPersonDao() {
        return personDao;
    }

    public void setPersonDao(PersonDao personDao) {
        this.personDao = personDao;
    }

    @Override
    public void save() {
        System.out.println("id = " + id + ", name = " + name);
        personDao.add();
    }
}

接着我们要将Spring的配置文件的内容改为:

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

    <!-- 依赖注入的第一种方式 -->
    <!--
    <bean id="personDao" class="cn.itcast.dao.impl.PersonDaoBean"></bean>
    <bean id="personService" class="cn.itcast.service.impl.PersonServiceBean">
        <property name="personDao" ref="personDao"></property>
    </bean>
    -->
    <!-- 依赖注入第二种方式: -->
    <bean id="personService" class="cn.itcast.service.impl.PersonServiceBean">
        <property name="personDao">
            <bean class="cn.itcast.dao.impl.PersonDaoBean"></bean>
        </property>
        <!-- 为基本类型属性注入值  -->
        <property name="name" value="itcast" />
        <property name="id" value="88" />
    </bean>

</beans>

最后测试SpringTest类的test()方法,将发现Eclipse控制台打印: 

到这里,自然就会产生一个疑问——Spring内部是如何注入基本类型对象的呢?有了疑问,我们接下来就来深入剖析其中的原理。

编码剖析Spring装配基本属性的原理

我们应确保Spring的配置文件——beans.xml的内容为:

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

    <!-- 依赖注入的第一种方式 -->
    <!--
    <bean id="personDao" class="cn.itcast.dao.impl.PersonDaoBean"></bean>
    <bean id="personService" class="cn.itcast.service.impl.PersonServiceBean">
        <property name="personDao" ref="personDao"></property>
    </bean>
    -->
    <!-- 依赖注入第二种方式: -->
    <bean id="personDao" class="cn.itcast.dao.impl.PersonDaoBean"></bean>
    <bean id="personService" class="cn.itcast.service.impl.PersonServiceBean">
        <property name="personDao" ref="personDao"></property>
        <!-- 为基本类型属性注入值  -->
        <property name="name" value="itcast" />
        <property name="id" value="88" />
    </bean>

</beans>

对照以上Spring的配置文件的内容,我们应该修改PropertyDefinition类的代码为:

/**
 * 该JavaBean专门用户存放<property ...>的信息
 * @author li ayun
 *
 */
public class PropertyDefinition {
    private String name;
    private String ref;
    private String value;

    public PropertyDefinition(String name, String ref, String value) {
        this.name = name;
        this.ref = ref;
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getRef() {
        return ref;
    }
    public void setRef(String ref) {
        this.ref = ref;
    }
}
  • 1

接下来我们就要对传智播客版的Spring容器修修改改了,由于我们要将把本身为字符串的值转成相应的属性类型的值,所以就要用到commons-beanutils工具,即要将commons-beanutils-1.9.2.jar包导入到项目中去。这样,ItcastClassPathXMLApplicationContext类的代码就应该为:

/**
 * 传智播客版Spring容器
 * @author li ayun
 *
 */
public class ItcastClassPathXMLApplicationContext {
    private List<BeanDefinition> beanDefines = new ArrayList<BeanDefinition>();
    private Map<String, Object> sigletons = new HashMap<String, Object>();

    public ItcastClassPathXMLApplicationContext(String filename) {
        this.readXML(filename);
        this.instanceBeans();
        this.injectObject();
    }

    /**
     * 为bean对象的属性(依赖)注入值
     */
    private void injectObject() {
        for (BeanDefinition beanDefinition : beanDefines) {
            Object bean = sigletons.get(beanDefinition.getId());
            if (bean != null) {
                try {
                    PropertyDescriptor[] ps = Introspector.getBeanInfo(bean.getClass()).getPropertyDescriptors();
                    for (PropertyDefinition propertyDefinition : beanDefinition.getPropertys()) {
                        for (PropertyDescriptor propertyDesc : ps) {
                            if (propertyDefinition.getName().equals(propertyDesc.getName())) {
                                Method setter = propertyDesc.getWriteMethod(); // 获取属性的setter方法,若setter方法是private的
                                if (setter != null) { // 最好判断有无setter方法,因为属性可以没有setter方法
                                    Object value = null;
                                    if (propertyDefinition.getRef() != null && !"".equals(propertyDefinition.getRef().trim()) ) {
                                        value = sigletons.get(propertyDefinition.getRef());
                                    } else { // 注入基本类型
                                        value = ConvertUtils.convert(propertyDefinition.getValue(), propertyDesc.getPropertyType()); // 把本身为字符串的值转成相应的属性类型的值
                                    }
                                    setter.setAccessible(true); // 允许访问私有的setter方法
                                    setter.invoke(bean, value); // 把引用对象注入到属性中
                                }
                                break;
                            }
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 完成bean的实例化
     */
    private void instanceBeans() {
        for (BeanDefinition beanDefinition : beanDefines) {
            try {
                if (beanDefinition.getClassName() != null && !"".equals(beanDefinition.getClassName().trim())) {
                    sigletons.put(beanDefinition.getId(), Class.forName(beanDefinition.getClassName()).newInstance());
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 读取XML配置文件
     * @param filename
     */
    private void readXML(String filename) {
        SAXReader saxReader = new SAXReader();
        Document document = null;
        try {
            URL xmlpath = this.getClass().getClassLoader().getResource(filename);
            document = saxReader.read(xmlpath);
            Map<String, String> nsMap = new HashMap<String, String>();
            nsMap.put("ns", "http://www.springframework.org/schema/beans"); // 加入命名空间
            XPath xsub = document.createXPath("//ns:beans/ns:bean"); // 创建beans/bean查询路径
            xsub.setNamespaceURIs(nsMap); // 设置命名空间
            List<Element> beans = xsub.selectNodes(document); // 获取文档下所有bean节点
            for (Element element : beans) {
                String id = element.attributeValue("id"); // 获取id属性值
                String clazz = element.attributeValue("class"); // 获取class属性值
                BeanDefinition beanDefine = new BeanDefinition(id, clazz);

                XPath propertysub = element.createXPath("ns:property");
                propertysub.setNamespaceURIs(nsMap); // 设置命名空间
                List<Element> propertys = propertysub.selectNodes(element);
                for (Element property : propertys) {
                    String propertyName = property.attributeValue("name");
                    String propertyRef = property.attributeValue("ref");
                    // System.out.println(propertyName + "=" + propertyRef); // 测试用

                    String propertyValue = property.attributeValue("value");

                    PropertyDefinition propertyDefinition = new PropertyDefinition(propertyName, propertyRef, propertyValue);
                    beanDefine.getPropertys().add(propertyDefinition);
                }

                beanDefines.add(beanDefine);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取bean实例
     * @param beanName
     * @return
     */
    public Object getBean(String beanName) {
        return this.sigletons.get(beanName);
    }
}
  • 1

最后,我们就要对传智播客版的Spring容器测试一把了,看它是否真能如我们所想的那样完成对基本类型对象的注入。我们修改单元测试SpringTest类的代码为:

public class SpringTest {

    @Test
    public void test() {
        ItcastClassPathXMLApplicationContext ctx = new ItcastClassPathXMLApplicationContext("beans.xml");
        PersonService personService = (PersonService) ctx.getBean("personService");
        personService.save();
    }

}

测试test(),可看到Eclipse控制台打印: 
 
这就已说明模拟Spring容器成功了,我们也对其中的原理有了更深刻的认识。如要查看源码,可点击编码剖析Spring装配基本属性的原理进行下载。

时间: 2024-10-26 13:07:16

编码剖析Spring装配基本属性的原理的相关文章

编码剖析Spring依赖注入的原理

Spring的依赖注入 前面我们就已经讲过所谓依赖注入就是指:在运行期,由外部容器动态地将依赖对象注入到组件中. Spring的依赖注入有两种方式: 通过构造器参数,让容器把创建好的依赖对象注入. 使用setter方法进行注入. 现在我们使用第二种方式进行依赖注入.以Spring管理的Bean的生命周期的案例为基础展开本文的说明. 首先在src目录下新建一个cn.itcast.dao包,并在该包下新建一个接口——PersonDao.java,其代码为: public interface Pers

编码剖析Spring管理Bean的原理

在Spring的第一个案例中,我们已经知道了怎么将bean交给Spring容器进行管理,并且明白了怎么从Spring容器中获取bean.那我们就有一个疑问了:Spring是如何创建并管理bean的呢?现在我们就来编码剖析Spring管理Bean的原理. 本文是在Spring的第一个案例的基础上展开的. 我们要使用dom4j读取Sping的配置文件--beans.xml <?xml version="1.0" encoding="UTF-8"?> <

深入探索spring技术内幕(二): 剖析spring管理Bean的原理与配置

求二叉树的宽度和深度 给定一个二叉树,获取该二叉树的宽度和深度. 例如输入 a / \ b c / \ / \ d e f g 返回3. 详细描述: 接口说明 原型: int GetBiNodeInfo(BiNode &head, unsigned int *pulWidth, unsigned int *pulHeight) 输入参数: head 需要获取深度的二叉树头结点 输出参数(指针指向的内存区域保证有效): pulWidth 宽度 pulHeight 高度 返回值: 0 成功 1 失败

Spring(八)编码剖析@Resource注解的实现原理

beans2.xml <?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:context="http://www.springframew

Spring2.5学习2.2_编码剖析Spring依赖注入原理

为了便于理解Spring属性注入,这里来模拟Spring容器是如何实现将PersonDaoBean注入到PersonServiceBean的. 所需jar包:下载地址http://download.csdn.net/detail/jeofey/8747927 PersonDaoBean.java [java] view plaincopy package xjj.dao.impl; import xjj.dao.PersonDao; public class PersonDaoBean impl

Spring2.5学习3.2_编码剖析@Resource注解的实现原理

首先看一下J2EE提供的@Resource注解:该注解默认安照名称进行装配,名称能够通过name属性进行指定, 假设没有指定name属性,当注解写在字段上时,默认取字段名进行依照名称查找,假设注解写在setter方法上默认取属性名进行装配. 当找不到与名称匹配的bean时才依照类型进行装配.可是须要注意的是,假设name属性一旦指定.就仅仅会依照名称进行装配. 这里我们模拟@Resource注解,便于理解注解的实现原理: 1.首先在前面模拟的容器中加入注入的方法annotationInject(

Spring框架和MVC原理

Spring框架和MVC原理 目录 Spring框架 SpringMVC工作原理 参考资料 回到顶部 Spring框架 Spring当前框架有20个jar包,大致可以分为6大模块: Core Container AOP and Instrumentation Messaging Data Access/Integration Web Test Spring框架提供了非常丰富的功能,因此整个架构也很庞大. 在我们实际的应用开发中,并不一定要使用所有的功能,而是可以根据需要选择合适的Spring模块

Spring Boot自动配置原理(转)

第3章 Spring Boot自动配置原理 3.1 SpringBoot的核心组件模块 首先,我们来简单统计一下SpringBoot核心工程的源码java文件数量: 我们cd到spring-boot-autoconfigure工程根目录下.执行 $ tree | grep -c .java$ 模块 java文件数 spring-boot 551 spring-boot-actuator 423 spring-boot-autoconfigure 783 spring-boot-devtools

好程序员Java干货分享Spring框架之IOC原理

好程序员Java干货分享Spring框架之IOC原理,前言:Spring框架是我们进行企业级开发的最常用框架,本章我们将了解Spring框架,并学习Spring的IOC特性以及IOC的实现原理:注解和反射. Spring框架简介 Spring是一种轻量级的控制反转(IOC)和面向切面编程(AOP)的容器框架,能够为企业级开发提供一站式服务. Spring的优点有 1.方便解耦,简化开发 通过Spring提供的IoC容器,我们可以将对象之间的依赖关系交由Spring进行控制,避免硬编码所造成的过度