第四节——配置文件解释

一、scope解释

1. scope的值有两个，分别是singleton和prototype
   
2. single是默认值，表示每次从xml取出的UserDaoImpl类都是唯一一个，且类的创建时机是在创建app对象时同时创建UserDao类

//测试代码
ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
userDao dao1 = (userDao) app.getBean("UserDao");
userDao dao2 = (userDao) app.getBean("UserDao");
System.out.println(dao1);
System.out.println(dao2);

3. prototype表示每次取出的都不是同一个对象，且创建时机在每次通过app取值时创建
   

二、生命周期配置

1. init-method：指定类的初始化方法
2. destroy-method：指定类中销毁方法
3. 举例：
   1）在UserDaoImpl类里面创建init和destroy
   2）在applicationContext里面配置init-method和destory-method参数

public class UserDaoImpl  implements userDao {
    
    

    @Override
    public void save() {
    
    
        System.out.println("save running..........");
    }

    public void init(){
    
    
        System.out.println("初始化方法");
    }

    public void destroy(){
    
    
        System.out.println("销毁方法");
    }
}

三、依赖注入——set注入

1. 使用前提：当B.class里面嵌套了A.class对象，当我们使用B的对象时，可以通过B的方法执行A的方法
2. 创建A类

public class A {
    
    
    public void test_a(){
    
    
        System.out.println("A");
    }
}

3. 创建B类

private class B {
    
    
    public A a_impl;

    public void setA_impl(A a_impl) {
    
    
        this.a_impl = a_impl;
    }

    public void test_b(){
    
    
        a_impl.test_a();
    }
}

4. 配置applicationContext文件，其中property里面的name与set函数中的名称一样，但是首字母小写，ref与a中bean id值一样

<bean id="a" class="A"/>
    <bean id="b" class="B">
        <property name="a_impl" ref="a"></property>
    </bean>

5. 在Demo01里面创建B对象调用test_b方法执行A类的方法

ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
B b_impl = (B) app.getBean("b");
b_impl.test_b();

三.2简化applicationContext文件配置

1. 引入p命名空间

xmlns:p="http://www.springframework.org/schema/p"

2. 简化b的bean配置

<bean id="b" class="B" p:a_impl-ref="a"></bean>

四、依赖注入——有参构造注入

1. 修改B类代码，生成有参构造和无参构造

public class B {
    
    
    private A a_impl;
    
    public B(A a_impl) {
    
    
        this.a_impl = a_impl;
    }

    public B() {
    
    
    }

    public void test_b(){
    
    
        a_impl.test_a();
    }
}

2. 修改applicationContext文件，其中name与构造方法的传入参数一致，ref与a的bean中id标识一致

<bean id="b" class="B">
	<constructor-arg name="a_impl" ref="a"></constructor-arg>
</bean>

3. 执行

ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
B b_impl = (B) app.getBean("b");
b_impl.test_b();

五、其他类型的注入

1. 注入分为
   1）引用数据类型注入(之前的对象也属于引用类型)
   2）普通数据类型注入
   3）集合数据类型注入
2. 普通数据类型注入举例——set注入(有参构造注入可以)
   1）B.class文件中声明int类型变量，创建相应的set函数
   2）修改applicationContext配置文件

public class B {
    
    
    private int age;

    public void setAge(int age) {
    
    
        this.age = age;
    }

    public void test_b(){
    
    
        System.out.println(age);
    }
}

3. 集合数据类型注入
   1）创建A.class文件
   2）创建B.class文件，一个A类型list，一个string类型list
   3）修改applicationContext

//A.class
public class A {
    
    
    private String name;
    private int age;

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

    public void setAge(int age) {
    
    
        this.age = age;
    }
}

//B.class
import java.util.List;

public class B {
    
    
    private List<String> stringArrayList;
    private List<A> aArrayList;

    public void setStringArrayList(List<String> stringArrayList) {
    
    
        this.stringArrayList = stringArrayList;
    }

    public void setAArrayList(List<A> aArrayList) {
    
    
        this.aArrayList = aArrayList;
    }

    public void test_b(){
    
    
        System.out.println(stringArrayList);
        System.out.println(aArrayList);
    }
}

六、使用import标签将配置文件分开

1. 新建一个spring config，命名为：applicationContext-b
   

2. 将原本的b的bean注释掉转移到applicationContext-b中，并使用import标签引入