Spring框架已集成20多个模块。主要是核心容器、数据访问/集成Web、AOP、工具、新闻和测试模块。

1.spring轻量级，开源J2EE框架 轻量级：包装数量少，体积小，可独立使用。 开源：免费提供源代码。 框架：开发更方便，码更简洁。

2.解决企业应用开发的复杂性

3.两个核心部分：IOC,AOP。 IOC : 控制反转，把创建对象的过程交给spring管理。 AOP : 面向切面，不修改源代码进行功能增强。

4.特点

• 方便解耦，简化开发
• AOP编程支持
• 方便程序测试
• 方便和其他框架集成
• 方便进行事务操作
• 降低API使用难度

• 轻量级 - Spring 在代码量和透明度方面都很轻便。
• IOC - 控制反转实现了松散耦合。
• AOP - 面向切面编程,可以将应用业务逻辑和系统服务分离，以实现高内聚。
• 容器 - Spring 负责创建和管理对象（Bean）的生命周期和配置。
• MVC - 对 web 应用提供了高度可配置性，其他框架的集成也十分方便。
• 事务管理 - 提供了用于事务管理的通用抽象层。Spring 的事务支持也可用于容器较少的环境。
• JDBC 异常 - Spring 的 JDBC 抽象层提供了一个异常层次结构，简化了错误处理策略。

Spring 配置文件是 XML 文件。该文件主要包含类信息。它描述了这些类是如何配置以及相互引入的。但是，XML 配置文件冗长且更加干净。如果没有正确规划和编写，那么在大项目中管理变得非常困难。

Spring 应用一般有以下组件：

接口 - 定义功能。 Bean 类 - 它包含属性，setter 和 getter 方法，函数等。 Spring 面向切面编程（AOP） - 提供面向切面编程的功能。 Bean 配置文件 - 包含类的信息以及如何配置它们。 用户程序 - 它使用接口。

作为一个成熟的 Spring Web 应用程序。 作为第三方 Web 框架，使用 Spring Frameworks 中间层。 用于远程使用。 作为企业级 Java Bean，它可以包装现有的 POJO（Plain Old Java Objects）。

1.配置对象创建

<bean id="id名字" class="类全路径：包+类"></bean>

2.加载spring配置文件

ApplicationContext context=new ClassPathXmlApplicationContext(.xml);

3.获取配置创建的对象

类名 实例化=context.getBean("id名字",类名.class);

1.控制反转，把对象的创建和对象之间的调用过程，交给spring进行管理。 2.使用目的：降低耦合度

它将最小化应用程序中的代码量。 它将使您的应用程序易于测试，因为它不需要单元测试用例中的任何单例或 JNDI 查找机制。 它以最小的影响和最少的侵入机制促进松耦合。 它支持即时的实例化和延迟加载服务。

Spring IOC负责创建对象、管理对象（通过依赖注入（DI）、装配对象、配置对象，并且管理这些对象的整个生命周期。

• DI： Dependency Injection（依赖注入）的简写。

• 不必创建对象，但必须描述如何创建它们。
• 不是直接在代码中将组件和服务连接在一起，而是描述配置文件中哪些组件需要哪些服务。
• 由 IOC 容器将它们装配在一起，相当于把每个bean和bean之间的关系交给Spring IOC容器来管理。

控制反转（IOC）和依赖注入（DI）是从不同角度描述同一件事情，利用依赖关系注入的方式，实现对像之间的解耦。

1.xml解析、工程模式、反射机制。

进一步降低耦合度

• IOC思想基于IOC容器，IOC容器底层就是对象工厂。
• Spring提供IOC容器实现两种方式：

1. BeanFactory：IOC容器最基本实现方式，是spring内部使用的接口，不提供给开发人员

加载配置文件时不会创建对象，在获取对象时在创建

2. ApplicationContext：是BeanFactory子接口，提供更多更强大的功能，一般提供给开发人员

加载配置文件时创建对象

• BeanFactory子接口

ConfigurableApplicationContext:相关扩展功能

• ApplicationContext接口有实现类

FileSystemXmlApplicationContext ClassPathXmlApplicationContext

它们是构成用户应用程序主干的对象。 Bean 由 Spring IoC 容器管理。 它们由 Spring IoC 容器实例化，配置，装配和管理。 Bean 是基于用户提供给容器的配置元数据创建。

1.Spring创建对象 2.Spring属性注入

Spring容器中的Bean是否线程安全，容器本身并没有提供Bean的线程安全策略，因此可以说spring容器中的Bean本身不具备线程安全的特性，但是还是要结合具体的scope的Bean去研究。

①set方法注入 ②构造函数注入 ③P命名空间注入 ④spel表达式注入 ⑤复杂类型（集合）注入

①set方法注入 在bean标签内部使用property标签，相当于调用set方法

<bean id="user" class="com.wpq.pojo.User">
        <property name="name" value="zs"></property>
        <property name="password" value="123"></property>
   </bean>

②构造函数注入 在bean标签内部使用constructor-arg标签，相当于构造函数注入

<bean id="user" class="com.wpq.pojo.User">
     <constructor-arg index="0" type="java.lang.String" name="name" value="张三"></constructor-arg>
     <constructor-arg index="1" type="java.lang.String" name="password" value="123"></constructor-arg>
 </bean>

③P命名空间注入

<?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/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--第3种注入方式:p命名空间,记得引入一个命名空间字符串:xmlns:p="http://www.springframework.org/schema/p"-->
    <!--p:property的缩写!简化了set方式注入的代码编写-->
   <bean name="car" class="com.wpq.domain.Car" p:logo="马车" p:color="黑色"/>
   <bean name="person" class="com.wpq.domain.Person" p:name="阮小二" p:age="40" p:car-ref="car"/>
</beans>

spring有两种类型bean：Bean，FactoryBean。

1. Bean：在配置文件中定义的bean类型就是返回类型
2. FactoryBean：在配置文件中定义的bean类型可以和返回值不一样 第一步：创建类，让这个类作为工厂bean，实现接口FactoryBean 第二步：实现接口中方法，在实现的方法中定义返回的bean类型

① singleton 单例模式 (Scope默认)：@Scope(value = “singleton”) ② prototype 多例模式：每次获取Bean的时候会有一个新的实例 ③ request： request表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效 ④ session:该作用域表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP session内有效 ⑤ global session：该作用域类似于标准的HTTP Session作用域，不过它仅仅在基于portlet的web应用中才有意义。Portlet规范定义了全局Session的概念，它被所有构成某个 portlet web应用的各种不同的portlet所共享。在global session作用域中定义的bean被限定于全局portlet Session的生命周期范围内。如果你在web中使用global session作用域来标识bean，那么web会自动当成session类型来使用。

1.设置bean是单实例还是多实例（.默认情况是单实例）

单实例 2.通过bean标签中scope属性设置单实例或多实例

• scope： 1.singlton：默认单实例 2.prototype：多实例 3.request：请求 4.session：

1.创建时机 singlton：加载文件时创建对象 prototype：在getBean时创建

生命周期：从对象的创建到销毁的过程 1.通过构造器创建（无参构造） 2.为属性设置值和其他bean引用（set方法） 3.调用bean初始化方法（配置） 4.可使用（对象获取到） 5.当容器关闭时，调用bean销毁方法（需要配置销毁方法）

bean的后置处理器，bean的生命周期 3之前：把bean实例对象传给bean后置处理器 postProcessBeforeInitialization 3之后：把bean实例对象传给bean后置处理器postProcessAfterInitialization

1.创建类 ，实现接口BeanPostProcessor，创建后置处理器 2.配置文件配置

只有将 bean 用作另一个 bean 的属性时，才能将 bean 声明为内部 bean。

当 bean 在 Spring 容器中组合在一起时，它被称为装配或 bean 装配。 Spring 容器需要知道需要什么 bean 以及容器应该如何使用依赖注入来将 bean 绑定在一起，同时装配 bean。

Spring 容器能够自动装配 bean。也就是说，可以通过检查 BeanFactory 的内容让 Spring 自动解析 bean 的协作者。 自动装配的不同模式：

no - 默认设置，表示没有自动装配。应使用显式 bean 引用进行装配。 byName - 根据 bean 的名称注入对象依赖项。匹配并装配其属性与 XML 文件中由相同名称定义的 bean。 byType - 根据类型注入对象依赖项。如果属性的类型与 XML 文件中的一个 bean 名称匹配，则匹配并装配属性。 构造函数 - 它通过调用类的构造函数来注入依赖项。它有大量的参数。 autodetect - 首先容器尝试通过构造函数使用 autowire 装配，如果不能，则尝试通过 byType 自动装配。

• 覆盖的可能性 - 您始终可以使用 和 设置指定依赖项，这将覆盖自动装配。
• 基本元数据类型 - 简单属性（如原数据类型，字符串和类）无法自动装配。
• 令人困惑的性质 - 总是喜欢使用明确的装配，因为自动装配不太精确。

1.基于xml配置 2.基于注解配置 3.基于java API配置

1.基于xml配置 bean 所需的依赖项和服务在 XML 格式的配置文件中指定。这些配置文件通常包含许多 bean 定义和特定于应用程序的配置选项。它们通常以 bean 标签开头。

<bean id="studentbean" class="org.edureka.firstSpring.StudentBean">
 <property name="name" value="Edureka"></property>
</bean>

2.基于注解配置 可以通过在相关的类，方法或字段声明上使用注解，将 bean 配置为组件类本身。默认情况下，Spring 容器中未打开注解装配。因此，需要在使用它之前在 Spring 配置文件中启用它。

<beans>
<context:annotation-config/>
<!-- bean definitions go here -->
</beans>

3.基于java API配置 @Bean 和 @Configuration 来实现。 @Bean 注解扮演与 元素相同的角色。 @Configuration 类允许通过简单地调用同一个类中的其他 @Bean 方法来定义 bean 间依赖关系。

@Configuration
public class StudentConfig { 
        
    @Bean
    public StudentBean myStudent() { 
        
        return new StudentBean();
    }
}

在spring配置文件中，使用bean标签，并添加属性

① id (唯一标识) ② name（获取bean的键） ③ class（指定bean对应类的全路径） ④ scope（单例或者多例设计模式） ⑤ lazy-init（延时加载，默认值：false）：设置false时,只有调用getBean方法才会创建对象 ⑥ init-method（指定：监听对象创建的方法） ⑦ destroy-method（指定：监听对象销毁的方法）

创建对象，默认执行无参构造方法。

DI : 依赖注入，就是注入属性 1.set方法注入

• 创建一个类，定义属性和set方法
• 在spring配置文件中配置对象创建和属性注入

2.有参构造函数

• 创建类，定义属性，创建有参构造方法
• 有参注入

3.p名称空间注入 可简化基于xml注入 第一步 添加p名称空间在配置文件中

第二步 进行属性注入，在bean标签中进行操作

（1）null值

（2）包含特殊符号

（1）创建service类和dao类 （2）在service类中调用dao中方法 （3）在spring配置文件中配置

什么是 spring 的内部 bean？ 只有将 bean 用作另一个 bean 的属性时，才能将 bean 声明为内部 bean。

（1）一对多关系：一个部门中多个员工 （2）在实体类之间表示一对多关系 （3）在spring配置文件中配置

第一种： 第二种

1.数组属性 2.List集合属性 3.注入Map属性 （1）创建类定义属性，生成set方法 （2）在spring配置文件中

4.在集合里面设置对象类型值

5.把集合注入部分提取出 （1）在spring配置文件中引入util

根据指定装配规则（属性名称或属性类型），spring自动将匹配的属性值进行注入。

1.直接配置数据库信息 （1）配置德鲁伊连接池 2.引入外部属性文件配置数据库连接池 （1）创建外部属性文件，properties格式文件，写数据库信息 （2）把外部属性properties文件引入spring配置文件中

注解：是代码里特殊的标记，格式：@注解名称（属性名称=属性值…) 使用方法：作用在类、方法、属性上。 目的：简化xml配置

Spring针对Bean管理中创建对象提供注解 1.@Component 2.@Service 3.@Controller 4.@Repository 功能一样

不使用 XML 来描述 bean 装配，开发人员通过在相关的类，方法或字段声明上使用注解将配置移动到组件类本身。它可以作为 XML 设置的替代方案。

Spring 的 Java 配置是通过使用 @Bean 和 @Configuration 来实现。

• @Bean 注解扮演与 元素相同的角色。
• @Configuration 类允许通过简单地调用同一个类中的其他 @Bean 方法来定义 bean 间依赖关系。

@Configuration
public class StudentConfig { 
        
    @Bean
    public StudentBean myStudent() { 
        
        return new StudentBean();
    }
}

默认情况下，Spring 容器中未打开注解装配。因此，要使用基于注解装配，我们必须通过配置 <context：annotation-config /> 元素在 Spring 配置文件中启用它。

①注解实现IOC

• @Component：组件注解，用来创建一个对象，等同于在xml中写了bean标签。

②注解实现DI

• @Value(“…”): 只能给简单类型注入值,不能给引用类型注入值，使用在成员变量上或set方法上 (简单类型=String+8种基本类型) 注意：该注解可以引入配置文件中的变量。 语法: @Value(“${age}”)
• @Autowired: 自动装载对象,默认情况下是按照类型来进行匹配。
• @Qualifier: 该注解一般要结合@Autowired的一起使用,当@Autowired根据类型无法匹配对象的时候,进行辅助,根据名称进行依赖注入.解决无法根据类型进行唯一性对象匹配的问题.
• @Resource: 等同于@Autowired+@Qualifier,该注解是Java原生的注解,既可以根据类型,又可以根据名称进行依赖注入.

③ Bean标签的属性对应的注解 作用域： @Scope(scopeName=“单例/多例”) 延迟加载：@Lazy: 等同于中的lazy-init属性 ，设置是否延迟加载 创建对象监听：@PostConstruct 指定监听对象创建的方法 销毁对象监听：@PreDestroy 指定监听对象销毁的方法

④ 组件注解 @Component:组件注解 @Controller:组件注解,一般用于web层对象的创建 @Service:组件注解,一般用于service层对象的创建 @Repository:组件注解,一般用于dao层对象的创建

⑤ 测试注解 @RunWith(SpringJUnit4ClassRunner.class) ：括号内指定完成测试工作的类 @ContextConfiguration(“classpath:appication-Collection.xml”) : 指定要加载的XML配置文件 @Test ：写在测试方法上

• @Component：将 java 类标记为 bean。它是任何 Spring 管理组件的通用构造型。spring 的组件扫描机制现在可以将其拾取并将其拉入应用程序环境中。
• @Controller：这将一个类标记为 Spring Web MVC 控制器。标有它的 Bean 会自动导入到 IoC 容器中。
• @Service：此注解是组件注解的特化。它不会对 @Component 注解提供任何其他行为。您可以在服务层类中使用 @Service 而不是 @Component，因为它以更好的方式指定了意图。
• @Repository：这个注解是具有类似用途和功能的 @Component 注解的特化。它为 DAO 提供了额外的好处。它将 DAO 导入 IoC 容器，并使未经检查的异常有资格转换为 Spring DataAccessException。

@Required 应用于 bean 属性 setter 方法。此注解仅指示必须在配置时使用 bean 定义中的显式属性值或使用自动装配填充受影响的 bean 属性。如果尚未填充受影响的 bean 属性，则容器将抛出 BeanInitializationException。

public class Employee { 
        
    private String name;
    @Required
    public void setName(String name){ 
        
        this.name=name;
    }
    public string getName(){ 
        
        return name;
    }
}

@Autowired 可以更准确地控制应该在何处以及如何进行自动装配。此注解用于在 setter 方法，构造函数，具有任意名称或多个参数的属性或方法上自动装配 bean。默认情况下，它是类型驱动的注入。

public class Employee { 
        
    private String name;
    @Autowired
    public void setName(String name) { 
        
        this.name=name;
    }
    public string getName(){ 
        
        return name;
    }
}

当创建多个相同类型的 bean 并希望仅使用属性装配其中一个 bean 时，您可以使用@Qualifier 注解和 @Autowired 通过指定应该装配哪个确切的 bean 来消除歧义。 例如，这里我们分别有两个类，Employee 和 EmpAccount。在 EmpAccount 中，使用@Qualifier 指定了必须装配 id 为 emp1 的 bean。

EmpAccount.java

public class EmpAccount { 
        
    private Employee emp;

    @Autowired
    @Qualifier(emp1)
    public void showName() { 
        
        System.out.println(“Employee name : ”+emp.getName);
    }
}

@RequestMapping 注解用于将特定 HTTP 请求方法映射到将处理相应请求的控制器中的特定类/方法。此注释可应用于两个级别： 类级别：映射请求的 URL 方法级别：映射 URL 以及 HTTP 请求方法

① 在XML文件中引入Context的约束 ② 配置组件扫描器 ③使用注解

第一步：引入AOP依赖 第二步：开启组件扫描 第三步：创建类 ，在类上面添加创建对象注解

1.设置哪些扫描2.设置哪些不扫描

1.@Aitowired：根据属性类型注入 第一步：把service和dao对象创建，在七类添加创建对象的注解 第二步：在service对象注入

2.@Qualifier：根据属性名称进行注入 和@Autowired一起使用

3.@Resource：属性类型、名称

4.@Value：注入普通属性类型

1.创建配置类，代替xml配置文件

2.测试类

什么是AOP(Aspect Oriented Programming)

1. 面向切面编程，利用AOP可以对业务逻辑进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
2. 不通过修改源代码方式添加新功能

实现 AOP 的技术，主要分为两大类：

• 静态代理 - 指使用 AOP 框架提供的命令进行编译，从而在编译阶段就可生成 AOP 代理类，因此也称为编译时增强； 编译时编织（特殊编译器实现） 类加载时编织（特殊的类加载器实现）。
• 动态代理 - 在运行时在内存中“临时”生成 AOP 动态代理类，因此也被称为运行时增强。 JDK 动态代理 C