spring知识回顾

嗯，又要开始......了

一、前言

1.1 Spring的概述

1.1.1 什么是Spring

• Spring：SE/EE开发的一站式框架。
  • 一站式框架：有EE开发的每一层解决方案。
  • WEB层 ：SpringMVC
  • Service层 ：Spring的Bean管理，Spring声明式事务
  • DAO层 ：Spring的Jdbc模板，Spring的ORM模块

1.1.2 为什么学习Spring

1.1.3 Spring的版本

Spring3.x、Spring4.x、Spring5.x

二、入门

2.1 Spring的入门（IOC）

2.1.1 什么是IOC

• IOC: Inversion of Control(控制反转)。
• 控制反转：将对象的创建权反转给（交给）Spring。

2.1.2 下载Spring的开发包

官网：http://spring.io/

2.1.3 解压Spring的开发包

• docs ：Spring的开发规范和API
• libs ：Spring的开发的jar和源码
• schema ：Spring的配置文件的约束

2.1.4 创建web项目，引入jar包

2.1.5 创建接口和类

• 如果底层的实现切换了，需要修改源代码，能不能不修改程序源代码对程序进行扩展？

  
  

2.1.6 将实现类交给Spring管理

在spring的解压路径下spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configuration.html

2.1.7 编写测试类

2.1.8 IOC和DI

• IOC：控制反转，将对象的创建权反转给了Spring。
  • DI：依赖注入，前提必须有IOC的环境，Spring管理这个类的时候将类的依赖的属性注入（设置）进来。
• 面向对象的时候
  • 依赖

  Class A{
  }

  Class B{
    public void xxx(A a){
    }
  }

• 继承:is a

  Class A{
  }
  Class B extends A{
  }

• 聚合:has a

3.1 Spring的工厂类

3.1.1 Spring工厂类的结构图

• ApplicationContext继承BeanFactory。

3.1.2 新老版本工厂类

1. BeanFactory：调用getBean的时候，才会生成类的实例。（老）
2. ApplicationContext：加载配置文件的时候，就会将Spring管理的类都实例化。
   ApplicationContext有两个实现类
   ClassPathXmlApplicationContext ：加载类路径下的配置文件
   FileSystemXmlApplicationContext ：加载文件系统下的配置文件

4.1 Spring的配置

4.1.1 Bean的相关的配置

1. <bean>标签的id和name的配置

• id :使用了约束中的唯一约束。里面不能出现特殊字符的。
• name :没有使用约束中的唯一约束（理论上可以出现重复的，但是实际开发不能出现的）。里面可以出现特殊字符。
  • Spring和Struts1框架整合的时候
  • <bean name=”/user” class=””/>

2. Bean的生命周期的配置（了解）

• init-method :Bean被初始化的时候执行的方法
• destroy-method :Bean被销毁的时候执行的方法（Bean是单例创建，工厂关闭）

3. Bean的作用范围的配置（重点）

• scope ：Bean的作用范围
  • singleton ：默认的，Spring会采用单例模式创建这个对象。
  • prototype ：多例模式。（Struts2和Spring整合一定会用到）
  • request ：应用在web项目中，Spring创建这个类以后，将这个类存入到request范围中。
  • session ：应用在web项目中，Spring创建这个类以后，将这个类存入到session范围中。
  • globalsession ：应用在web项目中，必须在porlet环境下使用。但是如果没有这种环境，相对于session。

4.2 Spring的Bean的管理（XML方式）

4.2.1 Spring的Bean的实例化方式

Bean已经都交给Spring管理，Spring创建这些类的时候，有几种方式

1. 无参构造方法的方式（默认）

   
   
   

2. 静态工厂实例化的方式

   
   
   

3. 实例工厂实例化的方式

   
   
   

4.2.2 Spring的属性注入

1. 构造方法的方式的属性注入

   
   

2. Set方法的方式的属性注入

   
   
   
3. P名称空间的属性的注入（Spring2.5以后）

• 通过引入p名称空间完成属性的注入
  写法：
  普通属性 p:属性名=”值”
  对象属性 p:属性名-ref=”值”

• p名称空间的引入

  
  

• 使用p名称空间

  
  

4. SpEL的属性注入（Spring3.0以后）
   SpEL：Spring Expression Language，Spring的表达式语言。
   语法：#{SpEL}

   
   

4.2.3 集合类型属性注入（了解）

<!-- Spring的集合属性的注入============================ -->
    <!-- 注入数组类型 -->
    <bean id="collectionBean" class="com.itheima.spring.demo5.CollectionBean">
        <!-- 数组类型 -->
        <property name="arrs">
            <list>
                <value>王东</value>
                <value>赵洪</value>
                <value>李冠希</value>
            </list>
        </property>
        
        <!-- 注入list集合 -->
        <property name="list">
            <list>
                <value>李兵</value>
                <value>赵如何</value>
                <value>邓凤</value>
            </list>
        </property>
        
        <!-- 注入set集合 -->
        <property name="set">
            <set>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </set>
        </property>
        
        <!-- 注入Map集合 -->
        <property name="map">
            <map>
                <entry key="aaa" value="111"/>
                <entry key="bbb" value="222"/>
                <entry key="ccc" value="333"/>
            </map>
        </property>
    </bean>

4.3 Spring的分模块开发的配置

4.3.1 在加载配置文件的时候，加载多个

4.3.2 在一个配置文件中引入多个配置文件

---

三、Spring IOC及AOP

3.1 Spring的IOC的注解开发

3.1.1 入门

1. 创建web项目，引入jar包

• 在Spring4的版本中，除了引入基本的开发包以外，还需要引入aop的包

  
  

2. 引入Spring的配置文件

• 在src下创建applicationContext.xml
  • 引入约束：使用注解开发引入context约束

  • 约束：spring-framework-4.2.4.RELEASE/docs/spring-framework-reference/html/xsd-configuration.html

    
    

3. 创建接口及实现类

4. 开启Spring的组件扫描

   
   

5. 在类上添加注解

   
   

6. 编写测试类

   
   
7. 注解方式设置属性的值

• 注解方式
  ：使用注解方式，可以没有set方法的。
  • 属性如果有set方法，需要将属性注入的注解添加到set方法

  • 属性如果没有set方法，需要将属性注入的注解添加属性上。

    
    

3.1.2 Spring的IOC的注解的详解

1. @Component：组件

• 修饰一个类，将这个类交给Spring管理
• 这个注解有三个衍生注解（功能类似）
  • @Controller：web层
  • @Service：service层
  • @Repository：dao层

2. 属性注入的注解

• 普通属性：
  • @Value：设置普通属性的值。
• 对象类型属性：
  • @Autowired：设置对象类型的属性的值。默认是按照类型完成属性注入（名称是谁无所谓）

    • 我们习惯是按照名称完成属性注入：必须让@Autowired注解和@Qualifier注解同时使用

      
      
      

• @Resource：完成对象类型的属性的注入，按照名称完成属性注入。（默认是按照类型）

  
  

3. Bean的其它的注解

• 生命周期相关的注解（了解）
  • @PostConstruct：init-method
  • @PreDestroy：destroy-method
• Bean作用范围的注解
  • @Scope：作用范围
    • singleton：默认单例
    • prototype：多例
    • request
    • session
    • globalsession

4. XML和注解的比较

• 适用场景
  • XML：可以使用任何场景
    • 结构清晰，维护方便
  • 注解：有些地方用不了，这个类不是自己提供的。
    • 开发方便。

5. XML和注解整合开发

• XML管理Bean，注解完成属性注入。

3.2 Spring的AOP的XML开发

3.2.1 AOP的概述

1. 什么是AOP

   
   
   

   AOP：面向切面编程。AOP是OOP的扩展和延伸，解决OOP开发遇到的问题。

2. Spring底层的AOP实现原理

• 动态代理
  • JDK动态代理：只能对实现了接口的类产生代理。
  • Cglib动态代理（类似于Javascript第三方代理技术）：对没有实现接口的类产生代理对象。生成子类对象。

3.2.2 Spring的AOP底层实现（了解）

1. JDK动态代理

   
   
   

2. Cglib动态代理

   
   
   

3.2.3 Spring的AOP的开发（AspectJ的XML的方式）

1. Spring的AOP的简介

• AOP思想最早是由AOP联盟组织提出的。Spring使用这种思想最好的框架
  • Spring的AOP有自己实现的方式（非常繁琐）。AspectJ是一个AOP的框架，Spring引入AspectJ作为自身AOP的开发。
  • Spring两套AOP开发方式
    • Spring传统方式（弃用）
    • Spring基于AspectJ的AOP开发（使用）

2. AOP开发中相关术语：

   
   

3.2.4 Spring的AOP的入门（AspectJ的XML的方式）

1. 创建web项目，引入jar包

• 引入基本开发包

• 引入aop开发相关jar包

  
  

2. 引入Spring的配置文件

• 引入aop的约束

  
  

3. 编写目标类并完成配置

   
   
4. 编写测试类：

• Spring整合Junit单元测试

  
  

5. 编写一个切面

   
   

6. 将切面类交给Spring

   
   

7. 通过AOP的配置实现

   
   

3.2.5 Spring中通知类型

1. 前置通知：在目标方法执行之前进行操作

• 前置通知：获得切入点信息

  
  
  

2. 后置通知：在目标方法执行之后进行操作

• 后置通知：获得方法的返回值。

  
  
  
  

3. 环绕通知：在目标方法执行之前和之后进行操作

   
   
   

• 环绕通知可以阻止目标方法的执行

  
  

4. 异常抛出通知：在程序出现异常的时候，进行的操作

   
   
   

5. 最终通知：无论代码是否有异常，总是会执行

   
   
   

6. 引介通知（不用会）

3.2.6 Spring的切入点表达式写法：

1. 切入点表达式语法：

• 基于execution的函数完成的
• 语法(public可省略)
  • [访问修饰符] 方法返回值 包名.类名.方法名（参数）

public void com.tong.spring.CustomerDao.save(..)
* *.*.*.*Dao.save(..)
* com.tong.spring.CustomerDao+.save(..) 当前类及其子类都可以
* com.tong.spring..*.*(..) 这个包及其子包下的所有类所有方法

3.3 Spring的AOP的基于AspectJ注解开发

3.3.1 Spring的基于ApsectJ的注解的AOP开发

1. 创建项目，创建jar包

   
   
2. 引入配置文件

3. 编写目标类并配置

   
   

4. 编写切面类并配置

   
   
   
5. 使用注解的AOP对象目标类进行增强

• 在配置文件中打开注解的AOP开发

  
  

• 在切面类上使用注解

  
  

6. 编写测试类

   
   

3.3.2 Spring的注解的AOP的通知类型

1. @Before ：前置通知

   
   

2. @AfterReturning ：后置通知

   
   

3. @Around ：环绕通知

   
   

4. @AfterThrowing ：异常抛出通知

   
   

5. @After ：最终通知

   
   

3.3.3 Spring的注解的AOP的切入点的配置

---

---

四、Spring JDBC模板及事务管理

4.1 Spring的JDBC的模板的使用

4.1.1 Spring的JDBC的模板

Spring是EE开发的一站式的框架，有EE开发的每层的解决方案。Spring对持久层也提供了解决方案：ORM模块和JDBC的模板。
Spring提供了很多的模板用于简化开发：

1. JDBC模板使用的入门

• 创建项目，引入jar包
• 引入基本开发包：
• 数据库驱动

• Spring的JDBC模板的jar包

  
  

2. 创建数据库和表

create database spring4_day03;
use spring4_day03;
create table account(
    id int primary key auto_increment,
    name varchar(20),
    money double
);

3. 使用JDBC的模板：保存数据

   
   

4.1.2 将连接池和模板交给Spring管理

1. 引入Spring的配置文件

   
   

2. 使用Jdbc的模板

• 引入spring_aop的jar包

  
  

4.1.3 使用开源的数据库连接池：

1. DBCP的使用

• 引入jar包

  
  

• 配置DBCP连接池

  
  

2. C3P0的使用

• 引入c3p0连接池jar包

  
  

• 配置c3p0连接池

  
  

4.1.4 抽取配置到属性文件

1. 定义一个属性文件

   
   
2. 在Spring的配置文件中引入属性文件

• 第一种

  
  

• 第二种（推荐，无需找类）

  
  

3. 引入属性文件的值

   
   

4. 测试

   
   

4.1.5 使用JDBC的模板完成CRUD的操作

1. 保存操作

   
   

2. 修改操作

   
   

3. 删除操作

   
   

4. 查询操作

• 查询某个属性

  
  

• 查询返回对象或集合

  
  

• 数据封装

  
  

4.2 Spring的事务管理

4.2.1 事务的回顾

1. 什么是事务
   事务：逻辑上的一组操作，组成这组操作的各个单元，要么全都成功，要么全都失败。
2. 事务的特性

• 原子性：事务不可分割
• 一致性：事务执行前后数据完整性保持一致
• 隔离性：一个事务的执行不应该受到其他事务的干扰
• 持久性：一旦事务结束，数据就持久化到数据库

3. 如果不考虑隔离性引发安全性问题

• 读问题
  • 脏读 ：一个事务读到另一个事务未提交的数据
  • 不可重复读 ：一个事务读到另一个事务已经提交的update的数据，导致一个事务中多次查询结果不一致
  • 虚读、幻读 ：一个事务读到另一个事务已经提交的insert的数据，导致一个事务中多次查询结果不一致。
• 写问题
  • 丢失更新

4. 解决读问题
   设置事务的隔离级别

• Read uncommitted ：未提交读，任何读问题解决不了。
• Read committed ：已提交读，解决脏读，但是不可重复读和虚读有可能发生。*
• Repeatable read ：重复读，解决脏读和不可重复读，但是虚读有可能发生。*
• Serializable ：解决所有读问题。

4.2.2 Spring的事务管理的API

1. PlatformTransactionManager：平台事务管理器
   平台事务管理器：接口，是Spring用于管理事务的真正的对象。

• DataSourceTransactionManager ：底层使用JDBC管理事务
• HibernateTransactionManager ：底层使用Hibernate管理事务

2. TransactionDefinition ：事务定义信息
   事务定义：用于定义事务的相关的信息，隔离级别、超时信息、传播行为、是否只读
3. TransactionStatus：事务的状态
   事务状态：用于记录在事务管理过程中，事务的状态的对象。
4. 事务管理的API的关系：
   Spring进行事务管理的时候，首先平台事务管理器根据事务定义信息进行事务的管理，在事务管理过程中，产生各种状态，将这些状态的信息记录到事务状态的对象中。

4.2.3 Spring的事务的传播行为

Spring中提供了七种事务的传播行为：

1. 保证多个操作在同一个事务中

• PROPAGATION_REQUIRED ：默认值，如果A中有事务，使用A中的事务，如果A没有，创建一个新的事务，将操作包含进来
• PROPAGATION_SUPPORTS ：支持事务，如果A中有事务，使用A中的事务。如果A没有事务，不使用事务。
• PROPAGATION_MANDATORY ：如果A中有事务，使用A中的事务。如果A没有事务，抛出异常。

2. 保证多个操作不在同一个事务中

• PROPAGATION_REQUIRES_NEW ：如果A中有事务，将A的事务挂起（暂停），创建新事务，只包含自身操作。如果A中没有事务，创建一个新事务，包含自身操作。
• PROPAGATION_NOT_SUPPORTED ：如果A中有事务，将A的事务挂起。不使用事务管理。
• PROPAGATION_NEVER ：如果A中有事务，报异常。

3. 嵌套式事务

• PROPAGATION_NESTED ：嵌套事务，如果A中有事务，按照A的事务执行，执行完成后，设置一个保存点，执行B中的操作，如果没有异常，执行通过，如果有异常，可以选择回滚到最初始位置，也可以回滚到保存点。

4.2.4 Spring的事务管理

1. 搭建Spring的事务管理的环境

• 创建Service的接口和实现类

  
  

• 创建Dao的接口和是实现类

  
  

• 配置Service和DAO：交给Spring管理

  
  

• 在DAO中编写扣钱和加钱方法：

  • 配置连接池和JDBC的模板

    
    

  • 在DAO注入JDBC的模板

    
    

• 测试

4.2.5 Spring的事务管理：一类：编程式事务（需要手动编写代码）--了解

1. 第一步：配置平台事务管理器

   
   

2. 第二步：Spring提供了事务管理的模板类

   
   

3. 第三步：在业务层注入事务管理的模板

   
   

4. 编写事务管理的代码

   
   

5. 测试

4.2.6 Spring的事务管理：二类：声明式事务管理（通过配置实现）---AOP

1. XML方式的声明式事务管理

• 第一步：引入aop的开发包

• 第二步：恢复转账环境

• 第三步：配置事务管理器

  
  

• 第四步：配置增强

  
  

• 第五步：AOP的配置

  
  

• 测试

2. 注解方式的声明式事务管理

• 第一步：引入aop的开发包

• 第二步：恢复转账环境

• 第三步：配置事务管理器

  
  

• 第四步：开启注解事务

  
  

• 第五步：在业务层添加注解