LearnJava
  • Summary
    • Introduction
    • MyResume
  • 开发
    • 小程序
      • 小程序开发问题总结
      • 小程序bug
    • 环境搭建
      • Linux搭建git服务器
      • Linux切换JDK版本
      • Mac搭建http服务器
      • Ubuntu搭建C++开发环境
      • ProtoBuffer安装
      • Ubuntu开启Telnet
      • Linux搭建邮件服务器
    • 遇到的问题
      • Mac下eclipse问题
      • Mac下Github问题
      • Markdown解决方案实例
      • Spring问题
  • 编程语言
    • C++
      • C&C++框架汇总
      • C++Primer课后习题记录
      • C++疑问
      • C++与java的异同
      • C++内存模型
      • C++知识点
      • Make和Cmake
    • GO
      • Go语言简介
      • Go语言知识点
    • XML
      • XML知识点
  • 技术学习
    • JavaIO
      • AIO通信
      • IO和NIO
      • 阻塞式IO通信
      • 非阻塞式IO通信
    • 计算机网络
      • CDN
      • HTTPS协议入门
      • HTTP_POST请求的数据格式
      • HTTP错误码和出现场景
      • HTTP协议入门
      • TCP/IP协议入门
      • Wireshark抓包
      • 域名解析过程
    • 计算机原理
      • 整型计算
      • GPU
      • Swap内存
    • 架构学习
      • 分布式锁
      • 分布式系统的CAP理论
      • IaaS,PaaS,SaaS的区别
      • Web框架
      • 康威定律
      • 秒杀系统设计
      • 数据异构
      • 微服务架构入门
      • 协程
      • MQ推拉模式对比
      • UML图
      • 缓存穿透击穿和雪崩
    • 前端学习
      • 安装使用VUE
      • 搭建VUE项目
    • 大数据
      • Hadoop之HBASE
      • Hadoop之HDFS
      • Hadoop之MapReduce
      • Hadoop简介
    • 数据结构
      • 二叉树
      • 图
      • 跳表
      • Bitmap
    • 算法
      • 排序算法
        • 插入排序
        • 归并排序
        • 计数排序
        • 快速排序
        • 冒泡排序
        • 选择排序
      • Hash算法
      • MD5介绍
      • 一致性Hash算法
      • 数字全排列
      • MD5介绍
      • 储水量
      • 最大子序列
    • Java多线程
      • AQS原理
      • AtomicInteger原理
      • Condition
      • Fork/Join框架
      • happens-before
      • Java锁优化
      • Java线程池
      • Java中的阻塞队列
      • Java实现线程的三种方式
      • Lock
      • Lock的种类
      • ThreadLocal
      • 线程状态及其转换
    • Java设计模式
      • Builder模式
      • 代理模式
      • 工厂和抽象工厂模式
      • 观察者模式
      • 设计模式概述
      • 职责链模式
      • 装饰者模式
      • Java实现单例的5种方式
    • Java学习
      • Java拓展学习
        • JavaSPI
      • Java序列化
      • Java异常
      • Java注解
      • 学习UML图
      • Java的Lambda表达式
      • Java集合之ArrayList
      • Java集合之HashMap
      • Java集合之LinkedList
      • List⤅&Set的操作和遍历
      • JavaP反编译命令
      • Servlet学习
    • JVM学习
      • 分层编译
      • Java进程内存占用
      • JVM参数
      • JVM常用工具
      • JVM的内存模型
      • 垃圾回收机制
      • 看懂gc日志
      • 类加载机制和双亲委派模型
      • 类的反射
      • 自己动手编译OPENJDK
      • ASM字节码增强技术
      • CodeCache
      • GC耗时案例
      • JVM性能调优
    • Linux学习
      • gdb调试定位
      • Linux常用命令
      • Linux工具
      • Linux进程通信的方式
      • Linux文件系统结构
      • Linux系统知识点
      • Linux小技巧
      • Shell学习
      • Vim常用命令
    • Java设计模式
      • 设计模式概述
      • 代理模式
      • 装饰者模式
    • Mysql
      • InnoDB介绍
      • Mac_mysql问题
      • mysql之group_concat函数
      • mysql事务
      • Mysql优化
      • Mysql实用命令
      • mysql慢查询
      • mysql文件
      • mysql视图
      • mysql锁
      • mysql索引
      • mysql约束
      • 存储过程和触发器
      • mysql常用语法
    • Spring
      • SpringCloud
        • 搭建Jenkins自动部署
        • SpringCloud介绍
        • SpringCloudBus
        • SpringCloudConfig
        • SpringCloudEureka
        • SpringCloudFeign
        • SpringCloudHystrix
        • SpringCloudRibbon
        • SpringCloudSleuth
        • SpringCloudStream
        • SpringCloudZuul
      • FactoryBean理解
      • MyBatis入门介绍
      • rose框架学习
      • SpringMVC的启动流程
      • SpringBean的生命周期
      • SpringBoot入门
      • Spring入门AOP和IOC
      • SpringMVC入门笔记
      • SpringMVC集成Log4j2
      • web.xml详解
    • web中间件学习
      • Redis
        • Redis入门
        • Redis持久化
        • Redis的数据类型
        • Redis特性
      • Gremlin入门
      • Elasticsearch安装使用
      • HugeGraph入门
      • jetty介绍
      • Kafka介绍使用
      • Maven安装配置
      • Netty介绍使用
      • Netty的编解码
      • Maven的pom介绍
      • Nginx介绍
      • Nginx配置详解
      • ProtocolBuffers学习笔记
      • Resin学习
      • RESTful入门
      • RocketMQ入门
      • RPC入门
      • Thrift介绍
      • Tomcat常用配置
      • Tomcat学习
      • Tomcat实现
      • zookeeper入门
      • Zookerper选举原理
  • 文档读后感
    • 除了写代码你还会干什么
  • 效率提升
    • Java诊断工具Arthas
    • Mac下安装多版本java
    • Mac下显示git分支
    • Mac中Clion快捷键
    • Mac中Eclipse快捷键
    • MacShell常用快捷键
    • PlantUML入门
    • Windows与Linux服务器传文件
    • Sublime技巧
    • 搜索引擎检索技巧
  • 总结
    • 2017工作总结
Powered by GitBook
On this page
  • 1. 概述
  • 2. IOC
  • 2.1 依赖注入的好处
  • 2.2 依赖注入的场景
  • 2.3 装配bean的方式
  • 3. AOP
  • 4. 学习路径

Was this helpful?

  1. 技术学习
  2. Spring

Spring入门AOP和IOC

1. 概述

Spring框架的核心有两个:

  • Spring容器作为超级大工厂,负责管理、创建所有的Java对象,这些Java对象被称为Bean。

  • Spring容器管理容器中Bean之间的依赖关系,使用一种叫做“依赖注入”的方式来管理bean之间的依赖关系。

Spring有两个核心接口:BeanFactory和ApplicationContext,ApplicationContext是BeanFactory的子接口、它们都可以代表Spring容器,Spring容器是生成Bean实例的工厂,并管理容器中的Bean。建议优先使用ApplicationContext。除非对内存非常关键的应用再考虑使用BeanFactory。当系统创建ApplicationContext的时候,默认会预初始化所有Singleton Bean,这就意味着前期创建ApplicationContext时将有较大的性能开销,但一旦ApplicationContext初始化完成,程序后面获取singleton Bean实例时,就拥有较好的性能。为<bean/>元素指定lazy-init="true"那么就不会预初始化Singleton bean了。

2. IOC

Inversion Of Control,控制反转,也可以叫依赖注入。A对象需要调用B对象的方法的情景,这种情形称为依赖,即A对象依赖B对象。使用依赖注入不仅可以为Bean对象注入普通的属性值,还可以注入其他Bean引用。通过这种依赖注入,Java EE应用中的各种组件不需要以硬编码方式耦合在一起,甚至无需使用工厂模式。当某个Java实例需要其他Java实例时,系统自动提供所需要的实例,无需程序显式获取。

2.1 依赖注入的好处

先来说说传统使用java实例的不足,一般有两种方式:

  • 通过new关键字实例化一个对象;

  • 通过工厂模式生产一个实例对象;

第一种方式必然导致调用者和被依赖对象存在硬编码耦合,非常不利于项目升级的维护;第二种比第一种好很多,但是调用组件需要主动通过工厂去获取被依赖的对象,这就会带来调用组件与被依赖工厂的耦合。

那么IOC有什么好处呢?

调用者无需主动获取被依赖的对象,只要被动接受Spring容器为调用者的成员变量即可。总体来说就是主动变为被动,所以被称为控制反转。

2.2 依赖注入的场景

依赖注入一般有以下两种:

  • 设值注入:IoC容器使用成员变量的setter方法来注入被依赖对象;

  • 构造注入:IoC容器通过构造器来注入被依赖对象;

建议采用设值注入为主,构造注入为辅的注入策略。对于依赖关系无需变化的注入,尽量采用构造注入;而其他依赖关系的注入,则考虑采用设值注入。

除了这两种依赖注入的方式还有一种接口注入的方式,这种方式使用的场景较少,主要是为了应对资源不是来自自身系统,而是来自外界的情况,比如数据库的连接资源可以在tomcat下配置,然后通过JNDI的形式获取它。

使用IoC容器的三个基本要点:

  • 应用程序的各组件面向接口编程,这样就可以将组件之间的耦合关系提升到接口层次,从而有有利于项目后期的发展;

  • 应用程序的各组件不再由程序主动创建,而是由Spring容器来负责产生并初始化;

  • Spring采用配置文件或注解来管理Bean的实现类、依赖关系,Spring容器则根据配置文件或注解,利用反射来创建实例,并为之注入依赖关系。

2.3 装配bean的方式

装配bean的方式一共有两种:

  • 通过xml配置:这种方式最直观清晰,通过bean标签完成一个bean的装配。

  • 通过注解配置:使用@Component等注解装配一个bean。使用@Autowired可以自动装配。

使用哪种装配方式看情况而定,如果是自身项目优先使用注解方式,对于引入的第三方包尽量使用xml方式。更加清晰和明朗。

3. AOP

Aspect Oriented Programming,面向切面编程,用于在模块化方面的横切关注点。AOP和OOP(Object Oriented Programming)互为补充,可以这么理解:面向对象编程是从静态角度纵向考虑程序结构,面向切面编程则是从动态角度横向考虑运行过程。比如一个日记记录的功能,代码往往水平的散落在所有对象中,与被散布的对象的核心功能没什么关系,这种散布在各个对象中的无关代码被称为“横切代码”,在OOP的设计中,它导致了大量代码的重复,从而不利于各个模块的复用。

简单的说,它是一个拦截器可以拦截一些过程,当一个方法执行,Spring AOP可以拦截一个方法的执行,在这个方法执行的前后添加一些功能。是一个典型代理模式的应用。

AOP中的一些术语

  • 切面(Aspect):切面组织多个Advice,Advice放在切面中定义。

  • 连接点(JoinPoint):程序执行过程中明确的点,如方法的调用,或者异常的抛出,在Spring AOP中,连接点总是方法的调用。

  • 增强处理(Advice):AOP框架在特定的切入点执行的增强处理,处理有“before”、“after”、“after-returning”、“around”、“after-throwing”等;

  • 切入点(Pointcut):可以插增强处理的连接点。当某个连接点满足指定要求时,该连接点将被添加增强处理(Advice),该连接点也就变成了切入点。

以一个bean配置为例:

<aop:config>
        <!-- advisor是简化的切面,只能指定一个pointcut -->
		<aop:advisor advice-ref="thirdAdviceBean" order="3" pointcut="(within(com.wangjun.aop.xml.Hello))"/>

		<!-- order:指定切面bean的优先级,值越小,优先级越高 -->
		<aop:aspect id="fourAdviceAspect" ref="fourAdviceBean" order="2">
			<aop:around method="processTask" pointcut="execution(* com.wangjun.aop.xml.*.*(..))"/>
			<aop:before method="authority" pointcut="execution(* com.wangjun.aop.xml.*.*(..))"/>
			<aop:after-returning method="log" returning="rvt" pointcut="execution(* com.wangjun.aop.xml.*.*(..))"/>
		</aop:aspect>
	</aop:config>

其中<aop:aspect/>和<aop:advisor/>标签就是切面,<aop:aspect/>下面的<aop:around/>、<aop:before/>这些就是增强处理,那么在哪里进行增强处理呢?pointcut属性就定义了切入点,也就是在哪里进行增强处理。这里的表达式比如execution(* com.wangjun.aop.xml.*.*(..))含义如下:

  1. 指定在com.wangjun.aop.xml包中任意类方法;

  2. 第一个*表示返回值不限,第二个*表示类名不限;

  3. 第三个*表示方法名不限,圆括号中的(..)表示任意个数、类型不限的形参。

切入点表达是也可以用within, 比如上面的within(com.wangjun.aop.xml.Hello,与execution的区别在于within只能定义类级别的,execution可以定义的范围包括包名、方法修饰符、方法名、返回值、参数等任意粒度。参考:https://blog.csdn.net/qushaming/article/details/102618542

还有一些术语:

  • 引入:将方法或字段添加到被处理的类中。Spring允许将新的接口引入到任何被处理的对象中,例如,你可以使用一个引入,使任何对象实现isModify接口,以此来简化缓存。

  • 目标对象:被AOP框架增强处理的对象。如果AOP采用的是动态AOP实现,那么该对象就是一个被代理的对象;

  • AOP代理:AOP框架创建的对象,也可以是cglib代理,代理就是堆目标对象的加强。

  • 织入(Weaving):将增强处理添加到目标对象中,并创建一个被增强的对象的过程就是织入。Spring和其他纯javaAOP框架一样,在运行时完成织入。

使用场景

日志记录、审计、声明式事务、安全性和缓存等。

AspectJ和Spring AOP的区别

正好代表了实现AOP的两种方式:

AspectJ是静态实现AOP的,即在编译阶段对程序进行修改,需要特殊的编译器,具有较好的性能;

Spring AOP是动态实现AOP的,即在运行阶段动态生成AOP代理,纯java实现,因此无需特殊的编译器,但是通常性能较差。

目前Spring已经对AspectJ进行了很好的集成。

Spring实现AOP的方式

  • 基于注解的“零配置”方式:使用@Aspect、@Pointcut等注解标注切入点和增强处理;

  • 基于XML配置文件的管理方式:使用Spring配置文件来定义切入点和增强处理;

Spring AOP的动态代理

所谓的动态代理就是说AOP框架不会去修改字节码,而是在内存中临时为方法生成一个AOP对象,这个AOP对象包含了目标对象的全部方法,并且在特定的切点做了增强处理,并回调原对象的方法。

Spring AOP中的动态代理主要有两种方式,JDK动态代理和CGLIB动态代理。JDK动态代理通过反射来接收被代理的类,并且要求被代理的类必须实现一个接口。JDK动态代理的核心是InvocationHandler接口和Proxy类。

如果目标类没有实现接口,那么Spring AOP会选择使用CGLIB来动态代理目标类。CGLIB(Code Generation Library),是一个代码生成的类库,可以在运行时动态的生成某个类的子类,注意,CGLIB是通过继承的方式做的动态代理,因此如果某个类被标记为final,那么它是无法使用CGLIB做动态代理的。

4. 学习路径

  1. 构建AOP和IOC的demo;

  2. 安装spring工具套件STS;

  3. 使用无注解方式进行AOP;

  4. 使用xml配置方式进行AOP;

PreviousSpringBoot入门NextSpringMVC入门笔记

Last updated 1 year ago

Was this helpful?