SPRING的知识点整理

Spring知识点的整理（IOC部分）

spring中基于xml的ioc的配置

@祈祷杰克
本篇博客是根据bilibili内的一部教学视频spring教学idea版整理的知识点总结，可能理解不够深刻，里面可能有些内容有错误，见谅，希望以后的我看到之后能把错误的地方改过来，把不完善的地方补充完整。

https://www.bilibili.com/video/av47952931/?p=1

*这个老师讲的确实有点东西，不仅讲应用，还把spring框架某个部分的形成过程，思路，以及为什么要使用讲的明明白白，很好，值得推广。

正文开始：

spring的背景，来源这里就不介绍了，以后如果忘了直接百度即可。
Spring分为ioc和aop，这篇文章先来说ioc

---

spring 的 IOC的作用：解耦。耦合是什么呢，就是程序间的依赖关系，包括类之间的依赖关系和方法之间的依赖，解耦就是降低程序之间的依赖。
举例：ioc就相当于房屋中介。以前人们把房子租出去，需要自己去刊登房屋信息，然后找买家，和他们商量相关事宜，很麻烦，费时费力，现在有了房屋中介了，我们把房子信息给中介，然后就什么都不用管了，中介去帮我们出租房子，省心省力。
解耦的思路：

1. 第一步：使用反射来创建对象，避免使用关键字new。（反射是什么呢，详情参见上一篇）

2. 第二步：通过读取配置文件来获取要创建的对象的全限定类名。

解耦方式： 一个创建bean对象的工厂

Bean：在计算机英语中，有可重用组件的意思
JavaBean:用java语言编写的可重用的组件

JavaBean 和 实体类的含义不一样哟，JavaBean大于实体类

它就是我们创建的service和dao对象
第一个：需要配置文件来配置我们的service和dao
配置的内容：唯一标识 = 全限定类名（key = value）
第二个：通过读取配置文件中配置的内容，反射创建对象

配置文件可以是xml也可以是properties

把new换成BeanFactory.getBean(“配置配置文件中要读取的名字，如accountDao/accountService”); //可能需要强转
这里就是不自己new一个对象了，而是把new对象的权力交由beanfactory，让他来帮我们创建对象，这样就降低 了程序之间的耦合。
注：
多例：对象被创建多次，执行效率没有单例对象高。多例是在调用时才被创建，有延时性。
单例：只被创建一次，从而类中的成员只被初始化一次。第一次即被创建。

ApplicationContext的三个常用实现类：

1. ClassPathXmlApplicationContext:它可以加载类路径下的配置文件，要求配置文件必须在类路径下。不在的话就加载不了
2. FileSystemXmlApplicationContext：他可以加载磁盘任意路径下的配置文件（必须有访问权限）
3. AnnotationConfigApplicationContext：用于读取注解创建容器的
   （例子见下方图片）
   
   核心容器的两个接口引发出的问题：
   ApplicationContext: （单例对象适用）（采用此接口更多）
   它在构建核心容器时，创建对象采取的策略是采用立即加载的方式。也就是说，只要一读取完配置文件马上就创建配置文件中配置的对象。
   BeanFactory: （多例对象适用）
   它在构建核心容器时，创建对象采取的策略是采用延迟加载的方式。也就是说，什么时候根据id获取对象了，什么时候才是真正创建对象。

bean对象的三种创建方式：

把对象的创建交给spring来处理
spring对bean对象的管理细节：

1. 创建bean的三种方式
2. bean对象的作用范围
3. bean对象的生命周期

创建bean的三种方式

第一种方式： 使用默认构造函数创建
在spring的配置文件中使用bean标签，配以id和class属性，且没有其他属性和标签时，
采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数，则对象无法创建 （id和class的作用就是寻找默认构造函数）
*自己总结的:id是为了在表现层能找到需要的类，然后直接在此类中找到默认的构造方法，然后执行。id随便起的，class是地址。找到的方法就是类中默认的构造方法。

<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>

第二种方式： 使用普通工厂中的方式创建对象（使用某个类中的方法创建对象，并存入spring容器）
*自己总结的（第一行的id是为了让第二行的factory-bean能找到对应的类，第二行的factory-method是为了找到此类中的方法，然后执行。第二行的id是调用的时候可以写的名）。找的过程就是，先看factory-bean，追溯到第一行的id，然后看第一行的class类，知道了类后，看factory-method，可以知道类中的方法。

	<bean id = "instanceFactory"  class="com.itheima.factory.InstanceFactory"></bean> 	
	<bean id="accountService"   factory-bean="instanceFactory"  factory-method="getAccountService"></bean>

第三种方式： 使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并存入spring容器）
*（用id来取，同第二种，找到class里的类，来找到factory-method中的方法来执行）

<bean id="accountService" class="com.itheima.factory.StaticFactory"  factory-method="getAccountService"></bean>

bean对象的生命周期:

bean的作用范围调整：
bean标签的scope属性：
作用：用于指定bean的作用范围
取值：常用的就是单例和多例的（前两个）

1. singleton:单例的（默认值）

2. prototype：多例的

3. request：作用于web应用的请求范围

4. session：作用于web应用的会话范围

5. global-session：作用于集群环境的会话范围（全局会话范围），当不是集群环境时，它就是session

<bean id = "accountService"   class = "com.itheima.service.impl.AccountServiceImpl"  scope = "prototype"></bean>

对象的生命周期

1. 单例对象：
   出生：当容器创建时对象出生（立即）
   活着：只要容器还在，对象一直活着
   死亡：容器销毁，对象死亡
   总结：单例对象的生命周期和容器相同
2. 多例对象：
   出生：当我们使用对象时，spring框架为我们创建（延迟）
   活着：对象只要是在使用过程中就一直活着
   死亡：当对象长时间不用，且没有别的对象引用时，由java的垃圾回收机制回收

Spring中的依赖注入

依赖注入： Dependency Injection
IOC的作用：降低程序间的耦合(依赖关系)
依赖关系的管理：以后都交给spring来维护
在当前类需要用到其他类的对象，有spring为我们提供，我们只需要在配置文件中说明
依赖关系的维护：
就称之为依赖注入
依赖注入：
一、 能注入的数据有三类：

1. 基本数据类型和String

2. 其他bean类型（在配置文件中或注解配置过的bean）

3. 其他类型/集合类型

二、注入的方式：有三种

1. 第一种：使用构造函数提供

2. 第二种：使用set方法提供

3. 第三种：使用注解提供

第一种：
构造函数的注入：
使用的标签：constructor-arg
标签出现的位置：bean标签的内部
标签中的属性：

• type：用于指定要注入的数据类型，该数据类型也是构造函数中某个或某些参数的类型
• index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值，索引位置是从0开始
• name：用于指定给构造函数中指定名称的参数赋值（常用的）

以上三个用于指定给构造函数中哪个参数赋值============

• value：用于提供基本类型和String类型的数据

• ref：用于指定其他的bean类型数据。他指的就是在spring的IOC核心容器中出现过的bean对象

  优势：在获取bean对象时，注入数据是必须操作，否则对象无法创建成功
  劣势：改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供

<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
                <constructor-arg name = "name" value = "test"></constructor-arg>
                <constructor-arg name="age" value="21"></constructor-arg>
                <constructor-arg name="birthday" ref="now"></constructor-arg>
 </bean>
           
 <!--配置一个日期对象-->
 <bean id="now" class="java.util.Date"></bean>

例子见图片：

第二种：set方法注入 更常用的方式
涉及到的标签：property
出现的位置：bean标签的内部
标签的属性：
name：用于指定注入时所调用的set方法名称
value：用于提供基本类型和String类型的数据
ref：用于指定其他的bean类型数据。他指的就是在spring的IOC核心容器中出现过的bean对象

优势：
创建对象时没有明确的限制，可以直接使用默认构造函数
弊端：
如果某个成员必须有值，则获取对象是可能set方法没有执行

<bean id="accountService2" class="com.itheima.service.impl.AccountServiceImpl2">
    <property name="name" value="狗子"></property>
    <property name="age" value="12"></property>
    <property name="birthday" ref="now"></property>
</bean>

<bean id="now" class="java.util.Date"></bean>

第三种：复杂类型的注入/集合类型的注入
（在类中定义了集合string[], list, set, map, Properties）
用于给List结构集合注入的标签：
list, array, set
用于给map集合注入的标签：
map, props
结构相同，标签可以互换

    <bean id="accountService3" class="com.itheima.service.impl.AccountServiceImpl3">
        <property name="myStrs">
            <array>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </array>
        </property>

        <property name="myList">
            <list>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </list>
        </property>

        <property name="mySet">
            <set>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </set>
        </property>

        <property name="myMap">
        <map>
            <entry key="testA" value="ming"></entry>
            <entry key="testB" value="mmm"></entry>
        </map>
    </property>

        <property name="myProps">
            <props>
                <prop key="testA">ccc</prop>
                <prop key="testB">ddd</prop>
            </props>
        </property>
    </bean>

注：第三种在下一篇博客中