Spring IoC — 基于XML的配置

原文:Spring IoC — 基于XML的配置

1、属性注入

注意点：

1）如果类中显示定义了一个带参的构造函数，则一定还要显示提供一个无参构造函数，否则使用属性注入时将抛出异常。

2）JavaBean关于属性命名的特殊规范。Spring只会检查Bean中是否有对应的Setter方法，至于Bean中是否有对应的属性变量则不做要求。如maxSpeed对应setMaxSpeed()，brand对应setBrand()。

所以<property>元素的属性变量名应满足：xxx的属性对应setXxx(）方法。变量的前两个字母要么全部大写，要么全部小写。

 

Car类：

package com.ioc.ch4_3_1;
/**
 * Created by gao on 16-3-25.
 */
public class Car {
    private int maxSpeed;
    public String brand;
    private double price;
    public Car() {
    }
    public Car(int maxSpeed, String brand, double price) {
        this.maxSpeed = maxSpeed;
        this.brand = brand;
        this.price = price;
    }
    public void setMaxSpeed(int maxSpeed) {
        this.maxSpeed = maxSpeed;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public int getMaxSpeed() {
        return maxSpeed;
    }
    public String getBrand() {
        return brand;
    }
    public double getPrice() {
        return price;
    }
    public String toString() {
        return "brand:" + brand + "/maxSpeed:" + maxSpeed + "/price:" + price;
    }
}

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-3.0.xsd">
    <bean id="car" class="com.ioc.ch4_3_1.Car">
        <property name="maxSpeed"><value>300</value></property>
        <property name="brand"><value>奥迪</value></property>
        <property name="price"><value>150000.00</value></property>
    </bean>
</beans>

测试类：

package com.ioc.ch4_3_1;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * Created by gao on 16-3-25.
 */
public class Test {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:com\\ioc\\ch4_3_1\\beans.xml");
        Car car = (Car) ctx.getBean("car");
        System.out.println(car.toString());
    }
}

输出结果：

brand:奥迪/maxSpeed:300/price:150000.0

 

2、构造函数注入

注意点：循环依赖问题。Spring容器能顺利实例化以构造函数注入方式配置的Bean有一个前提是：Bean构造函数入参引用的对象必须已经准备就绪。如果两个Bean都采用构造函数注入，而且都通过构造函数入参引用对方，则会发生循环依赖问题。这时可以将构造函数注入方式调整为属性注入方式。

Car类：

package com.ioc.ch4_3_2;
/**
 * Created by gao on 16-3-25.
 */
public class Car {
    private int maxSpeed;
    public String brand;
    private double price;
    private String corp;
    public Car() {
    }
    public Car(String brand, double price) {
        this.brand = brand;
        this.price = price;
    }
    public Car(int maxSpeed, String brand, double price) {
        this.maxSpeed = maxSpeed;
        this.brand = brand;
        this.price = price;
    }
    public Car(String brand, String corp, int maxSpeed) {
        this.brand = brand;
        this.corp = corp;
        this.maxSpeed = maxSpeed;
    }
    public void setMaxSpeed(int maxSpeed) {
        this.maxSpeed = maxSpeed;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public String getCorp() {
        return corp;
    }
    public void setCorp(String corp) {
        this.corp = corp;
    }
    public int getMaxSpeed() {
        return maxSpeed;
    }
    public String getBrand() {
        return brand;
    }
    public double getPrice() {
        return price;
    }
    public String toString() {
        return "brand:" + brand + "\tmaxSpeed:" + maxSpeed + "\tprice:" + price + "\tcorp:" + corp;
    }
}

Boss类：

package com.ioc.ch4_3_2;
public class Boss {
    private String name;
    private Car car;
    private Office office;
    public Boss(String name, Car car, Office office) {
        this.name = name;
        this.car = car;
        this.office = office;
    }
    public Boss(String name, Car car) {
        this.name = name;
        this.car = car;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Car getCar() {
        return car;
    }
    public void setCar(Car car) {
        this.car = car;
    }
    public String toString(){
        return "name:"+name+"\tcar:"+car.getBrand()+"\toffice:"+office;
    }
}

Office类：

package com.ioc.ch4_3_2;
public class Office {

}

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-3.0.xsd">
    <!--构造函数注入：type -->
    <bean id="car1" class="com.ioc.ch4_3_2.Car">
        <constructor-arg type="java.lang.String">
            <value>car1_甲壳虫</value>
        </constructor-arg>
        <constructor-arg type="double">
            <value>300000.0</value>
        </constructor-arg>
    </bean>
    <!--构造函数注入：index-->
    <bean id="car2" class="com.ioc.ch4_3_2.Car">
        <constructor-arg index="0" value="300"/>
        <constructor-arg index="1" value="car2_宝马"/>
        <constructor-arg index="2" value="200000.0"/>
    </bean>
    <!--构造函数注入：type&index -->
    <bean id="car3" class="com.ioc.ch4_3_2.Car">
        <constructor-arg index="0" type="java.lang.String">
            <value>car3_红旗CA72</value>
        </constructor-arg>
        <constructor-arg index="1" type="java.lang.String">
            <value>中国一汽</value>
        </constructor-arg>
        <constructor-arg index="2" type="int">
            <value>200</value>
        </constructor-arg>
    </bean>
    <!--构造函数注入：自动识别入参类型 -->
    <bean id="boss1" class="com.ioc.ch4_3_2.Boss">
        <constructor-arg>
            <value>John</value>
        </constructor-arg>
        <constructor-arg>
            <ref bean="car1" />
        </constructor-arg>
        <constructor-arg>
            <ref bean="office" />
        </constructor-arg>
    </bean>
    <bean id="car" class="com.ioc.ch4_3_2.Car"/>
    <bean id="office" class="com.ioc.ch4_3_2.Office" />
 </beans>

测试类：

package com.ioc.ch4_3_2;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * Created by gao on 16-3-25.
 */
public class Test {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:com\\ioc\\ch4_3_2\\beans.xml");
        Car car1 = (Car) ctx.getBean("car1");
        System.out.println(car1.toString());
        System.out.println("--------------------------------");
        Car car2 = (Car) ctx.getBean("car2");
        System.out.println(car2.toString());
        System.out.println("--------------------------------");
        Car car3 = (Car) ctx.getBean("car3");
        System.out.println(car3.toString());
        System.out.println("--------------------------------");
        Boss boss1 = (Boss) ctx.getBean("boss1");
        System.out.println(boss1.toString());
    }
}

输出结果：

brand:car1_甲壳虫 maxSpeed:0 price:300000.0 corp:null

--------------------------------

brand:car2_宝马 maxSpeed:300 price:200000.0 corp:null

--------------------------------

brand:car3_红旗CA72 maxSpeed:200 price:0.0 corp:中国一汽

--------------------------------

name:John car:car1_甲壳虫 office:com.ioc.ch4_3_2.Office@9eed10a

 

3、工厂方法注入

有非静态工厂方法和静态工厂方法两种方式

Car类：

package com.ioc.ch4_3_3;
/**
 * Created by gao on 16-3-25.
 */
public class Car {
    private int maxSpeed;
    public String brand;
    private double price;
    public Car() {
    }
    public Car(int maxSpeed, String brand, double price) {
        this.maxSpeed = maxSpeed;
        this.brand = brand;
        this.price = price;
    }
    public void setMaxSpeed(int maxSpeed) {
        this.maxSpeed = maxSpeed;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public int getMaxSpeed() {
        return maxSpeed;
    }
    public String getBrand() {
        return brand;
    }
    public double getPrice() {
        return price;
    }
    public String toString() {
        return "brand:" + brand + "\tmaxSpeed:" + maxSpeed + "\tprice:" + price;
    }
}

CarFactory类：

package com.ioc.ch4_3_3;
public class CarFactory {
    //创建Car的工厂方法
   public Car createHongQiCar(){
       Car car = new Car();
       car.setBrand("car5_奔驰");
       return car;
   }
   //工厂类方法是静态的
   public static Car createCar(){
       Car car = new Car();
       return car;
   }
}

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-3.0.xsd">
    <bean id="carFactory" class="com.ioc.ch4_3_3.CarFactory"/>
    <bean id="car5" factory-bean="carFactory" factory-method="createHongQiCar"/>
    <bean id="car6" class="com.ioc.ch4_3_3.CarFactory" factory-method="createCar"/>
 </beans>

测试类：

package com.ioc.ch4_3_3;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * Created by gao on 16-3-25.
 */
public class Test {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:com\\ioc\\ch4_3_3\\beans.xml");
        Car car5 = (Car) ctx.getBean("car5");
        System.out.println(car5.toString());
        System.out.println("-----------------------");
        Car car6 = (Car) ctx.getBean("car6");
        System.out.println(car6.toString());
    }
}

输出结果：

brand:car5_奔驰 maxSpeed:0 price:0.0

-----------------------

brand:null maxSpeed:0 price:0.0

 

注入方法的考量：

1）支持使用构造函数注入的理由：

    · 构造函数可以保证一些重要的属性在Bean实例化时就设置好，避免了因为一些重要属性没有提供，导致一个无用Bean实例的情况；

    · 不需要为每个属性提供Setter方法，减少了类的方法个数；    

    · 可以更好地封装类变量，不需要为每个属性指定setter方法，避免外部错误的调用。

2）更多的开发者更倾向于使用属性注入方式，反对构造函数注入的理由：

    · 如果一个类的属性众多，构造函数的签名将变成一个庞然大物，可读性很差；

    · 灵活性不强，在有些属性是可选的情况下，如果通过构造函数注入，也需要为可选的参数提供一个null值；

    · 如果有多个构造函数，需要考虑配置文件和具体构造函数匹配歧义的问题，配置上相对复杂；

    · 构造函数不利于类的继承和扩展，因为子类需要引用到父类复杂的构造函数；

    · 构造函数注入有时会造成循环依赖的问题。

3）对于一个全新的应用来说，不推荐使用工厂方法的注入方式。

 

 

 

时间： 2024-07-28 17:32:24

Spring IoC — 基于XML的配置的相关文章

Spring IoC — 基于注解的配置

原文:Spring IoC - 基于注解的配置 基于XML的配置,Bean定义信息和Bean实现类本身是分离的,而采用基于注解的配置方式时,Bean定义信息即通过在Bean实现类上标注注解实现. @Component:对类进行标注,Spring容器自动将POJO转换为容器管理的Bean: @Repository:用于对DAO实现类进行标注: @Service:用于对Service实现类进行标注: @Controller:用于对Controller实现类进行标注.   1.自动装配Bean:  

Spring IoC — 基于Java类的配置

原文:Spring IoC - 基于Java类的配置 普通的POJO只要标注@Configuration注解,就可以为Spring容器提供Bean定义的信息了,每个标注了@Bean的类方法都相当于提供一个Bean的定义信息. 基于Java类的配置方法和基于XML或基于注解的配置方式相比,前者通过代码的方式更加灵活地实现Bean的实例化及Bean之间的装配,但后面两者都是通过配置声明的方式,在灵活性上要稍逊一些,但是配置上要更简单一些.   UserDao类: package com.ioc.ch

Spring中基于Java的配置@Configuration和@Bean用法

Spring中为了减少xml中配置,可以创建一个配置类(例如ExampleConfiguration)来对bean进行配置. 1.配置spring配置文件来启用Java注解 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.o

spring如何在xml里配置Calendar，Date

文章地址:http://blog.csdn.net/hengyunabc/article/details/14107963 在Spring MVC里可以通过message converter机制来对数据进行格式化,但是在普通的Spring xml配置里就无能为力了. 在网上找了一通,发现也有很多人苦恼这个问题,不妨记录下. Spring 自带一个PropertyEditor的机制,但是这个是全局的,假如你的配置文件要是和别人有不同的话,那就悲剧了,比如你配置的时间的格式是"yyyy-mm-dd&

《Spring攻略（第2版）》——1.2　配置Spring IoC容器中的Bean

1.2 配置Spring IoC容器中的Bean 1.2.1 问题 Spring提供了一个强大的IoC容器来管理组成应用的bean.为了利用容器服务,你必须配置运行于Spring IoC容器中的Bean. 1.2.2 解决方案 你可以通过XML文件.属性文件.注释甚至API来配置Spring IoC容器中的Bean. Spring允许你在一个或者多个bean配置文件中配置bean.对于简单的应用程序,可以在单个配置文件中集中配置bean.但是对于有许多bean的大型应用,你应该根据其功能(例如控

从spring的IOC说起（二）——spring的Bean的基础配置

上次简单的说了下spring的IOC,也说到了spring的IOC强大在于有一系列可 以维护Bean不同关系的维护类的存在,而这样的维护也是基于高度可配置的 spring配置文件而言的.这次就是结合我的使用spring的IOC来讲讲我在使用中 的体会,当然,这里涉及的内容不会很高深,但是也必须读者能够读懂简单的 Bean配置才可以. 我们这里只讲spring的IOC,AOP不在这范围之内,虽然AOP也是基于IOC之上 的,至于那些集合啊什么的配置也不是这里的重点.我们这里说spring的Bean

Spring Batch 2将支持工作划分和基于注解的配置

这一版本的新特性可以分为四类:对Java 5的支持.非顺序执行.增强的可伸缩性以及注解. 对Java 5的支持: Spring Batch 2.0版支持Java 5泛型和参数化类型,以便可以在编译时检查类型安全性.例如,ItemReader接口现在有了一个类型安全的read方法. 非顺序执行: 这其实包括3个新特性--条件.暂停和并行执行.凭借这些特性,各步骤可以按非线性顺序执行.即使工作(Job)中的某个步骤(step)失败,整个工作也依然能够完成.有条件执行(Conditional exec

让IoC动态解析自定义配置（提供基于Unity的实现）

在<通过自定义配置实现插件式设计>中,通过在运行时对配置的动态解析实现了真正的"插件式"设计,其本质就是让配置自行提供对配置类型实例的创建.在这篇文章中,我们将更进一步,让自定义配置和IoC集成起来.IoC的目的就是通过解析注册的依赖注入信息,最终创建出我们希望的某个对象.而只有通过配置的方式来定义IoC容器需要的注入信息,才能实现灵活的设计.所以,如果将两者集成起来,让IoC容器能够解析通过配置定义的"依赖注入"信息,具有很大的现实意义.接下来,我们将

Spring Web工程web.xml零配置即使用Java Config + Annotation

摘要: 在Spring 3.0之前,我们工程中常用Bean都是通过XML形式的文件注解的,少了还可以,但是数量多,关系复杂到后期就很难维护了,所以在3.x之后Spring官方推荐使用Java Config方式去替换以前冗余的XML格式文件的配置方式: 在开始之前,我们需要注意一下,要基于Java Config实现无web.xml的配置,我们的工程的Servlet必须是3.0及其以上的版本: 1.我们要实现无web.xml的配置,只需要关注实现WebApplicationInitializer这个