SSM - spring 业务层框架

Spring 框架

Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，

以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented

Programming：面向切面编程）为内核，提供了展现层 SpringMVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架。

Spring 框架的优势

1方便解耦简化开发

通过 Spring 提供的 IoC 容器，可以将对象间的依赖关系交由 Spring 进行控制，避免硬编码所造成的过度程序耦合。

用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

2 AOP编程的支持

通过 Spring 的 AOP 功能，方便进行面向切面的编程，许多不容易用传统 OOP 实现的功能可以通过 AOP 轻松应付。

3声明式事务的支持

可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务的管理，提高开发效率和质量。

4方便程序的测试

可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。

5方便集成各种优秀框架

Spring 可以降低各种框架的使用难度，提供了对各种优秀框架（Struts、Hibernate、Hessian、 Quartz等）的直接支持。

6降低 JavaEE API 的使用难度

Spring 对 JavaEE API（如 JDBC、 JavaMail、远程调用等）进行了薄薄的封装层，使这些 API 的使用难度大为降低。

7 Spring的源码是经典学习范例

Spring 的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对 Java 设计模式灵活运用以及对 Java 技术的高深造诣。

它的源代码无意是 Java 技术的最佳实践的范例。

程序的耦合

耦合是指程序间的依赖关系，包括：类之间的依赖和方法间的依赖。在实际开发中：我们应该做到：编译期不依赖，运行时才依赖。

***程序讲究的是低耦合，高内聚。就是同一个模块内的各个元素之间要高度紧密，但是各个模块之间的相互依存度却要不那么紧密。

解耦的方法

为什么要解耦？就是为了提高我们程序的灵活性和可扩展性。

解耦的思路：

1. 使用反射来创建对象，而避免使用new关键字。

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

工厂模式结合配置文件解耦

在实际开发中我们可以把三层的对象都使用配置文件配置起来，当启动服务器应用加载的时候，让一个类中的方法通过读取配置文件，把这些对象创建出来并存起来。在接下来的使用的时候，直接拿过来用就好了。那么，这个读取配置文件，创建和获取三层对象的类就是工厂。

Spring三大经典思想

1. IOC

概念：Inversion Of Control 翻译成 “控制反转”

本质：对象交给Spring来管，而不是自己new

作用：削减计算机程序的耦合(解除代码中的依赖关系)

原理：工厂模式+反射+xml配置文件

2. DI

概念：Dependency Injection。翻译成 “依赖注入”，它是 spring 框架核心 IOC 的具体实现
本质：给某个对象设置值

作用：对应之间有依赖关系，再也不需要我们手动去设置值了，Spring 框架会帮我们解决

原理：反射设置值

3. AOP

概念：全称是 Aspect Oriented Programming 即：面向切面编程

就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强

作用：在程序运行期间，不修改源码对已有方法进行增强

优势：减少重复代码; 提高开发效率; 维护方便

实现方式：使用动态代理技术，在 Spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式

-------AOP核心概念-------

目标类(target): 要被增强的类

代理类(proxy): 使用动态代理产生目标类的代理

切入点(pointcut): 目标类中需要增强的方法，这些方法都称为切入点

通知(advice): 增强类中定义的方法，这些方法用于增强目标方法

切面(aspect): 切入点+通知

连接点(joinpoint): 目标类中的所有方法连接点包含切入点

织入(weaving): 将通知方法加到目标方法中的过程 spring aop 整个过程就是织入

引入(introduction): 在目标类引入新的属性或者新的方法

依赖注入

依赖注入：Dependency Injection。它是 spring 框架核心 ioc 的具体实现。本质，就是设置值.
我们的程序在编写时，通过控制反转，把对象的创建交给了 spring，但是代码中不可能出现没有依赖的情况。
ioc 解耦只是降低他们的依赖关系，但不会消除。例如：我们的业务层仍会调用持久层的方法。
那这种业务层和持久层的依赖关系，在使用 spring 之后，就让 spring 来维护了。
简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。

BeanFactory 和 ApplicationContext 的区别

在 BeanFactory 这棵继承树上的都叫 Bean 工厂，也叫 Spring 容器。

BeanFactory 才是 Spring 容器中的顶层接口。ApplicationContext 是它的子接口。
区别：
创建对象的时间点不一样。
ApplicationContext：推荐使用，只要一读取配置文件，默认情况下就会创建对象。

它在构建核心容器时，创建对象采取的策略是采用立即加载的方式。也就是说，只要一读取完配置文件马上就创建配置文件中配置的对象。
BeanFactory：什么时候使用什么时候创建对象。
它在构建核心容器时，创建对象采取的策略是采用延迟加载的方式。也就是说，什么时候根据id获取对象了，什么时候才真正的创建对象。

bean 的作用范围和生命周期

单例对象： scope="singleton" Spring 默认为单例
一个应用只有一个对象的实例。它的作用范围就是整个引用。
生命周期：
对象出生：当应用加载，创建容器时，对象就被创建了。
对象活着：只要容器在，对象一直活着。
对象死亡：当应用卸载，销毁容器时，对象就被销毁了。
多例对象： scope="prototype"
每次访问对象时，都会重新创建对象实例。
生命周期：
对象出生：当使用对象时，创建新的对象实例。
对象活着：只要对象在使用中，就一直活着。
对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。

实例化 Bean 的三种方式

1. 使用默认无参构造函数

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

2. Spring 管理静态工厂- 使用静态工厂的方法创建对象

public class StaticFactory {
         public static IAccountService createAccountService(){
                  return new AccountServiceImpl();
         }
}

<bean id="accountService" class="com.cast.factory.StaticFactory" factory-method="createAccountService"></bean>

3. spring 管理实例工厂- 使用实例工厂的方法创建对象

public class InstanceFactory {
         public IAccountService createAccountService(){
                  return new AccountServiceImpl();
         }
}

<bean id="instancFactory" class="com.cast.factory.InstanceFactory"></bean>
<bean id="accountService" factory-bean="instancFactory" factory-method="createAccountService"></bean>

通知

前置通知 before 目标方法被调用之前，就执行该前置通知方法

后置通知 after-returning 目标方法 return 返回之后，就执行该返回通知方法

最终通知 after 目标方法被调用完之后，不关心返回结果，就执行该最终通知方法

环绕通知 around 包裹了目标方法，在目标方法之前和在目标方法之后整个过程，经常使用ProceedJoinPoint.proceed()来执行

异常通知 after-throwing 当目标方法在执行异常的时候，就会执行该异常通知方法

事务

Automicity 原子性: 即事务要么被全部执行，要么被全部不执行。如果事务下的子事务全部提交成功，则所有数据库操作被提交，否则，应进行事务回滚。

Consistency 一致性: 即状态转换必须是由一种正确的状态转换到另外一种正确的状态。

Isolation 隔离性: 即相互间必须不能被影响。

Durabillity 持久性: 即事务提交后将被永久保存，即便出现其他故障，事务处理结果也应得到保存。

事务的隔离级别

Read uncommitted: 读未提交，就是一个事务可以读取另一个未提交事务的数据。 --- 脏读

Read committed: 读已提交，顾名思义，就是一个事务要等另一个事务提交后才能读取数据。 --- 不可重复读

Repeatable read: 重复读，就是在开始读取数据（事务开启）时，不再允许修改操作。 --- 幻读

Serializable: 最高的事务隔离级别，在该级别下，事务串行化顺序执行，可以避免脏读、不可重复读与幻读。但是这种事务隔离级别效率低下，比较耗数据库性能，一般不使用。

事务的传播行为

REQUIRED: 如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。一般的选择（默认值）增删改
SUPPORTS: 支持当前事务，如果当前没有事务，就以非事务方式执行（没有事务）查找
MANDATORY: 使用当前的事务，如果当前没有事务，就抛出异常
REQUERS_NEW: 新建事务，如果当前在事务中，把当前事务挂起。
NOT_SUPPORTED: 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
NEVER: 以非事务方式运行，如果当前存在事务，抛出异常
NESTED: 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行 REQUIRED 类似的操作。

传播行为：业务层的方法处理事务的问题