spring

1. 什么是spring

spring是J2EE应用程序框架，是轻量级的IoC和AOP的容器框架，主要是针对javaBean的生命周期进行管理的轻量级容器。

2. 框架概述

1. IoC(Inversion of Control)控制反转

   对象创建责任的反转，在spring中BeanFactory
   是IoC容器的核心接口，负责实例化，定位，配置应用程序中的对象及建立这些对象间的依赖。
   XmlBeanFactory实现BeanFactory接口，通过获取xml配置文件数据，组成应用对象及对
   象间的依赖关系。

   简单认知就是将原本对象的创建控制权交由spring进行管理，使用者无需关注对象的创建过程；

   DI 依赖注入

   指 Spring 创建对象的过程中，将对象依赖属性（简单值，集合，对象）通过配置设值给该对象。

   spring的三种注入方式：
   set注入 、 接口注入 、 构造方法注入

2. AOP面向切面编程

   • AOP是一种编程范式，提供从还有一个角度来考虑程序结构以完好面向对象编
     程（OOP）。
   • AOP为开发人员提供了一种描写叙述横切关注点的机制，并可以自己主动将横
     切关注点织入到面向对象的软件系统中。从而实现了横切关注点的模块化。
   • AOP可以将那些与业务无关，却为业务模块所共同调用的逻辑或责任。比如
     事务处理、日志管理、权限控制等。封装起来，便于降低系统的反复代码，降
     低模块间的耦合度，并有利于未来的可操作性和可维护性。

Spring 框架的主要优点具体如下：

1. 方便解耦，简化开发

   Spring 就是一个大工厂，可以将所有对象的创建和依赖关系的维护交给 Spring 管理。

2. 方便集成各种优秀框架

   Spring 不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如 Struts2、Hibernate、MyBatis 等）的直接支持。

3. 降低 Java EE API 的使用难度

   Spring 对 Java EE 开发中非常难用的一些 API（JDBC、JavaMail、远程调用等）都提供了封装，使这些 API 应用的难度大大降低。

4. 方便程序的测试

   Spring 支持 JUnit4，可以通过注解方便地测试 Spring 程序。

5. AOP 编程的支持

   Spring 提供面向切面编程，可以方便地实现对程序进行权限拦截和运行监控等功能。

6. 声明式事务的支持

   只需要通过配置就可以完成对事务的管理，而无须手动编程。

---

Spring 官网列出的 Spring 的 6 个特征:

• 核心技术 ：依赖注入(DI)，AOP，事件(events)，资源，i18n，验证，数据绑定，类型转换，SpEL。
• 测试 ：模拟对象，TestContext框架，Spring MVC 测试，WebTestClient。
• 数据访问 ：事务，DAO支持，JDBC，ORM，编组XML。
• Web支持 : Spring MVC和Spring WebFlux Web框架。
• 集成 ：远程处理，JMS，JCA，JMX，电子邮件，任务，调度，缓存。
• 语言 ：Kotlin，Groovy，动态语言。

---

spring结构：

1. Data Access/Integration（数据访问／集成）

   • JDBC 模块：提供了一个 JDBC 的抽象层，大幅度减少了在开发过程中对数据库操作的编码。
   • ORM 模块：对流行的对象关系映射 API，包括 JPA、JDO、Hibernate 和 iBatis 提供了的集成层。
   • OXM 模块：提供了一个支持对象/XML 映射的抽象层实现，如 JAXB、Castor、XMLBeans、JiBX 和 XStream。
   • JMS 模块：指 Java 消息服务，包含的功能为生产和消费的信息。
   • Transactions 事务模块：支持编程和声明式事务管理实现特殊接口类，并为所有的 POJO。

2. Web 模块

   • Web 模块：提供了基本的 Web 开发集成特性，例如多文件上传功能、使用的 Servlet 监听器的 IoC 容器初始化以及 Web 应用上下文。
   • Servlet模块：包括 Spring 模型—视图—控制器（MVC）实现 Web 应用程序。
   • Portlet 模块：提供了在 Portlet 环境中使用 MV C实现，类似 Web-Servlet 模块的功能。
   • WebSocket 模块：提供对WebSocket的集成支持。

3. Core Container（核心容器）

   • Beans 模块：提供了 BeanFactory，是工厂模式的经典实现，Spring 将管理对象称为 Bean。
   • Core 核心模块：提供了 Spring 框架的基本组成部分，包括 IoC 和 DI 功能。
   • Context 上下文模块：建立在核心和 Beans 模块的基础之上，它是访问定义和配置任何对象的媒介。ApplicationContext 接口是上下文模块的焦点。
   • Expression Language 模块：是运行时查询和操作对象图的强大的表达式语言。

4. Spring Aspects ：提供与 AspectJ 的集成，是一个功能强大且成熟的面向切面编程（AOP）框架。

5. Spring AOP ：提供了面向切面的编程实现。

6. Spring Test : 提供了对 JUnit 和 TestNG 测试的支持。

7. Instrumentation 模块：提供了类工具的支持和类加载器的实现，可以在特定的应用服务器中使用。

IOC容器

1. BeanFactory
   BeanFactory 是基础类型的 IoC 容器，它由 org.springframework.beans.factory.BeanFactory 接口定义，并提供了完整的 IoC 服务支持。简单来说，BeanFactory 就是一个管理 Bean 的工厂，它主要负责初始化各种 Bean，并调用它们的生命周期方法。

   BeanFactory 接口有多个实现类，最常见的是 org.springframework.beans.factory.xml.XmlBeanFactory，它是根据 XML 配置文件中的定义装配 Bean 的。

   创建 BeanFactory 实例时，需要提供 Spring 所管理容器的详细配置信息，这些信息通常采用 XML 文件形式管理。其加载配置信息的代码具体如下所示：

   BeanFactory beanFactory = new XmlBeanFactory(new FileSystemResource(“D://applicationContext.xml”));

2. ApplicationContext

   ApplicationContext 是 BeanFactory 的子接口，也被称为应用上下文。该接口的全路径为 org.springframework.context.ApplicationContext，它不仅提供了 BeanFactory 的所有功能，还添加了对 i18n（国际化）、资源访问、事件传播等方面的良好支持。

   ApplicationContext 接口有两个常用的实现类:
   ClassPathXmlApplicationContext
   该类从类路径 ClassPath 中寻找指定的 XML 配置文件，找到并装载完成 ApplicationContext 的实例化工作

   ApplicationContext applicationContext = new ClassPathXmlApplicationContext(String configLocation);

   FileSystemXmlApplicationContext该类从指定的文件系统路径中寻找指定的 XML 配置文件，找到并装载完成 ApplicationContext 的实例化工作

   ApplicationContext applicationContext = new FileSystemXmlApplicationContext(String configLocation);

bean的使用方法

public class SpringTest{ @Testpublic void Test(){String xmlPath="applicationContext.xml";String xmlPath="src/main/java/applicationContext.xml";//获取factory工厂对象（ApplicationContext）//以ClassPathXMLApplicationContext对象创建factory工厂ApplicationContext applicationContext= new ClassPathXmlApplicationContext(xmlPath);//以FileSystemXmlApplicationContext对象创建factory工厂        ApplicationContext applicationContext1=new FileSystemXmlApplicationContext(xmlPath1);//获取对象  对象获取后为object对象，需要对其进行强制转换      applicationContext.getBean("beanId");//beanId为applicationContest.xml文件中配置的bean的idapplicationContext1.getBean("beanId");}
}

DI

依赖注入主要有两种实现方式，分别是属性 setter 注入和构造方法注入。具体介绍如下。

1. 属性 setter 注入
   指 IoC 容器使用 setter 方法注入被依赖的实例。通过调用无参构造器或无参 static 工厂方法实例化 bean 后，调用该 bean 的 setter 方法，即可实现基于 setter 的 DI。

2. 构造方法注入

   指 IoC 容器使用构造方法注入被依赖的实例。基于构造器的 DI 通过调用带参数的构造方法实现，每个参数代表一个依赖。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:p="http://www.springframework.org/schema/p"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.2.xsd"><!-- 由 Spring容器创建该类的实例对象 --><bean id="personDao" class="com.jm.notes.PersonDaoImpl" /><bean id="personService" class="com.jm.notes.di.PersonServiceImpl"><!-- 将personDao实例注入personService实例中 --><!--setter方式注入--><!--<property name="personDao" ref="personDao"/>--><!--构造方法注入--><constructor-arg index="0" ref="personDao"/></bean>
</beans>

spring 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" xmlns:p="http://www.springframework.org/schema/p"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.2.xsd"></beans>

常用的属性

属性名称	描述
id	是一个 Bean 的唯一标识符，Spring 容器对 Bean 的配置和管理都通过该属性完成
name	Spring 容器同样可以通过此属性对容器中的 Bean 进行配置和管理，name 属性中可以为 Bean 指定多个名称，每个名称之间用逗号或分号隔开
class	该属性指定了 Bean 的具体实现类，它必须是一个完整的类名，使用类的全限定名
scope	用于设定 Bean 实例的作用域，其属性值有 singleton（单例）、prototype（原型）、request、session 和 global Session。其默认值是 singleton
constructor-arg	元素的子元素，可以使用此元素传入构造参数进行实例化。该元素的 index 属性指定构造参数的序号（从 0 开始），type 属性指定构造参数的类型
property	元素的子元素，用于调用 Bean 实例中的 Set 方法完成属性赋值，从而完成依赖注入。该元素的 name 属性指定 Bean 实例中的相应属性名
ref	和 等元素的子元索，该元素中的 bean 属性用于指定对 Bean 工厂中某个 Bean 实例的引用
value	和 等元素的子元素，用于直接指定一个常量值
list	用于封装 List 或数组类型的依赖注入
set	用于封装 Set 类型属性的依赖注入
map	用于封装 Map 类型属性的依赖注入
entry

---

bean的实例化

1. 构造器实例化

      <!--bean实例化对象构造器--><bean id="personTest" class="com.jm.notes.entity.PersonTest"/><!--id为查找实例化对象的标记，通常命名为对象名， class为对象的完全限定名-->
   

2. 静态工厂方法实例化

   /**
   *静态工厂类，里面包含创建对象的静态方法
   */
   public class StaticBaseFactory {   public static PersonTest createPersonTest(){return new PersonTest();}}
   

          <!--bean实例化对象静态工厂--><bean id="personTest1" class="com.jm.notes.entity.StaticBaseFactory"factory-method="createPersonTest"/><!--id为查找实例化对象的标记，通常命名为对象名， class为静态工厂类的完全限定名factory-method为静态工厂类中对应实例对象的静态方法名-->
   

3. 实例化工厂实例化

   /**
   *实例化工厂类，里面包含创建对象的普通方法
   */
   public class StaticBaseFactory {   //实例化类之前会先实例化工厂public StaticBaseFactory() {System.out.println("实例化工厂实例中");}public  PersonTest createPerson(){return new PersonTest();}}
   

   <!--bean实例化对象实例工厂-->
   <!--配置实例工厂-->
   <bean id="myBaseFactory" class="com.jm.notes.entity.StaticBaseFactory"/>
   <!--对象实例化配置-->    
   <bean id="personTest2" factory-bean="myBaseFactory"factory-method="createPerson"/>
   <!--实例化对象id为对象索引标记，factory-bean为指定的实例化工厂的id
   factory-method为指定实例化工厂中的对应对象的实例化方法
   -->
   

---

bean 的作用域

1. 作用域的种类

   1. singleton(常用)

      单例模式，使用 singleton 定义的 Bean 在 Spring 容器中只有一个实例，这也是 Bean 默认的作用域。

   2. prototype(常用)

      原型模式，每次通过 Spring 容器获取 prototype 定义的 Bean 时，容器都将创建一个新的 Bean 实例。

   3. request

      在一次 HTTP 请求中，容器会返回该 Bean 的同一个实例。而对不同的 HTTP 请求，会返回不同的实例，该作用域仅在当前 HTTP Request 内有效。

   4. session

      在一次 HTTP Session 中，容器会返回该 Bean 的同一个实例。而对不同的 HTTP 请求，会返回不同的实例，该作用域仅在当前 HTTP Session 内有效。

   5. global Session

      在一个全局的 HTTP Session 中，容器会返回该 Bean 的同一个实例。该作用域仅在使用 portlet context 时有效。

singleton 作用域

singleton 是 Spring 容器默认的作用域，当一个 Bean 的作用域为 singleton 时，Spring 容器中只会存在一个共享的 Bean 实例，并且所有对 Bean 的请求，只要 id 与该 Bean 定义相匹配，就只会返回 Bean 的同一个实例。

在xml配置中配置对象实例(applicationContextBeanSingleton.xml)

<!--配置对象PersonTest实例化bean并指定作用域scope为Singleton-->
<bean id ="personTest" class="com.jm.notes.entity.PersonTest" scope="singleton"/>
<!--配置另一个PersonTest对象的bean不指定作用域scope-->
<bean id ="personTest1" class="com.jm.notes.entity.PersonTest"/>

测试方法

public class BeanSingletonTest{ @Testpublic void SingletonTest(){String xmlPath = "applicationContextBaseSingleton.xml";ApplicationContext applicationContext =new ClassPathXmlApplicationContext(xmlPath);System.out.println(applicationContext.getBean("personTest"));System.out.println(applicationContext.getBean("personTest"));System.out.println(applicationContext.getBean("personTest1"));System.out.println(applicationContext.getBean("personTest1"));}}

输出结果

com.jm.notes.entity.PersonTest@1563da5
com.jm.notes.entity.PersonTest@1563da5
com.jm.notes.entity.PersonTest@2bbf4b8b
com.jm.notes.entity.PersonTest@2bbf4b8b

从结果上看，前两次获取的Id为personTest的对象的地址完全相同，后两次Id为personTest1的对象地址完全相同，说明申明了Singleton的bean和默认的bean都为单例模式实例化对象。

###prototype 作用域

使用 prototype 作用域的 Bean 会在每次请求该 Bean 时都会创建一个新的 Bean 实例。因此对需要保持会话状态的 Bean（如 Struts2 的 Action 类）应该使用 prototype 作用域。

在xml配置中配置对象实例

<!-配置bean实例对象PersonTest,配置scope为prototype-->
<bean id="personTest" class="com.jm.notes.entity.PersonTest" scope="prototype"/>

test class:

public class PrototypeBeanTest{ @Testpublic void prototypeTest(){String xmlPath="applicationContextBeanPrototype.xml";ApplicationContext applicationContext =new ClassPathXmlApplicationContext(xmlPath);System.out.println(applicationContext.getBean("personTest"));System.out.println(applicationContext.getBean("personTest"));System.out.println(applicationContext.getBean("personTest"));}}

输出结果：

com.jm.notes.entity.PersonTest@1877ab81
com.jm.notes.entity.PersonTest@305fd85d
com.jm.notes.entity.PersonTest@458c1321

每次的输出结果都不相同，说明bean scope申明为prototype的作用域下每次都创建了不同的PersonTest的实例。

---

###Spring生命周期

spring bean 的装配

Bean 的装配可以理解为依赖关系注入，Bean 的装配方式也就是 Bean 的依赖注入方式。Spring 容器支持多种形式的 Bean 的装配方式，如基于 XML 的 Bean 装配、基于 Annotation 的 Bean 装配和自动装配等。

基于xml装配bean

基于xml的注入方式有值注入和构造方法注入两种方式，值注入需要确保值都有对应的setter方法和一个默认无参构造方法；构造方法注入需要有一个对应注入参数对应的构造方法。

创建personTest类：

package com.jm.notes.entity;import java.util.Objects;/*** @描述* @author（创建者） jm* @date（创建时间） 2020/5/27 13:15*/public class PersonTest {private String name;private Integer age;private String sex;public PersonTest(String name, Integer age, String sex) {this.name = name;this.age = age;this.sex = sex;}public PersonTest() {}public String getName() {return name;}public void setName(String name) {this.name = name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}@Overridepublic String toString() {return "PersonTest{" +"name='" + name + '\'' +", age=" + age +", sex='" + sex + '\'' +'}';}}

xml(applicationContextBean.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"xmlns:p="http://www.springframework.org/schema/p"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.2.xsd"><!--Spring bean 基于xml的装配bean--><!-- 使用设值注入方式装配Person实例 --><bean  id="personTest" class="com.jm.notes.entity.PersonTest"><property name="name" value="我是值注入测试的人"/><property name="age" value="12"/><property name="sex" value="男"/></bean><!-- 使用构造方法装配Person实例 --><bean id="personTest1" class="com.jm.notes.entity.PersonTest"><constructor-arg index="0" value="我是构造方法注入测试的人"/><constructor-arg index="1" value="12"/><constructor-arg index="2" value="女"/></bean>
</beans>

test类：

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;/*** @描述* @author（创建者） jm* @date（创建时间） 2020/5/27 15:10*/
public class BeanAssemblyXmlTest {@Testpublic void assemblyXmlTest(){String xmlPath ="applicationContextBean.xml";ApplicationContext applicationContext=new ClassPathXmlApplicationContext(xmlPath);System.out.println(applicationContext.getBean("personTest"));System.out.println(applicationContext.getBean("personTest1"));}
}

输出结果：

PersonTest{name='我是值注入测试的人', age=12, sex='男'}
PersonTest{name='我是构造方法注入测试的人', age=12, sex='女'}

######xml装配的当bean的数量过多时会导致xml文件变得臃肿不好维护和升级。

基于annotation（注解）装配bean

基于Annotation的常用注解：

1. @Component

   用于表示一个组件bean，可以作用于任何层次上。

2. @Repository

   用于数据访问层（dao层）的类标注为spring的bean。

3. @Service

   通常作用域业务层（service层），用于将业务层的类标注为spring的bean。

4. @Controller

   通常用于控制层（Controller层），用于将控制层的类标注为spring的bean。

5. @Autowired

   用于对bean属性变量、属性的setter方法和构造函数进行标注，配合对应的注解助理bean的自动配置工作。默认按bean的类型进行装配。

6. @Resource
   作用和@Autowired相同，其区别在于 @Autowired 默认按照 Bean 类型装配，而 @Resource 默认按照 Bean 实例名称进行装配。

   @Resource 中有两个重要属性：name 和 type。

   Spring 将 name 属性解析为 Bean 实例名称，type 属性解析为 Bean 实例类型。如果指定 name 属性，则按实例名称进行装配；如果指定 type 属性，则按 Bean 类型进行装配。

7. @Qualifier

   与 @Autowired 注解配合使用，会将默认的按 Bean 类型装配修改为按 Bean 的实例名称装配，Bean 的实例名称由 @Qualifier 注解的参数指定。

@RestController vs @Controller

• @Controller 返回一个页面
• @RestController 返回JSON 或 XML 形式数据
• @Controller +@ResponseBody 返回JSON 或 XML 形式数据