Spring框架（二）

1.1、bean对象创建的细节

  1) 对象创建： 单例/多例

     * scope="singleton", 默认值， 即 默认是单例  【service/dao/工具类】

     * scope="prototype", 多例；                 【Action对象】

   2) 什么时候创建?

     *   scope="prototype"  在用到对象的时候，才创建对象。

     *    scope="singleton"  在启动(容器初始化之前)， 就已经创建了bean，且整个应用只有一个。

    3)是否延迟创建(懒加载)

     *   lazy-init="false"  默认为false,  不延迟创建，即在启动时候就创建对象

     *   lazy-init="true"   延迟初始化， 在用到对象的时候才创建对象

     *    （只对单例有效）

设置懒加载有两种方式：

　　1、 全局懒加载，可以在*.xml文件的<beans>下配置default-lazy-init="true"

　　2、 如果只想设置某一个<bean>为懒加载，可以在<bean>里面配置lazy-init="true"

<?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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    
    <!-- IOC容器的配置： 要创建的所有的对象都配置在这里
    <bean id="user" class="cn.itcast.a_hello.User" init-method="init_user" destroy-method="destroy_user" scope="singleton" lazy-init="false"></bean>
     -->
     
    <bean id="user1" class="cn.itcast.a_hello.User"></bean>
</beans> 

2.2、SpringIOC容器

1） 创建对象

　　　　SpringIOC容器，是spring核心内容。

　　　　　　　　作用： 创建对象 & 处理对象的依赖关系

　　　　IOC容器创建对象：

　　　　　　创建对象, 有几种方式：

　　　　　　　　　　1） 调用无参数构造器

　　　　　　　　　　2） 带参数构造器

　　　　　　　　　　3） 工厂创建对象

                   　　　　　　　　工厂类，静态方法创建对象

                   　　　　　　　　工厂类，非静态方法创建对象

代码示例：

 　　1、导包

　　 2、配置applicationContext.xml / bean.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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    
    <!-- ###############对象创建############### -->
    
    <!-- 1. 默认无参数构造器 
    <bean id="user1" class="cn.itcast.b_create_obj.User"></bean>
    -->
    
    <!-- 2. 带参数构造器 -->
    <bean id="user2" class="cn.itcast.b_create_obj.User">
        <constructor-arg index="0" type="int" value="100"></constructor-arg>
        <constructor-arg index="1" type="java.lang.String" value="Jack"></constructor-arg>
    </bean>
    
　　<!-- ref引用-->
    <!-- 定义一个字符串，值是"Jack" ;  String s = new String("jack")-->
    <bean id="str" class="java.lang.String">
        <constructor-arg value="Jacks"></constructor-arg>
    </bean>
    <bean id="user3" class="cn.itcast.b_create_obj.User">
        <constructor-arg index="0" type="int" value="100"></constructor-arg>
        <constructor-arg index="1" type="java.lang.String" ref="str"></constructor-arg>
    </bean>
    
    
    <!-- 3. 工厂类创建对象 -->
    <!-- # 3.1 工厂类，实例方法 -->
    <!-- 先创建工厂 -->
    <bean id="factory" class="cn.itcast.b_create_obj.ObjectFactory"></bean>
    <!-- 在创建user对象，用id="factory"的实例方法 -->
    <bean id="user4" factory-bean="factory" factory-method="getInstance"></bean>
    
    
    <!-- # 3.2 工厂类： 静态方法 -->
    <!-- 
        class 指定的就是工厂类型
        factory-method  一定是工厂里面的“静态方法”
     -->
    <bean id="user" class="cn.itcast.b_create_obj.ObjectFactory" factory-method="getStaticInstance"></bean>
</beans>      

实体类User

package cn.itcast.b_create_obj;
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;
    }
　　//getter/setter方法
    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 + "]";
    }
    
}

工厂类

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

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

测试代码

public class 依赖注入的简单测试 {
    public static void main(String[] args) {

        // 得到IOC容器对象,读取【applicationContext.xml】文件。直接得到IOC容器对象  
　　　　　ClassPathXmlApplicationContext cpc = new ClassPathXmlApplicationContext("applicationContext.xml");
　　 　　
　　　　//从IOC容器中获取bean，从而得到对象
　　　　User user = (User) cpc.getBean("user");
　　　  System.out.println(user); 

　　　　
　　}
 }

测试结果：

1、默认无参数构造器 

　　输出：

　　　　　　------User对象创建【无参数构造器】------

2、带参数构造器

 　 输出：

　　　　-----User对象创建【带参数构造器】--------

　　　　------User对象创建【无参数构造器】------
　　　　User [id=100, name=Jack]

转载于:https://www.cnblogs.com/guzhou-ing/p/6442392.html