锐客网

  1. 首页 > 睿知 > it技术 > >

带你彻底吃透Spring

IT知识spring

业无高卑志当坚，男儿有求安得闲？这篇文章主要讲述带你彻底吃透Spring相关的知识，希望能为你提供帮助。

带你彻底吃透Spring

文章图片



  • 框架，本质上是一些实用经验集合。即是前辈们在实际开发过程中积攒下来的实战经验，累积成一套实用工具，避免你在开发过程中重复去造轮子，特别是帮你把日常中能遇到的场景或问题都给屏蔽掉，框架的意义在于屏蔽掉开发的基础复杂度、屏蔽掉此类共性的东西，同时建立严格的编码规范，让框架使用者开箱即用，并且只需要关注差异面，即业务层面的实现。简而言之，框架只干一件事，那就是简化开发。然后在此基础上，可能会再考虑一些安全性、效率、性能、弹性、管理、拓展、解耦等等。


理解 Spring 核心Spring 作为一个框架，目的也是：简化开发 ，只不过在简化开发的过程中 Spring 做了一个特别的设计，那就是 Bean管理，这也是 Spring 的设计核心，而 Bean 生命周期管理的设计巧妙的 解耦 了 Bean 之间的关系。因此 Spring 核心特性就是 解耦 和 简化。
带你彻底吃透Spring

文章图片



Spring 框架图示展示得很清晰，基本描绘出 Spring 框架的核心：
  • 内核
  • 外延
简单说，就是 Spring 设计了一个 核心容器 Core Container，这里头主要就是管理 Bean 生命周期，然后为了服务这些业务 Bean ，引入了 Core , Context , SpEL 等工具到核心容器中。然后在核心容器基础上，又为了把更多的能力集成进来，例如为了拓展 数据访问 能力加入了 JDBC 、ORM 、OXM 、JMS 、Transactions 等，为了拓展 Web 能力加入了 WebSocket 、Servlet、Web、Portlet 等，其中为了把 RequestMapping 或 Servlet 等这些使用集成到业务 Bean 上，引入了 AOP ，包括还有引入（最终是提供） Aspects、Instrumentation、Messageing 等增强方式。
带你彻底吃透Spring

文章图片

所以仔细一看，Spring 就是把像数据库访问、Web支持、缓存、消息发送等等这些能力集成到业务 Bean 上，并提供一些测试支持。总结来说理解 Spring 就两点：


  1. Bean管理：解耦Bean关系。理解为内核，从 Bean 的定义、创建、管理等，这是业务Bean。
  2. 功能增强：解耦功能、声明式简化。理解为外延，在业务Bean基础上，需要访库等能力，那就是功能增强。


基本体现的就是两个核心特性，一个 解耦、一个 简化。
带你彻底吃透Spring

文章图片

Bean管理 本身就是在做 解耦，解除耦合，这个解耦指 Bean 和 Bean 之间的关联关系，Bean 之间通过接口协议互相串联起来的，至于每个接口有多少个实现类，那都不会有任何影响，Bean 之间只保留单点通道，通过接口相互隔离，关系都交给 Spring 管理，这样就避免了实现类和实现类之间出现一些耦合，就算方法增减了、引用变更了也不至于互相污染。
功能增强 本身就是在做 简化，例如声明式简化，像声明式编程，使用者只需要告诉框架他要什么，不用管框架是如何实现的。另外简化方面还有 约定优于配置 （当然这个确切的说是 SpringBoot 里的设计），约定优于配置其实就是约定好了无需去做复杂的配置，例如你引入一个什么组件或能力就像 redis 或 kafka，你不需要提前配置，因为 springboot 已经为你默认配置，开箱即用。


【带你彻底吃透Spring】  因此 Spring 框架特性怎么理解？就 解耦 和 简化 。

带你彻底吃透Spring

文章图片

而 SpringBoot，简单理解就是在 Spring 框架基础上添加了一个 SPI 可拓展机制 和 版本管理，让易用性更高，简化升级。
带你彻底吃透Spring

文章图片

而 SpringCloud，简单理解就是，由于 SpringBoot 的 依赖 可以被很好的管理，拓展 可以被可插拔的拓展，因此在 SpringBoot 基础上集成了很多跟微服务架构相关的能力，例如集成了很多组件，便有了 SpringCloud 全生态。
基本了解了 Spring 特性之后，我们回到 Spring 的核心设计 IoC 与 AOP 。


IoC我们说了 Spring 的其一特性是 解耦，那到底是使用什么来解耦？
带你彻底吃透Spring

文章图片

控制反转（Inversion of Control，缩写为 IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称 DI），还有一种方式叫“依赖查找”（Dependency Lookup，EJB 和 Apache Avalon 都使用这种方式）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。简单来说，就是原本 Bean 与 Bean 之间的这种互相调用，变成了由 IoC 容器去统一调配。如果没使用 IoC 容器统一管理业务 Bean，你的应用在部署、修改、迭代的时候，业务 Bean 是会侵入代码实现并互相调用的。
带你彻底吃透Spring

文章图片





那么问题来了，所有系统都需要引入 IOC 吗？IoC 容器是面向 迭代 起作用，如果你的应用就 不存在迭代 的情况，即系统是万年不变的，那没必要引入 IoC，因为你每引入一项技术，都势必会增加复杂度，所以额外引入 IoC 也一样会增加你整体应用的复杂度，所以假如 不存在迭代，大可直接写死A类引用B类，B类又写死引用C类，无需引入 IoC。一定要理解每一项技术背后是为了解决什么问题，同时在做架构设计的时候记住两个原则：合适 、简单。
当然，实际上我们大部分应用是 持续迭代 的，在类实现上、互相引用上、甚至接口协议上都有可能变化，所以一般引入 IoC 是合适的（如果是接口协议变化，即参数或返回值发生变化，那还是需要改动类间的代码的）。具体的，IoC 相当于是把 Bean 实例的创建过程交给 Spring 管理，无论是通过 XML、javaConfig，还是注解方式，最终都是把实例化的工作交给 Spring 负责，之后 Bean 之间通过接口相互调用，而实例化过程中就涉及到 注入，无论采用什么方式来实例化 Bean，注入 的类别就两种：


  • Setter注入： 通过 setter 来设置，发生在对象实例化之后设置。
  • 构造器注入： 通过构造器注入，发生在对象实例化之前就得把参数/实例准备好。


setter注入：


  1. 与传统的 JavaBean 的写法更相似，程序开发人员更容易理解、接受。通过 setter 方法设定依赖关系显得更加直观、自然。
  2. 对于复杂的依赖关系，如果采用构造注入，会导致构造器过于臃肿，难以阅读。Spring 在创建 Bean 实例时，需要同时实例化其依赖的全部实例，因而导致性能下降。而使用设值注入，则能避免这些问题。
  3. 尤其在某些成员变量可选的情况下，多参数的构造器更加笨重。
构造器注入：


  1. 构造器注入可以在构造器中决定依赖关系的注入顺序，优先依赖的优先注入。
  2. 对于依赖关系无需变化的 Bean ，构造注入更有用处。因为没有setter方法，所有的依赖关系全部在构造器内设定，无须担心后续的代码对依赖关系产生破坏。
  3. 依赖关系只能在构造器中设定，则只有组件的创建者才能改变组件的依赖关系，对组件的调用者而言，组件内部的依赖关系完全透明，更符合高内聚的原则。
而这两种方式的注入方式都使用了 反射。
带你彻底吃透Spring

文章图片



反射了解反射相关类以及含义：
  • java.lang.Class：代表整个字节码。代表一个类型，代表整个类。
  • java.lang.reflect.Method：代表字节码中的方法字节码。代表类中的方法。
  • java.lang.reflect.Constructor：代表字节码中的构造方法字节码。代表类中的构造方法。
  • java.lang.reflect.Field：代表字节码中的属性字节码。代表类中的成员变量（静态变量+实例变量）。
java.lang.reflect 包提供了许多反射类，用于获取或设置实例对象。简单来说，反射能够：
  1. 在运行时判断任意一个对象所属的类；
  2. 在运行时构造任意一个类的对象；
  3. 在运行时判断任意一个类所具有的成员变量和方法；
  4. 在运行时调用任意一个对象的方法；
  5. 生成动态代理。
IoC 和 反射，只是把 Bean 的实例创建处理完，而后续还有 功能增强，功能增强靠的就是 AOP。


AOPAOP全名 Aspect-Oriented Programming ，中文直译为面向切面编程，当前已经成为一种比较成熟的编程思想，可以用来很好的解决应用系统中分布于各个模块的交叉关注点问题。在轻量级的J2EE中应用开发中，使用AOP来灵活处理一些具有 横切性质 的系统级服务，如事务处理、安全检查、缓存、对象池管理等，已经成为一种非常适用的解决方案。

为什么需要AOP
当我们要进行一些日志记录、权限控制、性能统计等时，在传统应用程序当中我们可能在需要的对象或方法中进行编码，而且比如权限控制、性能统计大部分是重复的，这样代码中就存在大量 重复代码，即使有人说我把通用部分提取出来，那必然存在调用还是存在重复，像性能统计我们可能只是在必要时才进行，在诊断完毕后要删除这些代码；还有日志记录，比如记录一些方法访问日志、数据访问日志等等，这些都会侵入到各个要访问方法中；还有权限控制，必须在方法执行开始进行审核，想想这些是多么可怕而且是多么无聊的工作。如果采用 Spring，这些日志记录、权限控制、性能统计从业务逻辑中分离出来，通过 Spring 支持的面向切面编程，在需要这些功能的地方动态添加这些功能，无需侵入到各个需要的方法或对象中；有人可能说了，我们可以使用“代理设计模式”或“包装器设计模式”，你可以使用这些，但还是需要通过编程方式来创建代理对象，还是要 耦合 这些代理对象，而采用 Spring 面向 切面 编程能提供一种更好的方式来完成上述功能，一般通过 配置 方式，而且不需要在现有代码中添加任何额外代码，现有代码专注业务逻辑。
带你彻底吃透Spring

文章图片

所以，AOP 以横截面的方式插入到主流程中，Spring AOP 面向切面编程能帮助我们无耦合的实现：


  • 性能监控，在方法调用前后记录调用时间，方法执行太长或超时报警。
  • 缓存代理，缓存某方法的返回值，下次执行该方法时，直接从缓存里获取。
  • 软件破译，使用 AOP 修改软件的验证类的判断逻辑。
  • 记录日志，在方法执行前后记录系统操作日志。
  • 工作流系统，工作流系统需要将业务代码和流程引擎代码混合在一起执行，那么我们可以使用AOP将其分离，并动态挂接业务。
  • 权限验证，方法执行前验证是否有权限执行当前方法，没有则抛出没有权限执行异常，有业务代码捕捉。
  • 等等
AOP 其实就是从应用中划分出来了一个切面，然后在这个切面里面插入一些 “增强”，最后产生一个增加了新功能的 代理对象，注意，是代理对象，这是Spring AOP 实现的基础。这个代理对象只不过比原始对象（Bean）多了一些功能而已，比如 Bean预处理、Bean后处理、异常处理 等。 AOP 代理的目的就是 将切面织入到目标对象。



AOP如何实现
前面我们说 IoC 的实现靠反射，然后解耦，那 AOP 靠啥实现？ AOP，简单来说就是给对象增强一些功能，我们需要看 Java 给我们预留了哪些口或者在哪些阶段，允许我们去织入某些增强功能。我们可以从几个层面来实现AOP。
带你彻底吃透Spring

文章图片

  • 编译期
  • 原理：在编译器编译之前注入源代码，源代码被编译之后的字节码自然会包含这部分注入的逻辑。
  • 代表作如：lombok, mapstruct（编译期通过 pluggable annotation processing API 修改的）。


  • 运行期，字节码加载前
  • 原理：字节码要经过 classloader（类加载器 的方式，在字节码被自定义类加载器加载前给它修改掉。
  • 代表作如：javasist, java.lang.instrument ,ASM（操纵字节码）。
  • 许多 agent 如 Skywaking, Arthas 都是这么搞，注意区分静态agent与动态agent。
  • JVMTI是 JVM 提供操作 native 方法的工具，Instrument就是提供给你操纵JVMTI的 java 接口，详情见java.lang.instrument.Instrumentation


  • 运行期，字节码加载后
  • 原理：字节码被类加载器加载后，动态构建字节码文件生成目标类的子类，将切面逻辑加入到子类中。
  • 代表作如：jdk proxy, cglib。


  按照类别分类，基本可以理解为：
类别
原理
优点
缺点
静态AOP
在编译期，切面直接以字节码的形式编译到目标字节码文件中
对系统无性能影响
灵活度不够
动态AOP
在运行期，目标类加载后，为接口动态生成代理类，将切面织入到代理类中
动态代理方式，相对于静态AOP更加灵活
切入的关注点需要实现接口，对系统有一点性能影响
动态字节码生成
在运行期，目标类加载后，动态构建字节码文件生成目标类的 子类，将切面逻辑加入到子类中
没有接口也可以织入
扩展类的实例方法为final时，则无法进行织入。性能基本是最差的，因为需要生成子类嵌套一层，spring用的cglib就是这么搞的，所以性能比较差
自定义类加载器
在运行期，在字节码被自定义类加载器加载前，将切面逻辑加到目标字节码里，例如阿里的Pandora
可以对绝大部分类进行织入
代码中如果使用了其他类加载器，则这些类将不会被织入
字节码转换
在运行期，所有类加载器加载字节码前，进行拦截
可以对所有类进行织入
-
当然，理论上是越早织入，性能越好，像 lombok,mapstruct 这类静态AOP，基本在编译期之前都修改完，所以性能很好，但是灵活性方面当然会比较差，获取不到运行时的一些信息情况，所以需要权衡比较。


简单说明5种类别：
带你彻底吃透Spring

文章图片



当然我整理了一份详细的脑图，可以直接在网页上打开。
《脑图：Java实现AOP思路》:https://www.processon.com/embed/62333d1ce0b34d074452eec2


1、静态AOP
发生在 编译期，通过 Pluggable Annotation Processing API 修改源码。
带你彻底吃透Spring

文章图片

在 javac 进行编译的时候，会根据源代码生成抽象语法树（AST），而 java 通过开放 Pluggable Annotation Processing API 允许你参与修改源代码，最终生成字节码。典型的代表就是 lombok。



2、动态AOP
发生在 运行期，于 字节码加载后，类、方法已经都被加载到方法区中了。
带你彻底吃透Spring

文章图片

典型的代表就是 JDK Proxy。

public static void main(String[] args)

// 需要代理的接口，被代理类实现的多个接口，都必须在这里定义
Class[] proxyInterface = new Class[]IBusiness.class,IBusiness2.class;

// 构建AOP的Advice，这里需要传入业务类的实例
LogInvocationHandler handler = new LogInvocationHandler(new Business());

// 生成代理类的字节码加载器
ClassLoader classLoader = DynamicProxyDemo.class.getClassLoader();

// 织入器，织入代码并生成代理类
IBusiness2 proxyBusiness =
(IBusiness2)Proxy.newProxyInstance(classLoader, proxyInterface, handler);

// 使用代理类的实例来调用方法
proxyBusiness.doSomeThing2();
((IBusiness)proxyBusiness).doSomeThing();



其中代理实现 InvocationHandler 接口，最终实现逻辑在 invoke 方法中。生成代理类之后，只要目标对象的方法被调用了，都会优先进入代理类 invoke 方法，进行增强验证等行为。

public class LogInvocationHandler implements InvocationHandler

private Object target; // 目标对象

LogInvocationHandler(Object target)
this.target = target;


@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable

// 执行原有逻辑
Object rev = method.invoke(target,args);

// 执行织入的日志，你可以控制那些方法执行切入逻辑
if (method.getName().equals("doSomeThing2"))
// 记录日志

return rev;




当然动态代理相对也是性能差，毕竟也多走了一层代理，每多走一层就肯定是越难以优化。虽然，动态代理在运行期通过接口动态生成代理类，这为其带来了一定的灵活性，但这个灵活性却带来了两个问题：
  1. 第一代理类必须实现一个接口，如果没实现接口会抛出一个异常。
  2. 第二性能影响，因为动态代理使用反射的机制实现的，首先反射肯定比直接调用要慢，经过测试大概每个代理类比静态代理多出10几毫秒的消耗。其次使用反射大量生成类文件可能引起Full GC造成性能影响，因为字节码文件加载后会存放在JVM运行时区的方法区（或者叫持久代，JDK1.8之后已经在元空间）中，当方法区满的时候，会引起Full GC，所以当你大量使用动态代理时，可以将持久代设置大一些，减少Full GC次数。


3、动态字节码生成
发生在 运行期，于 字节码加载后 ，生成目标类的子类，将切面逻辑加入到子类中，所以使用Cglib实现AOP不需要基于接口。此时类、方法同样已经都被加载到方法区中了。
带你彻底吃透Spring

文章图片

典型的代表就是 Cglib（底层也是基于ASM操作字节码）， Cglib 是一个强大的,高性能的 Code 生成类库，它可以在运行期间扩展Java类和实现Java接口，它封装了 Asm，所以使用 Cglib 前需要引入 Asm 的jar。
public static void main(String[] args)
byteCodeGe();


/**
* 动态字节码生成
*/
public static void byteCodeGe()
//创建一个织入器
Enhancer enhancer = new Enhancer();
//设置父类
enhancer.setSuperclass(Business.class);
//设置需要织入的逻辑
enhancer.setCallback(new LogIntercept());
//使用织入器创建子类
IBusiness2 newBusiness = (IBusiness2) enhancer.create();

    推荐阅读


    上一篇：redis优化系列高可用集群Redis Cluster的认识

    下一篇：Linux 内核 内存管理memblock 分配器 ③ ( memblock_region 内存块区域 | memblock_region 结构体成员分析 | memblock 分配器标志位 )