Spring框架学习

Spring的优点

Spring是一个开源免费的框架
Spring是一个轻量级，非入侵式的框架
控制反转（IOC），面向切面编程（AOP）
支持事务处理，对框架整合支持

Spring就是一个轻量级的控制反转（IOC），面向切面编程（AOP）的框架

IOC本质

控制反转IOC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IOC的一种方法，也有人认为DI只是IOC的另一种说法。没有IOC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是︰获得依赖对象的方式反转了。
采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是loC容器，其实现方法是依赖注入(Dependency Injection,Dl)。

依赖注入

构造其注入

set注入

bean的自动装配

ByName

ByType

使用注解

代理模式

AOP

AOP是什么

AOP（Aspect Orient Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程(OOP)的一种补充和完善。它以通过预编译方式和运行期动态代理方式，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。

AOP应用场景

AOP就是要基于OCP(开闭原则)，在不改变原有系统核心业务代码的基础上动态添加一些扩展功能并可以"控制"对象的执行。例如AOP应用于项目中的日志处理，事务处理，权限处理，缓存处理等等。

AOP相关术语

切面(aspect): 横切面对象,一般为一个具体类对象(可以借助@Aspect声明)。
通知(Advice):在切面的某个特定连接点上执行的动作(扩展功能)，例如around,before,after等。
连接点(joinpoint):程序执行过程中某个特定的点，一般指被拦截到的的方法。
切入点(pointcut):对多个连接点(Joinpoint)一种定义,一般可以理解为多个连接点的集合。

AOP入门实践

基于项目中的核心业务，添加简单的日志操作，借助SLF4J日志API输出目标方法的执行时长。
添加依赖：

<dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

创建日志切面对象：
将此日志切面类作为核心业务增强（一个横切面对象）类，用于输出业务执行时长，其关键代码如下：

@Aspect
@Slf4j
@Component
public class SysLogAspect {
         @Pointcut("bean(sysUserServiceImpl)")
         public void logPointCut() {}

         @Around("logPointCut()")
         public Object around(ProceedingJoinPoint jp)
         throws Throwable{
                 try {
                   log.info("start:{}"+System.currentTimeMillis());
                   Object result=jp.proceed();//最终会调用目标方法
                   log.info("after:{}"+System.currentTimeMillis());
                   return result;
                 }catch(Throwable e) {
                   log.error("after:{}",e.getMessage());
                   throw e;
                 }
         }
}

说明：

@Aspect 注解用于标识或者描述AOP中的切面类型，基于切面类型构建的对象用于为目标对象进行功能扩展或控制目标对象的执行。
@Pointcut注解用于描述切面中的方法，并定义切面中的切入点（基于特定表达式的方式进行描述），在本案例中切入点表达式用的是bean表达式，这个表达式以bean开头，bean括号中的内容为一个spring管理的某个bean对象的名字。
@Around注解用于描述切面中方法，这样的方法会被认为是一个环绕通知（核心业务方法执行之前和之后要执行的一个动作），@Aournd注解内部value属性的值为一个切入点表达式或者是切入点表达式的一个引用(这个引用为一个@PointCut注解描述的方法的方法名)。
ProceedingJoinPoint类为一个连接点类型，此类型的对象用于封装要执行的目标方法相关的一些信息。只能用于@Around注解描述的方法参数

测试：

@SpringBootTest
public class AopTests {
         @Autowired
         private SysUserService userService;
         @Test
         public void testSysUserService() {
                 PageObject<SysUserDeptVo> po=
                 userService.findPageObjects("admin",1);
                 System.out.println("rowCount:"+po.getRowCount());
         }
}

AOP原理分析

基于JDK代理方式实现：

假如目标对象有实现接口,则可以基于JDK为目标对象创建代理对象,然后为目标对象进行功能扩展,如图：

基于CGLIb代理方式实现：

假如目标对象没有实现接口(当然实现了接口也是可以的)，可以基于CGLIB代理方式为目标对象织入功能扩展，如图：

AOP编程进阶

通知类型

@Before
@AfterReturning
@AfterThrowing
@After
@Around 重点掌握（优先级最高）

说明：在切面类中使用什么通知，由业务决定，并不是说，在切面中要把所有通知都写上。

通知的执行顺序

假如这些通知全部写到一个切面对象中，其执行顺序及过程，如图：

说明：对于@AfterThrowing通知只有在出现异常时才会执行，所以当做一些异常监控时可在此方法中进行代码实现。实际项目中可能不会在切面中定义所有的通知，具体定义哪些通知要结合业务进行实现。

切入点表达式

Spring中通过切入点表达式定义具体切入点，其常用AOP切入点表达式定义及说明：

指示符	作用
bean	用于匹配指定bean对象的所有方法
within	用于匹配指定包下所有类内的所有方法
execution	用于按指定语法规则匹配到具体方法
@Annotation	用于匹配指定注解修饰的方法

bean表达式一般应用于类级别，实现粗粒度的切入点定义

   bean("userServiceImpl")指定一个userServiceImpl类中所有方法。
   bBean("*ServiceImpl")指定所有后缀为ServiceImpl的类中所有方法。

说明:bean表达式内部的对象是由spring容器管理的一个bean对象,表达式内部的名字应该是spring容器中某个bean的name。

@Annotaion表达式应用于方法级别，实现细粒度的切入点表达式定义

@annotation(com.cy.pj.common.annotation.RequiredLog) 匹配有此注解描述的方法。
@annotation(com.cy.pj.common.annotation.RequiredCache) 匹配有此注解描述的方法。

其中:RequiredLog为我们自己定义的注解,当我们使用@RequiredLog注解修饰业务层方法时,系统底层会在执行此方法时进行日扩展操作。

within表达式（了解）

within表达式应用于类级别，实现粗粒度的切入点表达式定义，案例分析：

within("aop.service.UserServiceImpl")指定当前包中这个类内部的所有方法。
within("aop.service.*") 指定当前目录下的所有类的所有方法。
within("aop.service..*") 指定当前目录以及子目录中类的所有方法。

within表达式应用场景分析：
1)对所有业务bean都要进行功能增强，但是bean名字又没有规则。
2)按业务模块(不同包下的业务)对bean对象进行业务功能增强。

execution表达式（了解）

execution表达式应用于方法级别，实现细粒度的切入点表达式定义，案例分析：
语法：execution(返回值类型包名.类名.方法名(参数列表))。

execution(void aop.service.UserServiceImpl.addUser())匹配addUser方法。
execution(void aop.service.PersonServiceImpl.addUser(String)) 方法参数必须为String的addUser方法。
execution( aop.service...*(..)) 万能配置。

切面优先级设置

切面的优先级需要借助@Order注解进行描述，数字越小优先级越高，默认优先级比较低。

说明：当多个切面作用于同一个目标对象方法时，这些切面会构建成一个切面链，类似过滤器链、拦截器链，其执行分析如图：

声明式事务

事务：事务(Transaction)是一个业务,是一个不可分割的逻辑工作单元，基于事务可以更好的保证业务的正确性。

要么都成功，要么都失败
确保完整性和一致性
事务在项目开发中十分重要，涉及数据的一致性

事务ACID原则

原子性（Atomicity）：一个事务中的多个操作要么都成功要么都失败。
一致性（Consistency): 例如存钱操作,存之前和存之后的总钱数应该是一致的。
隔离性（Isolation）：事务与事务应该是相互隔离的。
持久性（Durability）：事务一旦提交,数据要持久保存。

@Transactional注解配置事务

启用声明式事务管理，在项目启动类上添加@EnableTransactionManagement，新版本中也可不添加（例如新版Spring Boot项目）。
将@Transactional注解添加到合适的业务类或方法上，并设置合适的属性信息。

 @Transactional(timeout = 30,
               readOnly = false,
               isolation = Isolation.READ_COMMITTED,
               rollbackFor = Throwable.class,
               propagation = Propagation.REQUIRED)
  @Service
  public class implements SysUserService {
        @Transactional(readOnly = true)
        @Override
        public PageObject<SysUserDeptVo> findPageObjects(
                        String username, Integer pageCurrent) {
      …
       }
}

当@Transactional注解应用在类上时表示类中所有方法启动事务管理，并且一般用于事务共性的定义。
当@Transactional描述方法时表示此方法要进行事务管理，假如类和方法上都有@Transactional注解，则方法上的事务特性优先级比较高。

@Transactional 常用属性应用说明：

timeout：事务的超时时间，默认值为-1,表示没有超时显示。如果配置了具体时间,则超过该时间限制但事务还没有完成，则自动回滚事务。这个时间的记录方式是在事务开启以后到sql语句执行之前。
read-only：指定事务是否为只读事务，默认值为 false；为了忽略那些不需要事务的方法，比如读取数据，可以设置read-only为true。对添加，修改，删除业务read-only的值应该为false。
rollback-for：用于指定能够触发事务回滚的异常类型，如果有多个异常类型需要指定，各类型之间可以通过逗号分隔。
no-rollback- for: 抛出no-rollback-for 指定的异常类型，不回滚事务。
isolation事务的隔离级别，默认值采用 DEFAULT。当多个事务并发执行时，可能会出现脏读，不可重复读，幻读等现象时，但假如不希望出现这些现象可考虑修改事务的隔离级别(但隔离级别越高并发就会越小，性能就会越差)

XML配置事务

<! --配置声明式事务-->
<property name="dataSource" ref="dataSource"/>
/bean>
<! --结合AOP实现事务的织入-->
<! --配置再务通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<!--给哪那些方法配置事务-->
<!--配置事务的传播特性: propagation= -->
<tx:attributes>
<tx:method name="add" propagation="REQUIRED"/>
<tx:method name="delete" propagation="REQUIRED"/>
<tx:method name="update" propagation="REQUIRED"/>
<tx:method name="query" read-only="true"/>
<tx:method name="*"propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>

<!--配置事务切入-->
<!--  com.cy.mapper.*.*(..) 表示mapper包下所有类里的所有方法-->
<aop:config>
<aop:pointcut id="txPointCut" expression="execution(* com.cy.mapper.*.*(..))">
<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
</aop:config>

Spring 中事务控制过程分析,如图：

Spring事务管理是基于接口代理（JDK）或动态字节码（CGLIB）技术，然后通过AOP实施事务增强的。当我们执行添加了事务特性的目标方式时，系统会通过目标对象的代理对象调用DataSourceTransactionManager对象，在事务开始的时，执行doBegin方法，事务结束时执行doCommit或doRollback方法。

Spring 中事务传播特性

事务传播(Propagation)特性指"不同业务(service)对象"中的事务方法之间相互调用时,事务的传播方式,如图：

@Transactional(propagation=Propagation.REQUIRED) 。

如果没有事务创建新事务, 如果当前有事务参与当前事务, Spring 默认的事务传播行为是PROPAGATION_REQUIRED，它适合于绝大多数的情况。假设 ServiveX#methodX() 都工作在事务环境下（即都被 Spring 事务增强了），假设程序中存在如下的调用链：
Service1#method1()->Service2#method2()->Service3#method3()，那么这 3 个服务类的 3 个方法通过 Spring 的事务传播机制都工作在同一个事务中。如图：

代码示例如下：

@Transactional(propagation = Propagation.REQUIRED)
        @Override
        public List<Node> findZtreeMenuNodes() {
                return sysMenuDao.findZtreeMenuNodes();
        }

说明：当有一个业务对象调用如上方法时，此方法始终工作在一个已经存在的事务方法，或者是由调用者创建的一个事务方法中。

@Transactional(propagation=Propagation.REQUIRES_NEW)。

必须是新事务, 如果有当前事务, 挂起当前事务并且开启新事务，如图：

代码示例如下：

        @Transactional(propagation = Propagation.REQUIRES_NEW)
        @Override
        public void saveObject(SysLog entity) {
          sysLogDao.insertObject(entity);
        }

说明：当有一个业务对象调用如上业务方法时，此方法会始终运行在一个新的事务中。

Spring 中事务管理小结

Spring 声明式事务是 Spring 最核心，最常用的功能。由于 Spring 通过 IOC 和 AOP的功能非常透明地实现了声明式事务的功能，对于一般的开发者基本上无须了解 Spring声明式事务的内部细节，仅需要懂得如何配置就可以了。但对于中高端开发者还需要了解其内部机制。

Spring AOP 异步操作实现

在开发系统的过程中，通常会考虑到系统的性能问题，提升系统性能的一个重要思想就是“串行”改“并行”。说起“并行”自然离不开“异步”，今天我们就来聊聊如何使用Spring的@Async的异步注解。

Spring 业务的异步实现

启动异步配置

在基于注解方式的配置中，借助@EnableAsync注解进行异步启动声明，Spring Boot版的项目中，将@EnableAsync注解应用到启动类上，代码示例如下：

   @EnableAsync //spring容器启动时会创建线程池
   @SpringBootApplication
   public class Application {
        public static void main(String[] args) {
                SpringApplication.run(Application.class, args);
        }
}

在需要异步执行的业务方法上，使用@Async方法进行异步声明

当我们需要自己对spring框架提供的连接池进行一些简易配置，可以参考如下代码：

spring:
  task:
    execution:
      pool:
        queue-capacity: 128#阻塞队列容量
        core-size: 5#核心线程数量
        max-size: 128#最大线程数
        keep-alive: 60000#线程空闲时间
      thread-name-prefix: db-service-task-