在千峰“逆战”学习的第24天

今天学习了spring结合数据库操作的流程，基于注解的IoC配置、创建对象、依赖注入
继续加油！奥利给！
人生重要的不是所站的位置，而是所朝的方向
中国加油！武汉加油！千锋加油！我自己加油

      程序的耦合：
       耦合：程序之间的依赖
           包括：
               类之间的依赖
               方法之间的依赖
       解耦：降低程序之间的依赖关系
       实际开发中：
           应做到，编译时不依赖，运行时才依赖
       解耦思路：
           第一步：使用反射创建对象，避免使用new关键字
           第二步：通过读取配置文件获取要创建对象全限定类名

      获取spring核心容器，并根据id获取对象
      ApplicationContext的三个实现类：
           ClassPathXmlApplicationContext：它可以加载类路径下的配置文件，要求配置文件必须在类路径下。
           FileSystemXmlApplicationContext:它可以加载磁盘任意路径下的配置文件
           AnnotationConfigApplicationContext:它是用于读取注解创建容器的。
     
      核心容器的两个接口引发的问题：
       ApplicationContext：  单例对象使用
           它在构建核心容器时，创建对象采取的策略是采用立即加载的方式。只要一读取完配置文件就创建配置文件中的对象
       BeanFactory： 多例对象使用
           他在构建核心容器时，创建对象采取的策略时采用延迟加载的方式。什么时候根据id获取对象，什么时候才真正的创建对象
     

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

    <!-- 第二种方式：使用普通工厂中的方法创建对象（使用某个类中方法创建对象，并存入容器中）-->
    <bean id="factoryInstan" class="com.zwl.factory.FactoryInstance"></bean>
    <bean id="accountService" factory-bean="factoryInstan" factory-method="getAccountService"></bean>
    public class FactoryInstance {
    public AccountService getAccountService() {
        return new AccountServiceImpl();
    }
}


    <!-- 第三种方式：使用工厂中的静态方法创建对象（使用某个类的静态方法创建对象，并存入spring容器 -->
    <bean id="accountService" class="com.zwl.factory.FactoryStatic" factory-method="getAccountService"></bean>
    public class FactoryStatic {
    public static AccountService getAccountService() {
        return new AccountServiceImpl();
    }
}


    <!-- bean的作用范围调整
        bean标签的scope属性，
            作用：用于指定bean的作用范围
            singleton：单例的 默认值
            prototype：多例的
            request：作用于web应用的请求范围
            session：作用于web应用的会话范围
            global-session：作用于集群环境的会话范围，当不是集群环境时，他就是session
    -->

    <!-- bean对象的生命周期
        单例对象：
            出生：当容器创建时对象出生
            活着：只要容器还在，对象一直或者
            死亡：容器销毁，对象消亡
            总结：单例对象的生命周期和容器相同
         多例对象：
            出生：只有在使用对象时spring框架才为我们创建
            活着：都西昂只要是在使用过程就一直活着
            死亡：当对象长时间不用时，且没有别的对象引用时，有java垃圾回收器回收
            总结：
    -->
    <bean id="accountService" class="com.zwl.service.impl.AccountServiceImpl" scope="prototype"
    init-method="init" destroy-method="destory"></bean>

<!-- spring中的依赖注入
        依赖注入：
        Dependency Injection
        IOC作用：
            降低程序间的耦合（依赖关系）
        在当前类需要用到其他的类对象，有spring为我们提供，我们只需要在配置文件中说明
        依赖关系的维护。
            就称之为依赖注入
        依赖注入：
            能注入的数据：有三类
                基本类型和String
                其他bean类型（在配置文件或注解配置过的bean）
                复杂类型/集合类型
            注入的方式有三种
                第一种：构造函数注入
                第二种：使用set方法提供
                第三种：使用注解提供
    -->

    <!-- 构造函数注入
        使用的标签：constructor-arg
        标签的位置：bean标签的内部
        标签中的属性：
            type：用于指定要注入的数据的数据类型，该数据类型是构造函数中某个或某些参数的类型
            index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值，索引的位置就是从0开始
            name：用于指定给构造函数中指定名称的参数赋值
            ===================== 以上三个参数用于给构造函数中指定的参数赋值==============
            value：用于提供基本类型和String类型的数据
            ref：用于指定其他的bean类型的数据，它指的是在spring的ioc容器中出现过的bean对象
        优势：
            在获取bean对象时，注入数据是必须的操作，否则对象无法创建
        弊端：
            改变了bean对象的实例化方式，是我们在创建对象时，如果不使用这些数据，也必须提供

    -->
    <bean id="accountService" class="com.zwl.service.impl.AccountServiceImpl">
        <constructor-arg name="name" value="test"></constructor-arg>
        <constructor-arg name="age" value="18"></constructor-arg>
        <constructor-arg name="birthday" ref="now"></constructor-arg>
    </bean>
    <bean id="now" class="java.util.Date"></bean>


    <!-- set方法注入       更常用的方式
        涉及的标签：propety
        出现的位置：bean标签内部
        标签的属性：
            name：用于指定注入时所调用的set方法名称
            value：用于提供基本类型和String类型的数据
            ref：用于指定其他bean类型数据，它指的就是spring的ioc核心容器中出现过的bean对象

        优势：
            创建对象时没有明确的限制，可以直接使用默认构造函数
        弊端：
            如果有某个成员必须有值，则获取对象时set方法可能没有执行
    -->
    <bean id="accountService2" class="com.zwl.service.impl.AccountServiceImpl2">
        <property name="name" value="test"></property>
        <property name="age" value="12"></property>
        <property name="birthday" ref="now"></property>
     </bean>


    <!-- 复杂类型的注入/集合类型的注入
        用于给list结构集合注入的标签
            list，array，set
        用于给Map结构集合注入的标签
            map，props
        结构相同标签可以互换
    -->
    <bean id="accountService3" class="com.zwl.service.impl.AccountServiceImpl3">
        <property name="myStrs">
            <array>
                <value>AAA</value>
                <value>BBB</value>
            </array>
        </property>

        <property name="myList">
            <list>
                <value>CCC</value>
                <value>DDD</value>
            </list>
        </property>

        <property name="mySet">
            <set>
                <value>EEE</value>
                <value>FFF</value>
            </set>
        </property>

        <property name="myMap">
            <map>
                <entry key="testA" value="GGG"></entry>
                <entry key="testB">
                    <value>HHH</value>
                </entry>
            </map>
        </property>

        <property name="myprope">
            <props>
                <prop key="testC">III</prop>
                <prop key="testD">JJJ</prop>
            </props>
        </property>
    </bean>