Spring

1,Spring

Spring的核心是控制反转(IoC)和面向切面(AOP)。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式)轻量级开源框架。
为什么说Spring是一个一站式的轻量级开源框架呢？EE开发可分成三层架构，针对JavaEE的三层结构，每一层Spring都提供了不同的解决技术。
• WEB层：SpringMVC
• 业务层：Spring的IoC
• 持久层：Spring的JDBCTemplate(Spring的JDBC模板，ORM模板用于整合其他的持久层框架)

Spring的核心有两部分：

IoC：控制反转。

举例来说，在之前的操作中，比方说有一个类，我们想要调用类里面的方法(不是静态方法)，就要创建类的对象，使用对象调用方法实现。对于Spring来说，Spring创建对象的过程，不是在代码里面实现的，而是交给Spring来进行配置实现的。

AOP：面向切面编程。Aspect Oriented Programming

2，AOP   对代码进行复用

利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

AOP不是一种技术，实际上是编程思想。凡是符合AOP思想的技术，都可以看成是AOP的实现

假设把应用程序想成一个立体结构的话，OOP的利刃是纵向切入系统，把系统划分为很多个模块（如：用户模块，文章模块等等），而AOP的利刃是横向切入系统，提取各个模块可能都要重复操作的部分（如：权限检查，日志记录等等）。由此可见，AOP是OOP的一个有效补充。

AOP有以下重要部分组成：

1，关注点    （每个方法调用的日志纪录...）也就是通知里面打印的内容

关注点,重复代码就叫做关注点；

2，切面    AspLog 类

关注点形成的类，就叫切面(类)！

面向切面编程，就是指 对很多功能都有的重复的代码抽取，再在运行的时候网业务方法上动态植入“切面类代码”。

3，切入点   addUser()

执行目标对象方法，动态植入切面代码。

可以通过切入点表达式，指定拦截哪些类的哪些方法； 给指定的类在运行的时候植入切面类代码

主要的功能是：日志记录，性能统计，安全控制，事务处理，异常处理等等。

例如：在已经开发好的项目中，给每个方法添加日志，我们的实现方式，肯定不可能是在每个方法调用的时候添加日志，因为方法很多，且都是重复代码，我们的实现实现方式是利用AOP 方式

           同理，事务的处理也是，在方法前开始事务，方法后提交事务

3,Spring 事务

事务基本特性
⑴ 原子性（Atomicity）
　　原子性是指事务包含的所有操作要么全部成功，要么全部失败回滚，因此事务的操作如果成功就必须要完全应用到数据库，如果操作失败则不能对数据库有任何影响。
⑵ 一致性（Consistency）
　一致性是指事务必须使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事务执行之前和执行之后都必须处于一致性状态。
　　拿转账来说，假设用户A和用户B两者的钱加起来一共是5000，那么不管A和B之间如何转账，转几次账，事务结束后两个用户的钱相加起来应该还得是5000，这就是事务的一致性。

⑶ 隔离性（Isolation）
　　隔离性是当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务，不能被其他事务的操作所干扰，多个并发事务之间要相互隔离。
　　即要达到这么一种效果：对于任意两个并发的事务T1和T2，在事务T1看来，T2要么在T1开始之前就已经结束，要么在T1结束之后才开始，这样每个事务都感觉不到有其他事务在并发地执行。
　　关于事务的隔离性数据库提供了多种隔离级别，稍后会介绍到。
⑷ 持久性（Durability）
持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。
例如我们在使用JDBC操作数据库时，在提交事务方法后，提示用户事务操作完成，当我们程序执行完成直到看到提示后，就可以认定事务以及正确提交，即使这时候数据库出现了问题，也必须要将我们的事务完全执行完成，否则就会造成我们看到提示事务处理完毕，但是数据库因为故障而没有执行事务的重大错误。

4，事务控制分类

编程式事务控制
自己手动控制事务，就叫做编程式事务控制。
Jdbc代码：
Conn.setAutoCommite(false); // 设置手动控制事务
Hibernate代码：
Session.beginTransaction(); // 开启一个事务
【细粒度的事务控制： 可以对指定的方法、指定的方法的某几行添加事务控制】
(比较灵活，但开发起来比较繁琐： 每次都要开启、提交、回滚.)

声明式事务控制
Spring提供了对事务的管理, 这个就叫声明式事务管理。
Spring提供了对事务控制的实现。用户如果想用Spring的声明式事务管理，只需要在配置文件中配置即可； 不想使用时直接移除配置。这个实现了对事务控制的最大程度的解耦。
Spring声明式事务管理，核心实现就是基于Aop。

Aop 日志例子：基于注解版本

定义一个接口和实现类

public interface UserService {
    
    public void addUser();

}

import org.springframework.stereotype.Service;

import com.hella.thread.spring.aop.service.UserService;

@Service
public class UserServiceImpl implements UserService {

    public void addUser() {
        System.out.println("add.......");

    }

}

在调用这个方法往数据库里面添加日志的时候需要添加log

切面类：

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Component // 放入到Spring容器中
@Aspect // 定义切面类 公共的log部分
public class AspLog {

    // aop 编程的通知 前置通知 后置通知 环绕通知 异常通知 运行通知

    @Before("execution (* com.hella.thread.spring.aop.service.UserService.addUser(..) )")
    public void before() {
        System.out.println("前置通知。。。。");

    }

    @After("execution (* com.hella.thread.spring.aop.service.UserService.addUser(..) )")
    public void after() {
        System.out.println("后置通知。。。");
    }

    @Around("execution (* com.hella.thread.spring.aop.service.UserService.addUser(..) )")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕通知  proceed前 。。。");
        proceedingJoinPoint.proceed();
        System.out.println("环绕通知 proceed后。。。"); // 异常则proceed后就不会执行
    }

    @AfterReturning("execution (* com.hella.thread.spring.aop.service.UserService.addUser(..) )")
    public void returning() {
        System.out.println("运行通知 。。。");

    }

    @AfterThrowing("execution (* com.hella.thread.spring.aop.service.UserService.addUser(..) )")
    public void afterThrowing() {
        System.out.println("异常通知");
    }

}

xml 文件，扫包

spring.xml

<?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"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <context:component-scan base-package="com.hella.thread.spring.aop"></context:component-scan>
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy> <!-- 开启事物注解 -->

</beans>

测试：

public class App {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext(
                "spring.xml");
        UserService userService = (UserService) classPathXmlApplicationContext.getBean("userServiceImpl");
        userService.addUser();
    }

}

打印：

前置通知。。。。
环绕通知 proceed前 。。。
add.......
后置通知。。。
环绕通知 proceed后。。。
运行通知 。。