Spring基础知识——AOP

时间  2019-11-15
标签 spring 基础 知识 aop 栏目 Spring 繁體版
原文   原文链接

 ● AOP是什么

        原文：http://wayfarer.cnblogs.com/articles/241024.html html

    3.1.1 概览java

    AOP（Aspect-Oriented Programming，面向切面编程），能够说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来创建一种对象层次结构，用以模拟公共行为的一个集合。当咱们须要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP容许你定义从上到下的关系，但并不适合定义从左到右的关系，例如日志功能。日志代码每每水平地散布在全部对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其余类型的代码，如安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切（cross-cutting）代码，在OOP设计中，它致使了大量代码的重复，而不利于各个模块的重用。git

    而AOP技术则偏偏相反，它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即切面。所谓“切面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减小系统的重复代码，下降模块间的耦合度，并有利于将来的可操做性和可维护性。AOP表明的是一个横向的关系，若是说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向切面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以得到其内部的消息。而后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹。github

    使用“横切”技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特色是，他们常常发生在核心关注点的多处，而各处都基本类似。好比权限认证、日志、事务处理。Aop 的做用在于分离系统中的各类关注点，将核心关注点和横切关注点分离开来。正如Avanade公司的高级方案构架师Adam Magee所说，AOP的核心思想就是“将应用程序中的商业逻辑同对其提供支持的通用服务进行分离。”web

    实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法建立“切面”，从而使得编译器能够在编译期间织入有关“切面”的代码。然而异曲同工，实现AOP的技术特性倒是相同的，分别为：spring

一、切面（Aspect）：一个横切关注点的模块化，这个关注点可能会横切多个对象，它相似宇OOP中定义的一个类，但更多的是描述对象间横向的关系。express

二、链接点（Joinpoint）：在程序执行过程当中某个特定的点，好比某方法调用的时候或者处理异常的时候，它是一个抽象的概念，在实现AOP时，并不须要去定义一个join point。在Spring  AOP中，一个链接点老是表示一个方法的执行。编程

三、切入点（Pointcut）：一个捕获链接点的结构，能够认为是链接点的集合。设计模式

四、通知（Advice）：在切面的某个特定的链接点上执行的动做，是执行“切面”的具体逻辑。安全

五、引入（Introduction）：用来给一个对象声明额外的方法或属性，从而达到修改对象结构的目的

六、目标对象（Target Object）： 被一个或者多个切面所“横切”的对象，是须要被加强的对象。

七、AOP代理（AOP Proxy）： AOP框架使用代理模式建立的对象，从而实如今链接点处插入加强（即应用切面），就是经过代理来对目标对象应用切面。

八、织入（Weaving）：织入是一个过程，是将切面应用到目标对象从而建立出AOP代理对象的过程，织入能够在编译期、类装载期、运行期进行。

上述的技术特性组成了基本的AOP技术，大多数AOP工具均实现了这些技术。它们也能够是研究AOP技术的基本术语。

    3.1.2 横切技术

    “横切”是AOP的专有名词。它是一种蕴含强大力量的相对简单的设计和编程技术，尤为是用于创建松散耦合的、可扩展的企业系统时。横切技术可使得AOP在一个给定的编程模型中穿越既定的职责部分（好比日志记录和性能优化）的操做。

    若是不使用横切技术，软件开发是怎样的情形呢？在传统的程序中，因为横切行为的实现是分散的，开发人员很难对这些行为进行逻辑上的实现或更改。例如，用于日志记录的代码和主要用于其它职责的代码缠绕在一块儿。根据所解决的问题的复杂程度和做用域的不一样，所引发的混乱可大可小。更改一个应用程序的日志记录策略可能涉及数百次编辑——即便可行，这也是个使人头疼的任务。

    在AOP中，咱们将这些具备公共逻辑的，与其余模块的核心逻辑纠缠在一块儿的行为称为“横切关注点（Crosscutting Concern）”，由于它跨越了给定编程模型中的典型职责界限。

    3.1.2.1 横切关注点

    一个关注点（concern）就是一个特定的目的，一块咱们感兴趣的区域，一段咱们须要的逻辑行为。从技术的角度来讲，一个典型的软件系统包含一些核心的关注点和系统级的关注点。举个例子来讲，一个信用卡处理系统的核心关注点是借贷/存入处理，而系统级的关注点则是日志、事务完整性、受权、安全及性能问题等，许多系统级关注点——即横切关注点（crosscutting concerns）——会在多个模块中出现。若是使用现有的编程方法，横切关注点会横越多个模块，结果是使系统难以设计、理解、实现和演进。AOP可以比上述方法更好地分离系统关注点，从而提供模块化的横切关注点。

例如一个复杂的系统，它由许多关注点组合实现，如业务逻辑、性能，数据存储、日志和调度信息、受权、安全、线程、错误检查等，还有开发过程当中的关注点，如易懂、易维护、易追查、易扩展等，图2.1演示了由不一样模块实现的一批关注点组成一个系统。


                        图3.1 把模块做为一批关注点来实现

经过对系统需求和实现的识别，咱们能够将模块中的这些关注点分为：核心关注点和横切关注点。对于核心关注点而言，一般来讲，实现这些关注点的模块是相互独立的，他们分别完成了系统须要的商业逻辑，这些逻辑与具体的业务需求有关。而对于日志、安全、持久化等关注点而言，他们倒是商业逻辑模块所共同须要的，这些逻辑分布于核心关注点的各处。在AOP中，诸如这些模块，都称为横切关注点。应用AOP的横切技术，关键就是要实现对关注点的识别。

    若是将整个模块比喻为一个圆柱体，那么关注点识别过程能够用三棱镜法则来形容，穿越三棱镜的光束（指需求），照射到圆柱体各处，得到不一样颜色的光束，最后识别出不一样的关注点。如图3.2所示：

                    图3.2 关注点识别：三棱镜法则

上图识别出来的关注点中，Business Logic属于核心关注点，它会调用到Security，Logging，Persistence等横切关注点。

public class BusinessLogic
{
    public void SomeOperation()
    {
       //验证安全性；Securtity关注点；
       //执行前记录日志；Logging关注点；

       DoSomething();

       //保存逻辑运算后的数据；Persistence关注点；
       //执行结束记录日志；Logging关注点；
    }
}

AOP的目的，就是要将诸如Logging之类的横切关注点从BusinessLogic类中分离出来。利用AOP技术，能够对相关的横切关注点封装，造成单独的“aspect”。这就保证了横切关注点的复用。因为BusinessLogic类中再也不包含横切关注点的逻辑代码，为达到调用横切关注点的目的，能够利用横切技术，截取BusinessLogic类中相关方法的消息，例如SomeOperation()方法，而后将这些“aspect”织入到该方法中。例如图3.3：

                图3.3 将横切关注点织入到核心关注点中

经过利用AOP技术，改变了整个系统的设计方式。在分析系统需求之初，利用AOP的思想，分离出核心关注点和横切关注点。在实现了诸如日志、事务管理、权限控制等横切关注点的通用逻辑后，开发人员就能够专一于核心关注点，将精力投入到解决企业的商业逻辑上来。同时，这些封装好了的横切关注点提供的功能，能够最大限度地复用于商业逻辑的各个部分，既不须要开发人员做特殊的编码，也不会由于修改横切关注点的功能而影响具体的业务功能。

    ● 为何使用AOP

    AOP技术的优点是显而易见的。在面向对象的世界里，人们提出了各类方法和设计原则来保障系统的可复用性与可扩展性，以期创建一个松散耦合、便于扩展的软件系统。例如GOF提出的“设计模式”，为咱们提供了设计的典范与准则。设计模式经过最大程度的利用面向对象的特性，诸如利用继承、多态，对责任进行分离、对依赖进行倒置，面向抽象，面向接口，最终设计出灵活、可扩展、可重用的类库、组件，乃至于整个系统的架构。在设计的过程当中，经过各类模式体现对象的行为、暴露的接口、对象间关系、以及对象分别在不一样层次中表现出来的形态。然而鉴于对象封装的特殊性，“设计模式”的触角始终在接口与抽象中大作文章，而对于对象内部则无能为力。

    经过“横切”技术，AOP技术就能深刻到对象内部翻云覆雨，截取方法之间传递的消息为我所用。因为将核心关注点与横切关注点彻底隔离，使得咱们可以独立的对“切面”编程。它容许开发者动态地修改静态的OO模型，构造出一个可以不断增加以知足新增需求的系统，就象现实世界中的对象会在其生命周期中不断改变自身，应用程序也能够在发展中拥有新的功能。

    设计软件系统时应用AOP技术，其优点在于：

    （一）在定义应用程序对某种服务（例如日志）的全部需求的时候。经过识别关注点，使得该服务可以被更好的定义，更好的被编写代码，并得到更多的功能。这种方式还可以处理在代码涉及到多个功能的时候所出现的问题，例如改变某一个功能可能会影响到其它的功能，在AOP中把这样的麻烦称之为“纠结（tangling）”。

    （二）利用AOP技术对离散的切面进行的分析将有助于为开发团队指定一位精于该项工做的专家。负责这项工做的最佳人选将能够有效利用本身的相关技能和经验。

    （三）持久性。标准的面向对象的项目开发中，不一样的开发人员一般会为某项服务编写相同的代码，例如日志记录。随后他们会在本身的实施中分别对日志进行处理以知足不一样单个对象的需求。而经过建立一段单独的代码片断，AOP提供了解决这一问题的持久简单的方案，这一方案强调了将来功能的重用性和易维护性：不须要在整个应用程序中一遍遍从新编写日志代码，AOP使得仅仅编写日志方面（logging aspect）成为可能，而且能够在这之上为整个应用程序提供新的功能。

    总而言之，AOP技术的优点使得须要编写的代码量大大缩减，节省了时间，控制了开发成本。同时也使得开发人员能够集中关注于系统的核心商业逻辑。此外，它更利于建立松散耦合、可复用与可扩展的大型软件系统。

    ● 怎么用——Spring中的AOP

    （1）、AOP Hello World

    开发环境搭建过程就不说了，直接上代码。

    核心业务代码

/**
 * 核心业务接口
 * @author FF
 *
 */
public interface PersionDao {
	
	public void savePersion();
}

/**
 * 核心业务类
 * @author FF
 *
 */
public class PersionDaoImp implements PersionDao {

	@Override
	public void savePersion() {

		System.out.println("save persion…………");
	}
}

  切面代码

/**
 * 事务相关的切面
 * @author FF
 *
 */
public class Transaction {
	
	public void begin() {
		
		System.out.println("transaction begin");
	}
	
	public void commit() {
		
		System.out.println("transaction commit");
	}
}

  测试代码

public class test {
	
	private ApplicationContext applicationContext;
	
	@Before
	public void init() {
		
		applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		
	}
	
	@Test
	public void myTest() {
		
		PersionDao persionDao = (PersionDao) applicationContext.getBean("persionDao");
		persionDao.savePersion();
	}
}

    applicationContext.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: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">
	
	<bean id="persionDao" class="target.PersionDaoImp"></bean>
	<bean id="transaction" class="aspect.Transaction"></bean>
	
	<aop:config>
		<aop:pointcut expression="execution (* target.PersionDaoImp.*(..))" id="perform"/>
		<aop:aspect ref="transaction">
			<aop:before method="begin" pointcut-ref="perform"/>
			<aop:after-returning method="commit" pointcut-ref="perform"/>
		</aop:aspect>
	</aop:config>
	
</beans>

    测试结果截图，运行测试代码中的myTest()方法，获得如下结果

    

    注：myTest()方法中getBean获取到的是一个PersionDaoImpImp对象的代理对象

    （3）、AOP配置说明

     <aop:config>：aop相关配置

     <aop:pointcut>: 定义一个切入点切入点。expression属性是切入点表达式，id是切入点惟一标识。

    <aop:aspect>: 定义一个切面切面。ref属性是切面类对应的<bean>id。

    <aop:before>: 定义一个前置通知。在目标方法以前执行配置的代码。method属性是要执行的方法名，pointcut-ref是切入点映射。此外aop:after-returning是后置通知，aop:after是最终通知，aop:after-throwing是异常通知，aop:around是环绕通知。

    （4）、切入点表达式说明

        切入点表达式与完整方法对应关系图

    

    其中“？”号结尾的无关紧要，即public……，java.lang.Object……，java.lang.InterruptedException……可省略

    Hello World示例中

expression="execution (* target.PersionDaoImp.*(..))"

    表示target包下PersionDaoImp类中的全部方法，方法的参数任意

    下面是几个表达式例子：

    任意公共方法的执行：   execution（public * *（..））

    任何一个名字以“set”开始的方法的执行：    execution（* set*（..））

    AccountService接口定义的任意方法的执行：    execution（* com.xyz.service.AccountService.*（..））

    在service包中定义的任意方法的执行：    execution（* com.xyz.service.*.*（..））

    在service包或其子包中定义的任意方法的执行：    execution（* com.xyz.service..*.*（..））

    在service包中的任意链接点（在Spring AOP中只是方法执行）：    within（com.xyz.service.*）

    在service包或其子包中的任意链接点（在Spring AOP中只是方法执行）：    within（com.xyz.service..*）

    实现了AccountService接口的代理对象的任意链接点 （在Spring AOP中只是方法执行）：    this（com.xyz.service.AccountService）

    实现AccountService接口的目标对象的任意链接点 （在Spring AOP中只是方法执行）：    target（com.xyz.service.AccountService）

    任何一个只接受一个参数，而且运行时所传入的参数是Serializable 接口的链接点（在Spring AOP中只是方法执行）:    args（java.io.Serializable）

    （5）、通知种类

        前置通知：在目标方法执行以前执行。xml配置文件中用<aop:before>配置

        后置通知：在目标方法执行以后执行，能够获取目标方法的返回值，当方法遇到异常不执行。xml配置文件中用<aop:after-returning>配置

        最终通知：在目标方法执行以后执行，不管目标方法是否遇到异常都执行。相似try catch块中的finally。

        异常通知：获取目标方法抛出的异常，当目标方法抛出异常时执行。

        环绕通知：能控制目标方法的执行。

    （6）、Hello World程序执行流程

        在Spring容器启动后：一、首先容器实例化xml文件中配置的bena，persionDao与transaction。二、接着Spring会解析aop配置，解析配置的切入点perform以及切面transaction和切面中配置的各类通知。Spring容器会依据切入点表达式匹配的类在Spring容器中查找，若是找到这个类，会为其建立代理对象，若是没有找到会报错。三、接着Spring为代理对象生成方法，经过通知+目标方法的方式。四、客户端经过getBean()方法获取对象，若是这个对象有代理则返回代理对象，若是没有返回对象自己。

        说明：一、客户端getBean()时，若是对象存在对应的代理，返回代理对象，若是没有则返回对象自己。二、若是目标类实现了接口，Spring自动使用jdk动态代理技术生成代理对象，若是目标类没有实现接口，Spring会使用cglib生成代理对象。生成的代理对象由Spring容器控制。

    （7）、AOP的两个应用案例

        一、用aop实现统一的异常处理

            思路：建立一个包含异常处理方法的切面，使用这个切面作统一的异常处理。

            代码：https://github.com/littleant2/java-web/tree/master/springAop_exception

        二、权限控制

            思路：建立一个切面，其中包含权限判断的通知，将其定义为环绕通知。

            代码：https://github.com/littleant2/java-web/tree/master/springAop_privilege

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程