Spring对象创建的三种方式

spring创建对象的三种方式详解

2018年01月18日 17:29:37 nwpu_geeker 阅读数：3597 标签： springioc创建对象对象 更多

个人分类： spring笔记

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/nwpu_geeker/article/details/79098797

前言

我们知道spring框架的核心就是IOC容器了，那么IOC容器主要的作用就是创建对象和处理对象之间的依赖关系。本文主要讲解IOC容器创建对象的三种方式。

创建对象的三种方式

1） 调用无参数构造器 
2） 带参数构造器 
3） 工厂创建对象 
包括：3.1 工厂类，静态方法创建对象 
3.2 工厂类，非静态方法创建对象

1.调用无参数的构造器

具体如下: 
User.java

public class User {

    private int id;
    private String name;



    public User() {
        super();
        System.out.println("------User对象创建【无参数构造器】------");
    }


    public User(int id, String name) {
        System.out.println("-----User对象创建【带参数构造器】--------");
        this.id = id;
        this.name = name;
    }


    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }


    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + "]";
    }
}

Bean.xml配置如下：

<!-- 1. 默认无参数构造器 -->
    <bean id="user1" class="com.nwpu.geeker.User"></bean>

测试：

// 测试：对象创建
    @Test
    public void testIOC() throws Exception {
        // 创建IOC容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("com/nwpu/geeker/bean.xml");
        // 获取容器中的对象
        User user = (User) ac.getBean("user");

        System.out.println(user);
    }

2.带参数构造器创建对象

例如：上面的user.java 有带参的构造器，参数列表为（int,string）.一般依赖注入对象的时候用的比较多。 
配置如下：

<!-- 2. 带参数构造器 -->
    <bean id="user2" class="com.nwpu.geeker..User">
        <constructor-arg index="0" type="int" value="100"></constructor-arg>
        <constructor-arg index="1" type="java.lang.String" value="Jack"></constructor-arg>
    </bean>

其中index属性表示参数的位置。Type表示类型，value表示赋值，还有一个ref属性下面将会介绍，表示可以引用IOC容器创建好的（已存在的）对象。 
配置如下：

<!-- 定义一个字符串，值是"Jack" ;  String s = new String("jack")-->
    <bean id="str" class="java.lang.String">
        <constructor-arg value="Jacks"></constructor-arg>
    </bean>
    <bean id="user3" class="com.nwpu.geeker.User">
        <constructor-arg index="0" type="int" value="100"></constructor-arg>
        <constructor-arg index="1" type="java.lang.String" ref="str"></constructor-arg>
    </bean>

ref属性引用的就是IOC容器创建对象的id属性值。

3.通过工厂类创建对象

3.1 通过实例化工厂，非静态方法创建对象 
先创建工厂javaBean

// 工厂，创建对象
public class ObjectFactory {

    // 实例方法创建对象
    public User getInstance() {
        return new User(100,"工厂：调用实例方法");
    }

    // 静态方法创建对象
    public static User getStaticInstance() {
        return new User(101,"工厂：调用静态方法");
    }
}

配置文件：

<!-- # 3.1 工厂类，实例方法 -->
    <!-- 先创建工厂 -->
    <bean id="factory" class="com.nwpu.geeker.ObjectFactory"></bean>
    <!-- 在创建user对象，用factory方的实例方法 -->
    <bean id="user4" factory-bean="factory" factory-method="getInstance"></bean>

其中： factory-bean=”factory”指定工厂。factory-method=”getInstance”指定工厂的哪个方法。

3.2 工厂类： 静态方法创建对象

<bean id="user" class="com.nwpu.geeker.ObjectFactory" factory-method="getStaticInstance"></bean>

class 指定的就是工厂类型，这里是和上面配置不同的地方。 
factory-method 一定是工厂里面的“静态方法”

创建对象的细节问题

1) 对象创建： 单例/多例 
在bean.xml配置文件中，配置scope=”singleton”,为单例创建对象，如果不配置，默认也是单例方式。主要应用于service/dao层还有一些utils工具类等只需要在服务器启动时初始化一次即可。 
scope=”prototype”,表示多例方式创建对象，也就是当用户需要使用这个对象时即创建对象，在ssh项目整合中主要应用于Action对象。这种方式一般在服务器启动时不会创建对象，在每次使用才创建。

2) 什么时候创建?上面其实已经说了 
scope=”prototype” 在用到对象的时候，才创建对象。（在ioc容器初始化之后） 
scope=”singleton” 在服务器启动时候(容器初始化之前)， 就已经创建了bean，且整个应用只有一个。

3)是否延迟创建 
lazy-init=”false” 默认为false, 不延迟创建，即在启动时候就创建对象 
lazy-init=”true” 延迟初始化， 在用到对象的时候才创建对象 
（只对单例有效）因为多例本来就是访问对象时才创建。

4) 创建对象之后，初始化/销毁 
init-method=”init_user” 【对应对象的init_user方法，在对象创建好之后执行 】 
destroy-method=”destroy_user” 【在调用容器对象的destroy方法时候执行，(容器用实现类)】

public class User {

    private int id;
    private String name;



    public User() {
        super();
        System.out.println("------User对象创建------");
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public void init_user() {
        System.out.println("创建对象之后，初始化");
    }
    public void destroy_user() {
        System.out.println("IOC容器销毁，user对象回收!");
    }

}

测试：

@Test
    public void testIOC() throws Exception {
        // 得到IOC容器对象  【用实现类，因为要调用销毁的方法】
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("com/nwpu/geeker/applicationContext.xml");
        System.out.println("-----容器创建-----");

        // 从容器中获取bean
        User user1 = (User) ac.getBean("user");
        User user2 = (User) ac.getBean("user");

        System.out.println(user1);
        System.out.println(user2);

        // 销毁容器对象 
        ac.destroy();
    }

    @Test
    public void test() throws Exception {
        // 容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("com/nwpu/geeker/applicationContext.xml");
        System.out.println("-----容器创建完成-----");
        User user1 = (User) ac.getBean("user1");
    }