aop切面编程

‘壹’ spring中的aop 是怎么面向切面编程的

Spring面向切面编程(AOP)

1 spring容器中bean特性

Spring容器的javabean对象默认是单例的。

通过在xml文件中，配置可以使用某些对象为多列。

Spring容器中的javabean对象默认是立即加载（立即实例化：spring加载完成，立即创建对象）

scope:属性

singleton：默认值为单例，默认也是立即加载,在加载完成spring容器的时候，bean对象已经创建完成

prototype：多例的，默认懒加载，spring容器加载完成的时候，不会创建bean的对象，只有从容器获得bean对象的时候，才进行bean对象的实例化

request: 将创建的javabean对象，封装到request范围

session:将创建的javabean对象，封装到session范围

Spring容器bean的对象生命周期：

Bean对象的创建一直到销毁为bean的生命周期。

生命周期的开始：

如果为单例，由加载完spring容器开始

如果为多例，由从容器获得bean对象开始

实例化

初始化

服务

销毁(单例：关闭容器的时候，多例由jvm自动回收)

2 spring的AOP面向切面编程

2.1 模拟银行转账业务

需求：实现银行的转账功能，在转账的时候需要完成

1 身份认证（登陆）

2 权限的验证

3 转账实现

4 历史交易记录，

分析：1，2，4三个功能对于银行的业务，属于公共的功能（共性的功能）

在功能实现的时候，需要将1，2，4抽取出来，单独实现，

做到了将共性的功能和核心的业务功能进行了分离

通过动态代理实现：共性的功能和核心业务功能的合并，产生核心业务对象的

在代码实现的时候，进行了功能实现的分离：

代码开发的进行分离，程序在运行的时候进行合并。

2.2 springAOP的思想

在系统开发中，将系统的共性的公共的功能独立实现，在程序运行的过程中，将共性功能和核心的业务功能，进行整合。

好处：

1 完成共性功能和核心业务功能的解耦合

2 提供共性功能的复用性。

2.3springAOP的概念

Aspect切面：封装共性功能的（增强功能的）类

Advice通过：切面类中封装的增强功能的方法。

PointCut:切入点，是一个集合的概念，该集合的表达使用一个正则表达式表达

所有核心业务对象的所有方法的前后（事务处理AOP典型的应用）

JoinPoint:连接点，程序中需要加入advice的地方，而且正在执行的ponitCut

织入(Weaving)：将aspect和核心业务对象，进行整合的过程。

3 springAOP的实现

3.1通过特定接口实现

Aop通知的类型：

Before:前置通知

After：后置通知

Around：环绕通知

Throwing：异常通知

需求：实现在业务对象中的方法执行的时候，记录日志功能

3.1.1前置通知

packageorg.guangsoft.utils;
importjava.lang.reflect.Method;
importjava.util.Arrays;
importjava.util.Date;
importorg.springframework.aop.MethodBeforeAdvice;
/****
*前置增强：
*MethodBeforeAdvice接口表示重写的方法为前置advice
****/

{
@Override
publicvoidbefore(Methodmethod,
Object[]args,Objectobj)
throwsThrowable
{
System.out.println(method);
System.out.println(Arrays.toString(args));
System.out.println(obj);
System.out.println("BeforeLog-------------"+newDate());
}
}

AOP配置:

<?xmlversion="1.0"encoding="UTF-8"?>
<!--到入xml文件的约束-->
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:aop="http://www.springframework.org/schema/aop"xmlns:p="http://www.springframework.org/schema/p"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">
<!--实例化BeforeLog对象-->
<beanid="bf"class="org.guangsoft.utils.BeforeLog"></bean>
<!--实例化service对象-->
<beanid="us"class="org.guangsoft.service.impl.UsersServiceImpl"/>
<!--进行aop的配置，产生代理对象-->
<aop:config>
<!--声明切入点-->
<aop:pointcutexpression="execution(*org.guansoft.service.impl.*.*(..))"
id="pc"/>
<!--织入将通知和切入点进行合并（切面+核心业务对象）-->
<aop:advisoradvice-ref="bf"pointcut-ref="pc"/>
</aop:config>
</beans>

3.1.2后置通知

对业务对象的方法进行后增强。

packageorg.guangsoft.utils;
importjava.lang.reflect.Method;
importjava.util.Date;
importorg.springframework.aop.AfterReturningAdvice;
/***
*后置通知
****/

{
@Override
publicvoidafterReturning(Objectobj1,//obj1接收目标方法的返回值
Methodmethod,
Object[]args,
Objectobj2)throwsThrowable
{
//System.out.println(obj1+"----------------------"+obj2);
System.out.println("AfterLog-------------------"+newDate());
}
}

AOP配置:

<?xmlversion="1.0"encoding="UTF-8"?>
<!--到入xml文件的约束-->
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:aop="http://www.springframework.org/schema/aop"xmlns:p="http://www.springframework.org/schema/p"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">
<!--实例化BeforeLog对象-->
<beanid="bf"class="org.guangsoft.utils.BeforeLog"></bean>
<beanid="af"class="org.guangsoft.utils.AfterLog"></bean>
<!--实例化service对象-->
<beanid="us"class="org.guangsoft.service.impl.UsersServiceImpl"/>
<!--进行aop的配置，产生代理对象-->
<aop:config>
<!--声明切入点-->
<aop:pointcutexpression="execution(*org.guangsoft.service.impl.*.*(..))"
id="pc"/>
<!--织入将通知和切入点进行合并（切面+核心业务对象）-->
<aop:advisoradvice-ref="bf"pointcut-ref="pc"/>
<aop:advisoradvice-ref="af"pointcut-ref="pc"/>
</aop:config>
</beans>

3.1.3环绕通知

packageorg.guangsoft.utils;
importjava.lang.reflect.Method;
importjava.util.Arrays;
importjava.util.Date;
importorg.aopalliance.intercept.MethodInterceptor;
importorg.aopalliance.intercept.MethodInvocation;
/***
*环绕通知
****/

{
/**
*MethodInvocation中封装了目标对象，调用的方法，方法需要的参数
****/
@Override
publicObjectinvoke(MethodInvocationmi)throwsThrowable
{
Methodmethod=mi.getMethod();
Object[]args=mi.getArguments();
Objectobj=mi.getThis();
System.out.println(method);
System.out.println(Arrays.toString(args));
System.out.println(obj);
System.out.println("around------before--------"+newDate());
Objectrv=method.invoke(obj,args);//调用目标对象的方法，放行
System.out.println("around------after--------"+newDate());
returnrv;
}
}

AOP配置：同上

3.1.4 异常通知

packageorg.guangsoft.utils;
importjava.util.Date;
importorg.springframework.aop.ThrowsAdvice;
/****
*异常通知
***/

{
/***
*该类中的方法参考AfterReturningAdvice写
*该参数是用来接收异常信息的
****/
publicvoidafterThrowing(Throwableex)throwsThrowable
{
//System.out.println(obj1+"----------------------"+obj2);
System.out.println("ExceptionLog-----------"+ex.getMessage()
+"--------"+newDate());
}
}

Pointcut:核心业务对象

Advice：通知

‘贰’ 什么是面向切面编程AOP

面向切面编程（AOP是Aspect Oriented Program的首字母缩写） ，我们知道，面向对象的特点是继承、多态和封装。而封装就要求将功能分散到不同的对象中去，这在软件设计中往往称为职责分配。实际上也就是说，让不同的类设计不同的方法。这样代码就分散到一个个的类中去了。这样做的好处是降低了代码的复杂程度，使类可重用。

但是人们也发现，在分散代码的同时，也增加了代码的重复性。什么意思呢？比如说，我们在两个类中，可能都需要在每个方法中做日志。按面向对象的设计方法，我们就必须在两个类的方法中都加入日志的内容。也许他们是完全相同的，但就是因为面向对象的设计让类与类之间无法联系，而不能将这些重复的代码统一起来。
也许有人会说，那好办啊，我们可以将这段代码写在一个独立的类独立的方法里，然后再在这两个类中调用。但是，这样一来，这两个类跟我们上面提到的独立的类就有耦合了，它的改变会影响这两个类。那么，有没有什么办法，能让我们在需要的时候，随意地加入代码呢？这种在运行时，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程。
一般而言，我们管切入到指定类指定方法的代码片段称为切面，而切入到哪些类、哪些方法则叫切入点。有了AOP，我们就可以把几个类共有的代码，抽取到一个切片中，等到需要时再切入对象中去，从而改变其原有的行为。
这样看来，AOP其实只是OOP的补充而已。OOP从横向上区分出一个个的类来，而AOP则从纵向上向对象中加入特定的代码。有了AOP，OOP变得立体了。如果加上时间维度，AOP使OOP由原来的二维变为三维了，由平面变成立体了。从技术上来说，AOP基本上是通过代理机制实现的。
AOP在编程历史上可以说是里程碑式的，对OOP编程是一种十分有益的补充。

‘叁’ Java编程中的AOP和IOC分别是什么呢，什么时候用呢

控制反转（IOC）

（理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”）

1、Ioc—Inversion of Control：即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。

2、谁控制谁，控制什么：传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象即由Ioc容器来控制对象的创建。

谁控制谁？当然是IoC 容器控制了对象。

控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。

3、为何是反转，哪些方面反转了： 有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象。

为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象,所以是反转。

哪些方面反转了？依赖对象的获取被反转了。

还是不明白没事，下面搞个简单案例来说就懂啦 ！！！

例子：当我们在任何一个有实际开发意义的程序项目中，我们会使用很多类来描述他们特有的功能，并且通过类与类之间的相互协作来完成特定的业务逻辑。这个时候，每个类都需要负责管理与自己有交互的类的引用和依赖，代码将会变的异常难以维护和极高的高耦合。而IOC的出现正是用来解决这个问题，我们通过IOC将这些依赖对象的创建、协调工作交给spring容器去处理，每个对象值需要关注其自身的业务逻辑关系就可以了。在这样的角度上来看，获得依赖的对象的方式，进行了反转，变成了由spring容器控制对象如何获取外部资源（包括其他对象和文件资料等）。

总的来说：IOC就是通过在Xml配置文件里依赖注入来解决代码问题。

IOC的注入类型有几种？主要可以划分为三种：构造函数注入、属性注入和接口注入。Spring支持构造函数注入和属性注入

面向切面（AOP）

（面向切面编程，AOP其实只是OOP的补充而已，AOP基本上是通过代理机制实现的。）

我们管切入到指定类指定方法的代码片段称为切面，而切入到哪些类、哪些方法则叫切入点。有了AOP，我们就可以把几个类共有的代码，抽取到一个切片中，等到需要时再切入对象中去，从而改变其原有的行为。

我们都知道 Java 是 OOP-面向对象编程的，它有自己的优势，也有自己的不足。比如说：在我们开发中，都会有一条业务主线（即客户的需求）。而我们要做的就是实现这个主线上的需求。我们在实现这些功能的时候，经常要干一些额外的不可避免的事情，比如事务的管理，日志的记录等，就很繁杂且代码量增多，所以 Spring 提供了另一种角度来思考程序结构，也就是把这一些事情剥离出来，然后适时适地的把它们加入到我们的代码中，比如说 声明式事务管理的时候，我们在 service 层检测到save*、update*这些方法要被调用的时候，我们先进行开启事务什么的，这就是AOP，面向编程的思想。

AOP的术语：

1、通知（Advice）：就是你想要的功能，也就是上面说的 安全，事物，日志等。你给先定义好把，然后在想用的地方用一下

2、连接点（JoinPoint）：这个更好解释了，就是spring允许你使用通知的地方，那可真就多了，基本每个方法的前，后（两者都有也行），或抛出异常时都可以是连接点，spring只支持方法连接点.其他如aspectJ还可以让你在构造器或属性注入时都行，不过那不是咱关注的，只要记住，和方法有关的前前后后（抛出异常），都是连接点。

3、切入点（Pointcut）：上面说的连接点的基础上，来定义切入点，你的一个类里，有15个方法，那就有几十个连接点了对把，但是你并不想在所有方法附近都使用通知（使用叫织入，以后再说），你只想让其中的几个，在调用这几个方法之前，之后或者抛出异常时干点什么，那么就用切点来定义这几个方法，让切点来筛选连接点，选中那几个你想要的方法。

4、切面（Aspect）：切面是通知和切入点的结合。现在发现了吧，没连接点什么事情，连接点就是为了让你好理解切点，搞出来的，明白这个概念就行了。通知说明了干什么和什么时候干（什么时候通过方法名中的before,after，around等就能知道），而切入点说明了在哪干（指定到底是哪个方法），这就是一个完整的切面定义。

5、引入（introction）：允许我们向现有的类添加新方法属性。这不就是把切面（也就是新方法属性：通知定义的）用到目标类中吗

6、目标（target）：引入中所提到的目标类，也就是要被通知的对象，也就是真正的业务逻辑，他可以在毫不知情的情况下，被咱们织入切面。而自己专注于业务本身的逻辑。

7、代理（proxy）：怎么实现整套aop机制的，都是通过代理，这个一会给细说。

8、织入（weaving）：把切面应用到目标对象来创建新的代理对象的过程。有3种方式，spring采用的是运行时，为什么是运行时，后面解释。

‘肆’ 什么是AOP编程

面向切面编程(也叫面向方面)：Aspect
Oriented
Programming(AOP),是目前软件开发中的一个热点，也是Spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
AOP是OOP的延续，是（Aspect
Oriented
Programming）的缩写，意思是面向切面（方面）编程。
可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。

‘伍’ 什么是AOP面向切面编程

aspect
oriented
programming（面向切面编程），可以
通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一
添加功能的一种技术。

‘陆’ 什么是面向切面编程

Aspect Oriented Programming(AOP)，面向切面编程，是一个比较热门的话题。AOP主要实现的目的是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。比如我们最常见的就是日志记录了，举个例子，我们现在提供一个查询学生信息的服务，但是我们希望记录有谁进行了这个查询。如果按照传统的OOP的实现的话，那我们实现了一个查询学生信息的服务接口(StudentInfoService)和其实现 类 （StudentInfoServiceImpl.java），同时为了要进行记录的话，那我们在实现类(StudentInfoServiceImpl.java)中要添加其实现记录的过程。这样的话，假如我们要实现的服务有多个呢？那就要在每个实现的类都添加这些记录过程。这样做的话就会有点繁琐，而且每个实现类都与记录服务日志的行为紧耦合，违反了面向对象的规则。那么怎样才能把记录服务的行为与业务处理过程中分离出来呢？看起来好像就是查询学生的服务自己在进行，但却是背后日志记录对这些行为进行记录，并且查询学生的服务不知道存在这些记录过程，这就是我们要讨论AOP的目的所在。AOP的编程，好像就是把我们在某个方面的功能提出来与一批对象进行隔离，这样与一批对象之间降低了耦合性，可以就某个功能进行编程。

‘柒’ AOP是什么意思

AOP为Aspect
Oriented
Programming的缩写，是面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。
AOP的出现弥补了OOP的这点不足，AOP
是一个概念，一个规范，本身并没有设定具体语言的实现，AOP是基于动态代理模式。AOP是方法级别的，要测试的方法不能为static修饰，因为接口中不能存在静态方法，编译就会报错。
AOP可以分离业务代码和关注点代码（重复代码），在执行业务代码时，动态的注入关注点代码。切面就是关注点代码形成的类。Spring
AOP中的动态代理主要有两种方式，JDK动态代理和CGLIB动态代理。JDK动态代理通过反射来接收被代理的类，并且要求被代理的类必须实现一个接口。
(7)aop切面编程扩展阅读
AOP实现的关键在于AOP框架自动创建的AOP代理，AOP代理主要分为静态代理和动态代理，静态代理的代表为AspectJ。而动态代理则以Spring
AOP为代表，静态代理是编译期实现，动态代理是运行期实现，可想而知前者拥有更好的性能。
静态代理是编译阶段生成AOP代理类，也就是说生成的字节码就织入了增强后的AOP对象；动态代理则不会修改字节码，而是在内存中临时生成一个AOP对象，这个AOP对象包含了目标对象的全部方法，并且在特定的切点做了增强处理，并回调原对象的方法。
参考资料来源；搜狗网络--AOP