Spring框架学习过程回顾一

一、搭建Spring运行时环境

1）导入JAR包
① Spring自身JAR包：spring-framework-4.0.0.RELEASE\libs目录下
spring-beans-4.0.0.RELEASE.jar
spring-context-4.0.0.RELE2ASE.jar
spring-core-4.0.0.RELEASE.ja
spring-expression-4.0.0.RELEASE.jar
② commons-logging-1.1.1.jar
2）在STS中创建Spring的配置文件
① File->New->Spring Bean Configuration File
② 为文件取名字 例如：applicationContext.xml

二、利用Spring写出第一个程序

配置文件

<!-- 使用bean元素定义一个由IOC容器创建的对象 -->
	<!-- class属性指定用于创建bean的全类名 -->
	<!-- id属性指定用于引用bean实例的标识 -->
	<bean id="student" class="com.star.bean.Student">
		<!-- 使用property子元素为bean的属性赋值 -->
		<property name="studentId" value="001"/>
		<property name="stuName" value="Star"/>
		<property name="age" value="18"/>

测试类：

//1.创建IOC容器对象
ApplicationContext iocContainer = 
		new ClassPathXmlApplicationContext("helloworld.xml");
//2.根据id值获取bean实例对象
Student student = (Student) iocContainer.getBean("student");
//3.打印bean
System.out.println(student);

三、IOC容器和Bean的配置

1.IOC(Inversion of Control)：反转控制

IOC是一种思想，而下面的DI就是一种具体实现

2.DI(Dependency Injection)：依赖注入

组件以一些预先定义好的方式(例如：setter 方法)接受来自于容器的资源注入。

3.IOC容器在Spring中的实现

1）在通过IOC容器读取Bean的实例之前，需要先将IOC容器本身实例化。
2）Spring提供了IOC容器的两种实现方式
① BeanFactory：IOC容器的基本实现，是Spring内部的基础设施，是面向Spring本身的，不是提供给开发人员使用的。
② ApplicationContext：BeanFactory的子接口，提供了更多高级特性。面向Spring的使用者，几乎所有场合都使用ApplicationContext而不是底层的BeanFactory。

4.ApplicationContext的主要实现类

1. ClassPathXmlApplicationContext：对应类路径下的XML格式的配置文件
2. FileSystemXmlApplicationContext：对应文件系统中的XML格式的配置文件
3. 在初始化时就创建单例的bean，也可以通过配置的方式指定创建的Bean是多实例的。

5.通过类型获取bean

1. 从IOC容器中获取bean时，除了通过id值获取，还可以通过bean的类型获取。但如果同一个类型的bean在XML文件中配置了多个，则获取时会抛出异常，所以同一个类型的bean在容器中必须是唯一的。
2. 或者可以使用另外一个重载的方法，同时指定bean的id值和类型

6.给bean的属性赋值

依赖注入的方式

1. 通过bean的setXxx()方法赋值

<bean id="student" class="com.star.bean.Student">
		<!-- 使用property子元素为bean的属性赋值 -->
		<property name="studentId" value="001"/>
		<property name="stuName" value="Star"/>
		<property name="age" value="18"/>

2. 通过bean的构造器赋值
   Spring自动匹配合适的构造器

<bean id="book" class="com.star.bean.Book" >
           <constructor-arg value= "10010"/>
           <constructor-arg value= "Book01"/>
           <constructor-arg value= "Author01"/>
           <constructor-arg value= "20.2"/>
     </bean >

*通过索引值指定参数位置*

<bean id="book" class="com.star.bean.Book" >
           <constructor-arg value= "10010" index ="0"/>
           <constructor-arg value= "Book01" index ="1"/>
           <constructor-arg value= "Author01" index ="2"/>
           <constructor-arg value= "20.2" index ="3"/>
     </bean >

*通过类型区分重载的构造器*

<bean id="book" class="com.atguigu.spring.bean.Book" >
      <constructor-arg value= "10010" index ="0" type="java.lang.Integer" />
      <constructor-arg value= "Book01" index ="1" type="java.lang.String" />
      <constructor-arg value= "Author01" index ="2" type="java.lang.String" />
      <constructor-arg value= "20.2" index ="3" type="java.lang.Double" />
</bean >

p名称空间的方式

1. 为了简化XML文件的配置，越来越多的XML文件采用属性而非子元素配置信息。Spring 从2.5版本开始引入了一个新的p命名空间，可以通过元素属性的方式配置Bean的属性。

<bean 
	id="student" 
	class="com.star.bean.Student"
	p:studentId="001" p:stuName="star" p:age="18" />

7.FactoryBean

Spring中有两种类型的bean，一种是普通bean，另一种是工厂bean，即FactoryBean。工厂bean跟普通bean不同，其返回的对象不是指定类的一个实例，其返回的是该工厂bean的getObject方法所返回的对象。工厂bean必须实现org.springframework.beans.factory.FactoryBean接口。

8.bean的生命周期

1. Spring IOC容器可以管理bean的生命周期，Spring允许在bean生命周期内特定的时间点执行指定的任务。
2. Spring IOC容器对bean的生命周期进行管理的过程：
   ① 通过构造器或工厂方法创建bean实例
   ② 为bean的属性设置值和对其他bean的引用
   ③ 调用bean的初始化方法
   ④ bean可以使用了
   ⑤ 当容器关闭时，调用bean的销毁方法
3. 在配置bean时，通过init-method和destroy-method 属性为bean指定初始化和销毁方法
4. bean的后置处理器
   ① bean后置处理器允许在调用初始化方法前后对bean进行额外的处理
   ② bean后置处理器对IOC容器里的所有bean实例逐一处理，而非单一实例。
   其典型应用是：检查bean属性的正确性或根据特定的标准更改bean的属性。
   ③ bean后置处理器需要实现接口：
   org.springframework.beans.factory.config.BeanPostProcessor。在初始化方法被调用前后，Spring将把每个bean实例分别传递给上述接口的以下两个方法：
   ●postProcessBeforeInitialization(Object, String)
   ●postProcessAfterInitialization(Object, String)
5. 添加bean后置处理器后bean的生命周期
   ①通过构造器或工厂方法创建bean实例
   ②为bean的属性设置值和对其他bean的引用
   ③将bean实例传递给bean后置处理器的postProcessBeforeInitialization()方法
   ④调用bean的初始化方法
   ⑤将bean实例传递给bean后置处理器的postProcessAfterInitialization()方法
   ⑥bean可以使用了
   ⑦当容器关闭时调用bean的销毁方法

四、引用外部属性文件

当bean的配置信息逐渐增多时，查找和修改一些bean的配置信息就变得愈加困难。这时可以将一部分信息提取到bean配置文件的外部，以properties格式的属性文件保存起来，同时在bean的配置文件中引用properties属性文件中的内容，从而实现一部分属性值在发生变化时仅修改properties属性文件即可。这种技术多用于连接数据库的基本信息的配置。

1.直接配置

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
	<property name="user" value="root"/>
	<property name="password" value="root"/>
	<property name="jdbcUrl" value="jdbc:mysql://...."/>
	<property name="driverClass" value="com.mysql.jdbc.Driver"/>
</bean>

2.使用外部的属性文件

1. 创建properties属性文件

prop.userName=root
prop.password=root
prop.url=jdbc:mysql://
prop.driverClass=com.mysql.jdbc.Driver

2. 引入context名称空间
   
3. 指定properties属性文件的位置

<!-- 指定properties属性文件的位置 -->
<!-- classpath:xxx 表示属性文件位于类路径下 -->
<context:property-placeholder location="classpath:jdbc.properties"/>

4. 从properties属性文件中引入属性值

<!-- 从properties属性文件中引入属性值 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
	<property name="user" value="${prop.userName}"/>
	<property name="password" value="${prop.password}"/>
	<property name="jdbcUrl" value="${prop.url}"/>
	<property name="driverClass" value="${prop.driverClass}"/>
</bean>

五、自动装配

1. 手动装配：以value或ref的方式明确指定属性值都是手动装配。
2. 自动装配：根据指定的装配规则，不需要明确指定，Spring自动将匹配的属性值注入bean中。

装配模式

1. 根据类型自动装配：将类型匹配的bean作为属性注入到另一个bean中。若IOC容器中有多个与目标bean类型一致的bean，Spring将无法判定哪个bean最合适该属性，所以不能执行自动装配
2. 根据名称自动装配：必须将目标bean的名称和属性名设置的完全相同
3. 通过构造器自动装配：当bean中存在多个构造器时，此种自动装配方式将会很复杂。不推荐使用。

六、通过注解配置bean

相对于XML方式而言，通过注解的方式配置bean更加简洁和优雅，而且和MVC组件化开发的理念十分契合，是开发中常用的使用方式

1.使用注解标识组件

1. 普通组件：@Component
   标识一个受Spring IOC容器管理的组件
2. 持久化层组件：@Repository
   标识一个受Spring IOC容器管理的持久化层组件
3. 业务逻辑层组件：@Service
   标识一个受Spring IOC容器管理的业务逻辑层组件
4. 表述层控制器组件：@Controller
   标识一个受Spring IOC容器管理的表述层控制器组件
5. 组件命名规则
   ①默认情况：使用组件的简单类名首字母小写后得到的字符串作为bean的id
   ②使用组件注解的value属性指定bean的id
   注意：事实上Spring并没有能力识别一个组件到底是不是它所标记的类型，即使将 @Respository注解用在一个表述层控制器组件上面也不会产生任何错误，所以 @Respository、@Service、@Controller这几个注解仅仅是为了让开发人员自己明确 当前的组件扮演的角色。

2.扫描组件

组件被上述注解标识后还需要通过Spring进行扫描才能够侦测到。

1. 指定被扫描的package

<context:component-scan base-package="com.atguigu.component"/>

2. 详细说明
   ①base-package属性指定一个需要扫描的基类包，Spring容器将会扫描这个基类包及其子包中的所有类。
   ②当需要扫描多个包时可以使用逗号分隔。
   ③包含与排除
   ●context:include-filter子节点表示要包含的目标类
   注意：通常需要与use-default-filters属性配合使用才能够达到“仅包含某些组件”这样的效果。即：通过将use-default-filters属性设置为false，禁用默认过滤器，然后扫描的就只是include-filter中的规则指定的组件了。
   ●context:exclude-filter子节点表示要排除在外的目标类
   ●component-scan下可以拥有若干个include-filter和exclude-filter子节点

   ④如果仅希望扫描特定的类而非基包下的所有类，可使用resource-pattern属性过滤特定的类，示例：

<context:component-scan 
	base-package="com.atguigu.component" 
	resource-pattern="autowire/*.class"/>