spring学习笔记

Spring的简介

• Spring：春天------>给软件行业带来了春天！
• 2002，首次推出了Spring框架的雏形：interface21框架！
• Spring框架即以interface21框架为基础，经过重新设计，并不断丰富其内涵，于2004年3月24日发布了1.0正式版。
• Rod Johnson，Spring Framework创始人，著名作者。很难想象Rod Johnson的学历，真的让好多人大吃一惊，他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。
• Spring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架！
• SSH：Struct2 + Spring + Hibernate!
• SSM：SpringMVC + Spring + Mybatis!

Spring的优点

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

IOC控制反转

控制反转IoC（Inversion of Control），是一种设计思想，DI（依赖注入）是实现IoC的一种方法，也有人认为DI只是IoC的另一种说法。没有IoC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection，DI）。

思考问题？

• Hello对象是谁创建的？
  Hello对象是由Spring创建的。
• Hello对象的属性是怎么设置的？
  Hello对象的属性是由Spring容器设置的。

这个过程就叫控制反转：

控制：谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的。

反转：程序本身不创建对象，而变成被动的接收对象。

依赖注入：就是利用set方法来进行注入的。

IOC是一种编程思想，由主动的编程变成被动的接收。

可以通过new ClassPathXmlApplicationContext去浏览一下底层源码。

OK，到了现在，我们彻底不用在程序中去改动了，要实现不同的操作，只需要在xml配置文件中进行修改，所谓的IOC，一句话搞定：对象由Spring来创建，管理，装配！

什么是Bean?

Spring Bean是被实例的，组装的及被Spring 容器管理的Java对象。

Spring 容器会自动完成@bean对象的实例化。

IOC创建对象的方式（构造器注入）

1. 无参构造，默认
2. 有参构造，通过index、type或name赋值

总结：在配置文件加载的时候，容器中管理的对象就已经初始化了！

依赖注入

1. 构造器注入（上节）
2. set注入
3. 拓展方式注入（p命名空间和c命名空间）

• set注入：
  • 依赖：bean对象的创建依赖于容器！
  • 注入：bean对象中的所有属性，由容器来注入！
• p命名空间注入：
  • 可以直接注入属性的值，p 就是property
• c命名空间注入：
  • 通过构造器注入，c 就是constructor-args

Bean的作用域

singleton	单例模式，在整个Spring IoC 容器中，使用 singleton 定义的Bean将只有一个实例
prototype	原型模式，每次通过容器的getBean 方法获取prototype定义的Bean 时,都将产生一个新的Bean实例
request	对于每次HTTP请求，使用request定义的Bean都将产生一个新的实例，每次HTTP请求都将产生不同的Bean实例，该作用域仅在给予web的Spring ApplicationContext情形下有效
session	对于每次HTTP Session ，使用session定义的Bean都将产生一个新实例，该作用域仅在给予web的Spring ApplicationContext情形下有效
global session	每个全局得HTTP Session对应一个Bean实例，该作用域仅在给予web的Spring ApplicationContext情形下有效

比较常用的是singleton 和 prototype 两种作用域。

对于singleton作用域（这是默认选项），每次请求该Bean都将获得相同的实例，Spring容器负责跟踪监视Bean实例的状态，负责维护Bean实例的生命周期行为。

如果一个Bean被设置成prototype作用域，程序每次请求该id的Bean，Spring都会创建一个新的Bean实例，然后返回给程序，在这种情况下，Spring容器仅仅使用new 关键字创建Bean实例，一旦创建成功，容器Spring不再对Bean的生命周期负责，也不会维护Bean实例的状态。

prototype作用域Bean 的创建销毁代价比较大，而singleton作用域的Bean 实例一旦创建成功，可以重复使用。因此，除非必要，否则避免将Bean作用域设置成prototype。

其余的request、session、application，这些只能在web开发中使用到（先不管）。

Bean的自动装配

• 自动装配是Spring满足bean依赖一种方式！
• Spring会在上下文中自动寻找，并自动给bean装配属性！

在Spring中有三种装配的方式：

1. 在xml中显式的配置；
2. 在java中显式配置；
3. 隐式的自动装配bean【重要】

两种显式的配置：

• ByName，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致！
• ByType，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致！

注解实现装配：

@Autowired

直接在属性上使用即可！也可以在set方法上使用！

使用Autowired我们就可以不用编写set方法了，前提是你这个自动配置的属性在IOC（Spring）容器中存在，且符合名字ByName！

小结：

@Resource和@Autowired的区别：

都是用来自动装配的，都可以放在属性字段上
@Autowired通过byType的方式实现，而且必须要求这个对象存在！【常用】
@Resource默认通过byName的方式实现，如果找不到名字，则通过byType实现！如果两个都找不到的情况下，就报错！【常用】

使用注解开发

需要先导AOP的包。

    <!--指定要扫描的包，这个包下的注解就会生效-->
    <context:component-scan base-package="com.kuang"/>
    <!--开启注解的支持    -->
    <context:annotation-config/>

@Component
public class User {

    //相当于  <property name="name" value="花仙"/>
    @Value("花仙")
    public String name;
}

@Component即声明这是一个组件类，纳入spring容器中进行管理！

以下三个的作用跟@Component是一样的，只是根据MVC三层架构分层了：

dao 【@Repository】
service 【@Service】
controller 【@Controller】

自动装配：

@Autowired、@Resource

作用域：

@scope

小结：
xml与注解：
xml更加万能，适用于任何场合！维护简单方便
注解不是自己类使用不了，维护相对复杂！
xml与注解最佳实践：
xml用来管理bean；
注解只负责完成属性的注入；
我们在使用的过程中，只需要注意一个问题：为了让注解生效，就必须开启注解的支持

代理模式

代理模式分为：

• 静态代理
• 动态代理

代理模式的角色：

角色分析：

• 抽象角色：一般会使用接口或者抽象类来解决
• 真实角色：被代理的角色
• 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
• 客户：访问代理对象的人！

代理模式的好处：

• 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
• 公共角色就交给代理角色！实现了业务的分工！
• 公共业务发生扩展的时候，方便集中管理！

缺点：

• 一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率会变低

两种代理的区别：

动态代理和静态代理角色一样
动态代理的代理类是动态生成的，不是我们直接写好的！
动态代理分为两大类：基于接口的动态代理，基于类的动态代理
基于接口 — JDK动态代理【我们在这里使用】
基于类：cglib
java字节码实现：javassist
需要了解两个类：Proxy：代理；InvocationHandler：调用处理程序。

动态代理的好处：

• 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
• 公共角色就交给代理角色！实现了业务的分工！
• 公共业务发生扩展的时候，方便集中管理！
• 一个动态代理类代理的是一个接口，一般就是对应的一类业务
• 一个动态代理类可以代理多个类，只要是实现了同一个接口即可！

AOP面向切面编程

AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

AOP在Spring中的作用

提供声明式事务；允许用户自定义切面

• 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志，安全，缓存，事务等等…
• 切面（ASPECT）：横切关注点被模块化的特殊对象。即，它是一个类。
• 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
• 目标（Target）：被通知对象。
• 代理（Proxy）：向目标对象应用通知之后创建的对象。
• 切入点（PointCut）：切面通知执行的“地点”的定义。
• 连接点（JointPoint）：与切入点匹配的执行点。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HjUplqe3-1664821081036)(C:\Users\Chan\Desktop\代码与学习\Springboot\Spring\20201120104454887.png)]

即AOP在不改变原有代码的情况下，去增加新的功能。

使用Spring实现AOP

使用AOP织入，需要导入一个依赖包！

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

方式一：使用Spring的API接口【主要是SpringAPI接口实现】

1. 在service包下，定义UserService业务接口和UserServiceImpl实现类
2. 在log包下，定义我们的增强类，一个Log前置增强和一个AfterLog后置增强类
3. 最后去spring的文件中注册 , 并实现aop切入实现 , 注意导入约束，配置applicationContext.xml文件

方式二： 自定义类来实现AOP【主要是切面定义】

1. 在diy包下定义自己的DiyPointCut切入类
2. 去spring中配置文件

方式三：使用注解实现

1. 在diy包下定义注解实现的AnnotationPointCut增强类
2. 在Spring配置文件中，注册bean，并增加支持注解的配置。

//声明式事务！
@Aspect //标注这个类是一个切面
public class AnnotationPointCut {

    @Before("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("====方法执行前====");
    }

    @After("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("====方法执行后====");
    }

    //在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点；
    @Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable{
        System.out.println("环绕前");

        Signature signature = jp.getSignature();// 获得签名
        System.out.println("signature:"+signature);

        Object proceed = jp.proceed(); //执行方法

        System.out.println("环绕后");

        System.out.println(proceed);
    }

}

事务ACID原则

• 原子性（atomicity）
  事务是原子性操作，由一系列动作组成，事务的原子性确保动作要么全部完成，要么完全不起作用。
• 一致性（consistency）
  一旦所有事务动作完成，事务就要被提交。数据和资源处于一种满足业务规则的一致性状态中。
• 隔离性（isolation）
  可能多个事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏。
• 持久性（durability）
  事务一旦完成，无论系统发生什么错误，结果都不会受到影响。通常情况下，事务的结果被写到持久化存储器中。

Spring中的事务管理

Spring在不同的事务管理API之上定义了一个抽象层，使得开发人员不必了解底层的事务管理API就可以使用Spring的事务管理机制。Spring支持编程式事务管理和声明式的事务管理。

编程式事务管理

将事务管理代码嵌到业务方法中来控制事务的提交和回滚
缺点：必须在每个事务操作业务逻辑中包含额外的事务管理代码
声明式事务管理

一般情况下比编程式事务好用。
将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。
将事务管理作为横切关注点，通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务管理。

spring事务传播特性

事务传播行为就是多个事务方法相互调用时，事务如何在这些方法间传播。spring支持7种事务传播行为：

• propagation_requierd：如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是最常见的选择。
• propagation_supports：支持当前事务，如果没有当前事务，就以非事务方法执行。
• propagation_mandatory：使用当前事务，如果没有当前事务，就抛出异常。
• propagation_required_new：新建事务，如果当前存在事务，把当前事务挂起。
• propagation_not_supported：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
• propagation_never：以非事务方式执行操作，如果当前事务存在则抛出异常。
• propagation_nested：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与
• propagation_required类似的操作。

Spring 默认的事务传播行为是 PROPAGATION_REQUIRED，它适合于绝大多数的情况。

为什么需要事务？

• 如果不配置事务，可能存在数据提交不一致的情况；
• 如果我们不在Spring中去配置声明式事务，我们就需要在代码中手动配置事务！
• 事务在项目的开发中十分重要，涉及到数据的一致性和完整性问题，不容马虎！