Spring

Spring

Spring 是什么?

Spring 是于 2003 年兴起的一个轻量级的,IOC 和 AOP 的 Java 开发框架，它 是为了简化企业级应用开发而生的。

Spring有几大特点如下

轻量级的

Spring 框架使用的 jar 都比较小，一般在 1M 以下或者几百 kb。Spring 核 心功能的所需的 jar 总共在 3M 左右。 Spring 框架运行占用的资源少，运行 效率高。

IOC

控制反转，即 Inversion of Control，缩写为 IOC，就是由 Spring IoC 容器管理对象，而 非传统实现中由程序代码直接操控.

AOP

直译过来就是 面向切面编程。AOP 是一种编程思想，是面向对象编程（OOP） 的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将 程序抽象成各个切面.

一站式框架

Spring 本身也提供了数据访问功能和 web 功能,以及可以很好的管理其他框架.

提供核心功能,主要是IOC,创建管理对象.
      提供面向切面编程,增强程序扩展
      对数据访问层进行了封装(重点在于事务管理)
      对web层进行封装,使得请求更加便捷

Spring 体系结构

Core Container(核心容器):

        Beans: 管理 Beans

        Core: Spring 核心

        Context: 配置文件

        ExpressionLanguage: SpEL 表达式 

AOP(切面编程)

AOP 框架: Aspects

Data Access(数据库整合):   JDBC, ORM, OXM, JMS, Transaction

Web(MVC Web 开发):    Web, Servlet, Portlet, Struts

Test(Junit 整合)

官网地址: https://spring.io/

Spring  搭建

Maven 导入 spring 核心基础 jar

<!-- spring-context -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.2.RELEASE</version>
</dependency>

编写 spring 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="user" class="com.ff.spring.bean.User"> </bean>
</beans>

编写一个 User 实体类

测试 spring

IOC(控制反转)

读作“反转控制”(Inverse of Control)更好理解，不是什么技术，而是一种 设计思想，就是将原本在程序中手动创建对象的控制权，交由 Spring 框架来 管理。

IOC 容器是具有依赖注入功能的容器，负责对象的实例化、对象的初始化，对 象和对象之间依赖关系配置、对象的销毁、对外提供对象的查找等操作，对象 的整个生命周期都是由容器来控制。我们需要使用的对象都由 ioc 容器进行管 理，不需要我们再去手动通过 new 的方式去创建对象，由 ioc 容器直接帮我 们组装好，当我们需要使用的时候直接从 ioc 容器中直接获取就可以了。

正控：若要使用某个对象，需要自己去负责对象的创建。

反控：若要使用某个对象，只需要从 Spring 容器中获取需要使用的对象， 不关心对象的创建过程，也就是把创建对象的控制权反转给了 Spring 框架。

底层实现方式: 解析 xml/扫描注解标签 + 工厂模式 + 反射机制

Spring Bean 管理

基于 xml 配置方式

bean 配置需要 spring 管理的类

id 生成的对象名

class 全类名

name 对象别名,可以为多个

scope:

      singleton(默认值):在 Spring 中只存在一个 bean 实例, 单例模式.

      prototype:原型 getBean()的时候都会 new Bean()

      request:每次 http 请求都会创建一个 bean, 仅用于 WebApplicationContext 环境

session:同一个 http session 共享一个 Bean, 不同 Session 使用不同的 Bean, 使用环境同上

Xml 配置方式依赖注入 

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

实现 IOC 需要 DI 做支持

注入的方式：

       set 方法注入

       构造方法注入

注解方式实现

注解开发准备工作

注解需要的 jar 包

注解功能封装在 AOP 包中，导入 Spring aop jar 包即可

开启注解扫描

<context:component-scan base-package="包名"> </context:component-scan>

注解创建对象

@Component(value=“user”)等于

<bean id=“user” class=“”></bean>

@Service

@Repository

以上注解都可以实现创建对象功能，只是为了后续扩展功能，在不同的层 使用不同的注解标记

@Scope(value=“prototype”) 原型

@Scope(value=“ singleton ”) 单例

注解方式注入属性

@Autowired

@Autowired 是 Spring 提供的注解,可以写在字段和 setter 方法上。如果写在 字段上，那么就不需要再写 setter 方法。默认情况下它要求依赖对象必须存在， 如果允许 null 值，可以设置它的 required 属性为 false。

byType 自动注入

该注解默认使用按类型自动装配 Bean 的方式。

byName 自动注入

如果我们想使用按照名称（byName）来装配，可以结合@Qualifier 注解一起 使用

需要在引用属性上联合使用注解@Autowired 与@Qualifier。@Qualifier 的 value 属性用于指定要匹配的 Bean 的 id 值。

JDK 注解@Resource 自动注入

Spring 提供了对 jdk 中@Resource 注解的支持。@Resource 注解既可以按名 称匹配 Bean，也可以按类型匹配 Bean。默认按照 ByName 自动注入

byName 注入引用类型属性

@Resource 注解指定其 name 属性，则 name 的值即为按照名称进行匹配 的 Bean 的 id。

注解与 XML 的对比

注解优点： 方便,直观,高效（代码少，没有配置文件的书写那么复杂）。

注解缺点：以硬编码的方式写入到 Java 代码中，修改是需要重新编译代码的。

xml 优点是： 配置和代码是分离的,在 xml 中做修改，无需编译代码，只需重 启服务器即可将新的配置加载。

xml 的缺点是：编写麻烦，效率低，大型项目过于复杂。

Spring JDBC

Spring 是个一站式框架：Spring 自身也提供了控制层的 SpringMVC 和 持久 层的 Spring JdbcTemplate。

开发步骤

下载 Spring JdbcTemplate 的 jar 包

<!-- spring-jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.2.RELEASE</version>
</dependency>
<!-- 阿里数据源 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.10</version>
</dependency>

导入属性文件

<context:property-placeholder location="config.properties"/>

管理数据源对象

spring 管理与数据库链接 (数据源)

<bean id="dataSource"class="com.alibaba.druid.pool.DruidDataSource">
<propertyname="driverClassName" value="${driverClassName}"></property>
<property name="url" value="${url}"></property>
<property name="username" value="${uname}"></property>
<property name="password" value="${pwd}"></property>
<property name="initialSize" value="10"></property>
<property name="minIdle" value="5"></property>
<property name="maxActive" value="20"></property>
</bean>

在配置文件中创建 JdbcTemplate

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>

在类中获得 JdbcTemplate 对象，就可以直接使用。

JdbcTemplate 中常用的方法 

execute：无返回值，可执行 ddl，增删改语句

update：执行新增、修改、删除语句；

queryForXXX：执行查询相关语句；

不使用 AOP 的开发方式

先定义好接口与一个实现类，该实现类中除了要实现接口中的方法外，还要 再写两个非业务方法。非业务方法也称为交叉业务逻辑：

➢ doTransaction()：用于事务处理

➢ doLog()：用于日志处理

然后，再使接口方法调用它们。接口方法也称为主业务逻辑.

AOP 概述

AOP 为 Aspect Oriented Programming 的缩写，意为：面向切面编程，通过 预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。

AOP 是 OOP 的延续，是软件开发中的一个热点，是 java 开发中的一个重要内 容。利用 AOP 可以对业务逻辑和非业务逻辑进行隔离，从而使得各部分之间的 耦合度降低，提高程序的可重用性，同时提高了开发的效率。

AOP、OOP 在字面上虽然非常类似，但却是面向不同领域的两种设计思想。OOP （面向对象编程）针对业务处理过程的实体及其属性和行为进行抽象封装，以获 得更加清晰高效的逻辑单元划分。

而 AOP 则是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的 某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。这两种设 计思想在目标上有着本质的差异。

面向切面编程的好处就是: 减少重复,专注业务；

注意：面向切面编程只是面向对象编程的一种补充。

核心原理：

使用动态代理的方式在执行方法前后或者出现异常的时候做加入相关的逻辑

使用案例:

事务处理：开启事务，关闭事务，出现异常后回滚事务

权限判断：在执行方法前，判断是否具有权限

日志：在执行前进行日志处理

AOP 的基本概念

连接点（Joinpoint）：类中可以被增强的方法，这个方法就被称为连接点

切入点（pointcut）：类中有很多方法可以被增强，但实际中只有 add 和 update 被增了，那么 add 和 update 方法就被称为切入点（实际实现的连接点）

通知(Advice): 通知是指一个切面在特定的连接点要做的事情(增强的功能)。通 知分为方法执行前通知，方法执行后通知，环绕通知等.

切面(Aspect):把通知添加到切入点的整个过程称为切面.

目标(Target): 代理的目标对象(连接点,切入点所在类)

代理(Proxy): 向目标对象应用通知时创建的代理对象

springAOP 实现

对于 AOP 这种编程思想，很多框架都进行了实现。Spring 就是其中之一，可 以完成面向切面编程。

AspectJ 是一个基于 Java 语言的 AOP 框架，它提供了强大的 AOP 功能,且其实 现方式更为简捷，使用更为方便， 而且还支持注解式开发。所以，Spring 又 将 AspectJ 的对于 AOP 的实现也引入到了自己的框架中。

下载 AOP 相关 jar

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.2.2.RELEASE</version>
</dependency>

基于 aspectj 的 xml 配置方式实现

<bean id="aopdemo" class="com.ff.spring.aop.AopDemo"></bean>
<aop:config>
<!-- 配置切入点 -->
<aop:pointcut expression="execution(*
com.ff.spring.service.UserService.adduser(..))" id="adduser"/>
<aop:pointcut expression="execution(*
com.ff.spring.service.UserService.*(..))" id="allmethod"/>
<!-- 配置通知和切入点 -->
<aop:aspect ref="aopdemo">
<aop:before method="savelog" pointcut-ref="adduser"/>
<aop:after method="savelog" pointcut-ref="adduser"/>
<aop:around method="aroundAdvice" pointcut-ref="adduser"/>
<aop:after-throwing method="exceptionAdvice" pointcut-ref="allmethod"
throwing="e" />
</aop:aspect>
</aop:config>

AspectJ 中常用的通知有五种类型：

前置通知 before   业务方法执行前调用
后置通知 after-returning   业务方法执行后执行，当方法出现异常不执行
异常通知 after-throwing    业务方法出现异常时调用
最终通知 after    业务方法执行后调用 当方法出现异常也会执行
环绕通知 around

 

基于注解方式的实现

启动 AspectJ 支持:

<aop:aspectj-autoproxy />

@Component
@Aspect
public class AOPDemo {
@Before("execution(* com.ff.spring.demo1.dao.UserDao.*(..))")
public void before(){
System.out.println("before");
}
@After("execution(* com.ff.spring.demo1.dao.UserDao.*(..))")
public void after(){
System.out.println("after");
}
@Around("execution(* com.ff.spring.demo1.dao.UserDao.*(..))")
public void around(ProceedingJoinPoint point) throws Throwable {
System.out.println("start");
point.proceed();
System.out.println("end");
}
@AfterThrowing(value = "execution(* com.ff.spring.demo1.dao.UserDao.*(..))",throwing = "e")
public void afterthrow(Throwable){
System.out.println("afterthrow");
}
@AfterReturning("execution(* com.ff.spring.demo1.dao.UserDao.*(..))")
public void afterreturn(){
System.out.println("afterreturn");
}
}

Spring 事物管理

事物可以看做是由对数据库若干操作组成的一个单元。

我们在开发企业应用时，对于业务人员的一个操作实际是对数据读写的多步操作 的结合。由于数据操作在顺序执行的过程中，任何一步操作都有可能发生异常， 异常会导致后续操作无法完成，此时由于业务逻辑并未正确的完成，之前成功操 作数据的并不可靠，需要在这种情况下进行回退。

事务的作用就是为了保证用户的每一个操作都是可靠的，事务中的每一步操作都 必须成功执行，只要有发生异常就回退到事务开始未进行操作的状态,这些操作 要么都完成，要么都取消，从而保证数据满足一致性的要求

Spring 中的事务管理分为两种形式,一种是编程式事务,一种是声明式事务。

编 程 式 事 务 在 项 目 中 很 少 使 用 , 这 种 方 式 需 要 注 入 一 个 事 务 管 理 对 象 TransactionTemplate ,然后在我们代码中需要提交事务或回滚事务时自己写代 码实现。

声 明 式 事 务管理建立在 AOP 基础上，本质是对方法前后进行拦截，所以声明式 事务是方法级别的。

Spring 声明式事物管理方式有两种：    基于 xml 配置          基于注解实现

Spring 针对不同的 dao 框架，提供了不同的实现类,Jdbc,mybatis 事物管理实 现类是 DataSourceTransactionManager

配置事物管理器

<!-- 配置 spring 事务管理类, 并注入数据源 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>

注解方式

<!-- 开启注解事务管理 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

在 service 中控制事务     @Service(value="userservice")       @Transactiona

声明式事务不生效的场景

@Transactional 应用在非 public 修饰的方法上 异常被 catch 捕获导致失效 出现编译期异常

@Transactional 事务传播行为设置错误 数据库引擎不支持事务 同一个类中,使用非代理对象调用一个有事务的方法，导致事务错误

Spring 事务传播行为

什么叫事务传播行为？

即然是传播，那么至少有两个东西，才可以发生传播。单体不存在传播这个行为。 事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事 务方法调用时，这个事务方法应该如何进行。事务传播行为是 Spring 框架独有 的事务增强特性，他不属于的事务实际提供方数据库行为.

例如：methodA 事务方法调用 methodB 事务方法时，methodB 是继续在调 用者 methodA 的事务中运行呢，还是为自己开启一个新事务运行，这就是由 methodB 的事务传播行为决定的。

Spring 定义了七种传播行为：

 

Spring 集成 Mybatis

Spring 集成 Mybatis 其核心是将 SqlSessionFactory 交由 Spring 管理，并由 Spring 管理对 dao 接口的代理实现。

导入 mybatis jar 包

<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.1</version>
</dependency>

配置 sqlSessionFactory

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
<property name="configLocation" value="mybatis-config.xml"></property>
<property name="mapperLocations" value="com/ff/*Mapper.xml">
</property>
</bean>

指定生成接口代理

<bean id="mapperFactory" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.ff.ssm.dao"></property>
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory">
</property>
</bean>

在 service 中注入 Dao 代理接口，此接口有 Spring 代理实现