Spring IOC 容器创建bean的几种方式（Xml配置的方式）

基于xml文件的方式创建bean:

xml文件有三种创建bean的方式，分别是：
1、构造函数
2、静态工厂方法
3、实例工厂方法

构造函数的方式：

Bean 对象：

package spring.basic.xml.createbean;
/**
 * 演示 spring 通过 xml 方式创建bean
 *   1、通过构造函数方式创建bean实例
 *
 * @author keivn.chen <https://github.com/cdxpc>
 * @create 2018-12-21 13:43
 * @since 1.0.0v
 */
public class Black {
    private String name;
    public Black(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        System.out.println("Black say: My color is " + name);
        return null;
    }
}

Xml 配置：

<!-- 1、通调用构造方法的方式 -->
<bean name="black" class="spring.basic.xml.createbean.Black">
        <constructor-arg name="name" value="黑色"/>
</bean>

静态工厂方法的方式：

Bean 接口（静态工厂方法和实例工厂方式使用同一个接口类）：

package spring.basic.xml.createbean;
/**
 * 静态工厂方法和实例工厂方法统一的bean接口
 *
 * @author keivn.chen <https://github.com/cdxpc>
 * @create 2018-12-21 14:58
 * @since 1.0.0v
 */
public interface Color {
    void setName(String name);
    void myColor();
}

Bean 对象：

package spring.basic.xml.createbean;
/**
 * 演示 spring 通过 xml 方式创建bean
 *   2、通过静态工厂方式创建bean实例
 *
 * @author keivn.chen <https://github.com/cdxpc>
 * @create 2018-12-21 13:43
 * @since 1.0.0v
 */
public class Blue implements Color {
    private String name;
    public Blue() {
    }
    @Override
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public void myColor() {
        System.out.println("Blue say: My color is " + name);
    }
}

package spring.basic.xml.createbean;
/**
 * 演示 spring 通过 xml 方式创建bean
 *   2、通过静态工厂方式创建bean实例
 *
 * @author keivn.chen <https://github.com/cdxpc>
 * @create 2018-12-21 13:41
 * @since 1.0.0v
 */
public class Green implements Color {
    private String name;
    public Green() {
    }
    @Override
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public void myColor() {
        System.out.println("Green say: My color is " + name);
    }
}

静态工厂类：

package spring.basic.xml.createbean;
/**
 * 通过调用静态工厂方法的方式
 *
 * @author keivn.chen <https://github.com/cdxpc>
 * @create 2018-12-21 15:00
 * @since 1.0.0v
 */
public class ColorStaticFactory {
    // 工厂 - 静态方法
    public static Color getColor(String colorType) {
        if("blue".equals(colorType)) {
            return new Blue();
        } else {
            return new Green();
        }
    }
}

Xml 配置：

<!-- 2、通过调用静态工厂方法的方式 -->
<bean name="blue" class="spring.basic.xml.createbean.ColorStaticFactory" factory-method="getColor">
        <constructor-arg value="blue"/>
        <property name="name" value="蓝色"/>
</bean>
<bean name="green" class="spring.basic.xml.createbean.ColorStaticFactory" factory-method="getColor">
        <constructor-arg value="green"/>
        <property name="name" value="绿色"/>
</bean>

实例工厂方法的方式：

Bean 对象：

package spring.basic.xml.createbean;
/**
 * 演示 spring 通过 xml 方式创建bean
 *   3、通过实例工厂方式创建bean实例
 *
 * @author keivn.chen <https://github.com/cdxpc>
 * @create 2018-12-21 13:38
 * @since 1.0.0v
 */
public class Red implements Color {
    private String name;
    @Override
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public void myColor() {
        System.out.println("Red say: My color is " + name);
    }
}

package spring.basic.xml.createbean;
/**
 * 演示 spring 通过 xml 方式创建bean
 *  3、通过实例工厂方式创建bean实例
 *
 * @author keivn.chen <https://github.com/cdxpc>
 * @create 2018-12-21 13:41
 * @since 1.0.0v
 */
public class Yellow implements Color {
    private String name;
    @Override
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public void myColor() {
        System.out.println("Yellow say: My color is " + name);
    }
}

实例工厂类：

package spring.basic.xml.createbean;
/**
 * 通过调用实例工厂方法的方式
 *
 * @author keivn.chen <https://github.com/cdxpc>
 * @create 2018-12-21 15:00
 * @since 1.0.0v
 */
public class ColorInstanceFactory {
    // 工厂 - 实例对象方法
    public Color getColor2(String colorType) {
        if("red".equals(colorType)) {
            return new Red();
        } else {
            return new Yellow();
        }
    }
}

Xml 配置：

<!-- 3、通过调用实例工厂方法的方式 -->
<bean name="instanceFactory" class="spring.basic.xml.createbean.ColorInstanceFactory"/>
<bean name="red" factory-bean="instanceFactory" factory-method="getColor2">
        <constructor-arg value="red"/>
        <property name="name" value="红色"/>
</bean>
<bean name="yellow" factory-bean="instanceFactory" factory-method="getColor2">
        <constructor-arg value="yellow"/>
        <property name="name" value="黄色"/>
</bean>

对上述三种方式统一的测试类：

XmlBaseTest 基类：

package spring.basic.xml;
import org.junit.After;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * xml方式测试基类
 *
 * @author keivn.chen <https://github.com/cdxpc>
 * @create 2018-12-20 9:03
 * @since 1.0.0v
 */
public class XmlBaseTest {
    protected ClassPathXmlApplicationContext context;
    // IOC 容器创建完成之后，就可以使用 appclication context
    protected void init() {
        // spring 对配置文件是支持使用spEL和OGNL表达式的
        String path = "classpath*:spring-${moduleName}.xml";
        // 调用有参数构造，默认会调用setConfigLocation()方法和refresh() 方法
        // context = new ClassPathXmlApplicationContext(path);
        // 调用无参构造，必须显示的调用setConfigLocation()方法和refresh() 方法
        context = new ClassPathXmlApplicationContext();
        context.setConfigLocation(path);
        context.refresh();
    }
    @After
    public void destroy() {
        // 关闭 IOC 容器
        context.close();
    }
}

CreateBeanTest 测试类：

package spring.basic.xml.createbean;
import org.junit.Before;
import org.junit.Test;
import spring.basic.xml.XmlBaseTest;
/**
 * xml方式 spring IOC容器创建bean的几种方式
 *  1、构造器方式
 *  2、静态工厂方法方式
 *  3、实例工厂方法方式
 *
 * @author keivn.chen <https://github.com/cdxpc>
 * @create 2018-12-21 16:23
 * @since 1.0.0v
 */
public class CreateBeanTest extends XmlBaseTest {
    @Before
    public void setUp(){
        // 设置加载的配置文件所对应的模块，这里会加载classpath路径下的spring-createbean.xml文件
        System.setProperty("moduleName", "createbean");
        init();
    }
    @Test
    public void testCreateBean() {
        System.out.println("----------构造函数方式----------");
        // 从容器中获取通过构造函数方式创建的bean
        Black black = (Black) context.getBean("black");
        black.toString();
        System.out.println("----------静态工厂方法----------");
        // 从容器中获取通过静态工厂方法方式创建的bean
        Blue blue = (Blue) context.getBean("blue");
        Green green = (Green) context.getBean("green");
        blue.myColor();
        green.myColor();
        System.out.println("----------实例工厂方法----------");
        // 从容器中获取通过实例工厂方法方式创建的bean
        Red red = (Red) context.getBean("red");
        Yellow yellow = (Yellow) context.getBean("yellow");
        red.myColor();
        yellow.myColor();
    }
}

测试运行结果：

----------构造函数方式----------
Black say: My color is 黑色
----------静态工厂方法----------
Blue say: My color is 蓝色
Green say: My color is 绿色
----------实例工厂方法----------
Red say: My color is 红色
Yellow say: My color is 黄色