<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.cpz</groupId>
    <artifactId>spring_ioc</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
    </dependencies>
    
</project>

3.1.2 ApplicationContext.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.xsd">
    <!--spring的ioc：由容器创建对象（底层：反射+工厂）
        bean：用来创建对象
            id：对象的唯一标识（名称）
            class：对象的创建路径（类型）
    -->

    <bean id="accountService" class="com.cpz.service.impl.AccountServiceImpl"></bean>
    <bean id="accountDao" class="com.cpz.dao.impl.AccountDaoImpl"></bean>

</beans>

3.1.3 创建 Service、Dao 接口以及对应的实现类

AccountService.java 接口

package com.cpz.service;

public interface AccountService {
    public void saveAccount();
}

AccountServiceImpl.java 实现类

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AccountServiceImpl implements AccountService {
    AccountDao accountDao;

    public AccountServiceImpl() {
        System.out.println("AccountServiceImpl对象被创建了");
    }

    public void saveAccount() {
        System.out.println("执行AccountServiceImpl中的saveAccount方法！");
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        AccountDao accountDao = (AccountDao) ac.getBean("accountDao");
        accountDao.saveAccount();
    }
}

AccountDao.java 接口

package com.cpz.dao;

public interface AccountDao {
    public void saveAccount();
}

AccountDaoImpl.java 实现类

package com.cpz.dao.impl;

import com.cpz.dao.AccountDao;

public class AccountDaoImpl implements AccountDao {
    public void saveAccount() {
        System.out.println("执行AccountDaoImpl类中的saveAccount方法！");
    }
}

3.1.3 测试类

Main.java

package com.cpz.main;

import com.cpz.service.AccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
    public static void main(String[] args) {
        // 由spring创建对象（完成对象的解耦）
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 通过名称调用（通过spring容器中的id属性）(推荐）
        AccountService accountService = (AccountService) ac.getBean("accountService");
        // 通过类型调用（通过spring容器中的class属性）
        //AccountService accountService = (AccountService) ac.getBean(AccountServiceImpl.class);
        accountService.saveAccount();
    }
}

3.1.4 相关知识的拓展

BeanFactory 才是 Spring 容器中的顶层接口。

ApplicationContext 是它的子接口。

BeanFactory 和 ApplicationContext 的区别：

创建的方式都表示单例对象。
创建对象的时间点不一样。

ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。（立即加载）
BeanFactory：什么时候使用什么时候创建对象。（延迟加载）

ApplicationContext 接口的实现类：

（1）ClassPathXmlApplicationContext
它是从类的根路径下加载配置文件推荐使用这种
（2）FileSystemXmlApplicationContext
它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
（3）AnnotationConfigApplicationContext
当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。

3.1.5 id 和 name 的配置

在 ApplicationContext.xml 文件中的 <bean> 标签中，我们使用 id 属性来作为容器中的唯一标识，这里还可以使用 name 属性来表示对相关类的引用。

id中不能出现特殊字符（容器中的唯一标识），name中可以出现特殊的字符（表示引用）。

可以指定多个name，之间可以用分号（“；”）、空格（“ ”）或逗号（“，”）分隔开，如果没有指定id，那么第一个name为标识符，其余的为别名；若指定了id属性，则id为标识符，所有的name均为别名。如：

<bean name="alias1 alias2;alias3,alias4" id="hello1" class="com.zyh.spring3.hello.HelloWorld"> </bean>

此时，hello1为标识符，而alias1，alias2，alias3，alias4为别名，它们都可以作为Bean的键值；

3.2 实例化 Bean 的三种方式

3.2.1 采用无参数的构造方法方式实例化

<!--创建Bean的三种方式 -->
<!-- 第一种方式：使用默认构造函数创建。
        在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时。
        采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数，则对象无法创建。
-->
<bean id="accountService" class="com.cpz.service.impl.AccountServiceImpl"></bean>

由于入门案例中采用的就是无参构造方法的方式进行的实例化，所以这里不再阐述。

3.2.2 采用静态工厂实例化的方式

<!--第二种：采用静态工厂实例化的方式-->
<bean id="accountService" class="com.cpz.factory.StaticFactory" factory-method="getAccountService"></bean>

创建一个静态工厂类：

package com.cpz.factory;

import com.cpz.service.AccountService;
import com.cpz.service.impl.AccountServiceImpl;

public class StaticFactory {
    public static AccountService getAccountService(){
        return new AccountServiceImpl();
    }
}

3.2.3 采用实例工厂（非静态的）实例化的方式

    <!--第三种：采用实例工厂（非静态的）实例化的方式-->
    <bean id="instanceFactory" class="com.cpz.factory.InstanceFactory"></bean>
    <bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean>

这里我们可以理解为：第一行的 <bean> 代表的是指向 InstanceFactory 类，第二行的 <bean> 中 factory-bean 代表的是创建了一个 instanceFactory 对象，并调用它的 getAccountService 方法。因为是非静态的，所以我们需要先将类实例化才能调用方法。

package com.cpz.factory;

import com.cpz.service.AccountService;
import com.cpz.service.impl.AccountServiceImpl;

public class InstanceFactory {
    public AccountService getAccountService(){
        return new AccountServiceImpl();
    }
}

3.3 Bean 的作用访问的配置：scope 的配置

Spring 创建这个类的时候，默认采用的单例的模式进行创建的。如果想去改变单例模式，需要通过scope进行配置。

Scope属性中有以下几个取值:

singleton：默认值，单例的。

prototype：多例的。

request：应用在web应用中，将创建的对象存入到request域中。

session：应用在web应用中，将创建的对象存入到session域中。

globalsession：应用在集群环境下使用。将创建的对象存入到全局的session中。

    <!-- bean的作用范围调整
        bean标签的scope属性：
        作用：用于指定bean的作用范围
        取值： 常用的就是单例的和多例的
            singleton：单例的（默认值）
            prototype：多例的
            request：作用于web应用的请求范围
            session：作用于web应用的会话范围
            global-session：作用于集群环境的会话范围（全局会话范围），当不是集群环境时，它就是session
    -->
    <bean id="accountService" class="com.cpz.service.impl.AccountServiceImpl" scope="prototype"></bean>