AOP面向切面编程
（1）程序更改中，增加功能，导致的问题
在源代码中，业务方法中增加功能
1.源代码可能改动比较多，
2.重复代码比较多
3.代码难以维护
AOP概念
什么是AOP（aspect orient programing），
面向切面编程
Aspect：表示切面，给业务方法增加的功能，叫做切面，切面一般是非业务功能，而且切面的功能一般都是复用的，如日志功能，事物功能，权限检查，参数检查，统计信息，
orient ：面向
programming：编程
怎么理解面向切面编程呢，
1.设计项目时，找出切面的功能
2.安排切面的执行时间，执行的位置
AOP的作用
1.让切面功能复用
2.让开发人员专注业务逻辑，提高开发效率
3.实现业务功能和其他业务的解耦合，
AOP中的术语
1.aspect：切面，给业务方法增加的功能
2.joinpoint：连接点，连接切面的业务方法执行时，同时会执行切面的功能。
3.pointcut：切入点，是一个或多个连接点的集合，表示，这些方法执行时，都能增加切面的功能，表示切面的位置。
4.target：目标对象，给哪个对象增加切面的功能，这个对象就是目标对象，
5.advice：通知（增强），表示切面执行时间，在目标方法执行之前执行切面，这还是目标方法之后执行切面，AOP中重要的三个要素，aspect，pointcut，advice，这个概念的理解是：在advice的时间，在pointcut的位置，执行aspect，
AOP是一个动态的思想，在程序运行期间，创建代理（serviceproxy），使用代理执行方法时，增加切面的功能，这个代理对象时存在内存中的
什么时候使用AOP
你想要给某些方法，增加相同的一些功能，源代码不能或者不容易更改，给业务方法增加一些非业务功能时，可以使用AOP
AOP技术思想的实现
使用框架实现AOP,实现AOP功能的框架有很多，有名的有两个，
1.spring：spring框架实现AOP思想中的部分功能，spring框架实现时操作繁重，
2.aspectj：独立的框架，专门是AOP、，属于eclipse，
使用AspectJ框架实现AOP
AspectJ框架可以使用注解和xm配置文件方式实现AOP
1.aspectJ表示切面执行时间，用的通知，（advice），这个通知可以使用注解表示
将五个注解，表示切面的五个执行时间，这些注解叫做通知注解，
@befor：前置通知
@afterretunring:后置通知
@around：环绕通知
@afterthrowing：异常通知
@after:最终通知
pointcut：用来表示切面执行的位置，使用aspectJ中切入点表达式，
切入点表达式语法：execution(访问权限 方法返回值 方法声明（参数）异常类型)
前置通知@before
package com.service.handle;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Before;
import java.util.Date;
/***
* @asspect:切面类的注解
* 位置：在某个类的上面
* 作用：表示当前类是切面类
* 切面类：表示切面功能的类
*
*/
public class MyAspect {
//定义方法，表示切面的具体方法
/**
* 前置通知方法的定义
* 方法是public
* 方法是void
* 方法名称自定义
* 方法可以有参，如果是joinpoint
* 也可以没有
*/
/**
* @befor：前置通知
* 属性：value切点表达式，表示切面上的执行位置，在这个方法收同时会执行功能
* 位置：方法的上面
* 特点，目标方法之前执行，
* 不会影响目标的执行，
* 不会修改目标方法的执行结果
*/
/* @Before(value = "execution(public void com.service.impl.SomeServiceImpl.doSome(String,Integer))")
public void myBefor(){
//切面类的功能
System.out.println("前置通知：切面的功能，在目标方法执行前执行："+ new Date());
}*/
/**
* 切面类中的通知方法，可以有参数，
* joinpoint必须是他
*
* joinpoint：表示正在执行的业务方法，相当于反射中method
* 使用要求：必须是参数列表的第一个
* 作用是获取方法执行时的信息，例如方法名称，方法的参数集合
*/
@Before(value = "execution(* *..SomeServiceImpl.do*(..))")
public void myBefore(){
System.out.println("前置通知："+new Date());
}
@Before(value = "execution(* *..SomeServiceImpl.do*(..))")
public void myBefore01(JoinPoint joinPoint){
//获取方法的定义
System.out.println("前置通知中"+joinPoint.getSignature());
System.out.println("前置通知中，获取方法名称="+joinPoint.getSignature().getName());
//获取方法执行时的参数
Object args[]=joinPoint.getArgs();
for (Object x:args){
System.out.println("前置通知，获取参数"+x);
}
System.out.println("前置通知："+new Date());
}
}
applicationContxt.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: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/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
<!--声明对象-->
<bean id="someService" class="com.service.impl.SomeServiceImpl"/>
<!--声明切面类对象-->
<bean id="myAspect" class="com.service.handle.MyAspect"/>
<!--声明自动代理生成器：目的是创建目标对象的代理（就是javaspringAOP02项目中Serviceproxy）
调用aspectJ框架中的功能，寻找spring容器中的所有目标对象
把每个目标对象加入切面类中的功能，生成代理
这个代理对象是修改的内存中的目标对象，这个目标对象就是代理对象（serviceproxy）
-->
<aop:aspectj-autoproxy/>
</beans>
后置通知@afterreturning
package com.service.handle;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
import java.util.Date;
/***
* @asspect:切面类的注解
* 位置：在某个类的上面
* 作用：表示当前类是切面类
* 切面类：表示切面功能的类
*
*/
@Aspect
@Component
public class MyAspect {
//定义方法，表示切面的具体方法
/**
* 后置通知方法的定义
* 方法是public
* 方法是void
* 方法名称自定义
* 方法有参数，推荐使用object类型
*/
/**
* @Afterreturning：后置通知
* 属性：value 切入点表达式
* returning 自定义的变量，表示目标方法的返回值的
* 自定义的变量名必须和通知方法的形参一样
* 位置“在方法的上面
* 特点：
* 1.在目标方法之后执行的
* 2.能获取到目标方法的执行结果
* 3.不会影响目标方法的执行
*
* 方法的形参：
* object res：表示目标方法的返回值，使用res接受doOther的调用结果
* object res=dother（）
* 后置通知的执行顺序
* object res=SomeServiceImpl.doOther(..);student
*
* myAfterReturning（res）;
*/
@AfterReturning(value = "execution(* *..SomeServiceImpl.doOther(..))",returning = "res")
public void myAfterreturning(Object res){
System.out.println("这是一个后置通知，在目标方法之后"+res);
if ("ABC".equals(res)) {
//这是一个增强功能
System.out.println("输出判断。");
}
}
//也可以加一个参数是joinpoint，但是joinpoint必须是第一个参数
@AfterReturning(value = "execution(* *..SomeServiceImpl.doOther(..))",returning = "res")
public void myAfterreturning02(JoinPoint joinPoint,Object res){
System.out.println("这是一个后置通知，在目标方法之后"+res);
if ("ABC".equals(res)) {
//这是一个增强功能
System.out.println("输出判断。");
}
}
}
环绕通知@around
@Around（value=“切入点的表达式”）
功能最强
其增强方法有proceedingjoinpoint参数，
在目标方法执行之后，被注解为环绕增强的方法要有返回值，object类型，并且方法可以包含一个proceedingjoinpoint类型的参数，接口proceedingjoinpoint其有一个proceed（）方法，用于执行目标方法，若目标方法有返回值，则该方法返回值就是目标方法的返回值，最后，环绕增强方法将其返回值返回，其增强方法实际上就是拦截了目标方法的执行
package com.service.handle;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
import java.util.Date;
/***
* @asspect:切面类的注解
* 位置：在某个类的上面
* 作用：表示当前类是切面类
* 切面类：表示切面功能的类
*
*/
@Aspect
@Component
public class MyAspect {
//定义方法，表示切面的具体方法
/**
* 后置通知方法的定义
* 方法是public
* 方法是必须有返回值，推荐使用object类型1
* 方法名称自定义
* 方法必须有proceedingjoinpoint参数
*/
/***
* @around：环绕通知
* 属性：value：切入点表达式
* 位置：在方法的上面
*
* 返回值：object，表示调用方法希望得到执行结果（不一定是目标方法自己的返回值）
* 参数：proceedingjoinpoint，相当于反射中Method（）
* 作用：执行目标方法的。等于method。invoke（）
*/
@Around(value = "execution(* *..SomeServiceImpl.doFirst(..))")
public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("执行了环绕通知的方法");
String name="";
Object args [] =proceedingJoinPoint.getArgs();
if (args!=null&&args.length>0){
Object arg=args[0];
if (args!=null){
name = (String) arg;
}
}
Object methodReturn=null;
System.out.println("执行了环绕通知，在目标方法之前，输出日志时间："+new Date());
/**
* 执行目标方法 proceedingjoinpoint，表示dofirst
*/
if ("小王".equals(name)) {
proceedingJoinPoint.proceed();//method.invoke(),表示执行doFirst（）方法本身
}
proceedingJoinPoint.proceed();//method.invoke(),表示执行doFirst（）方法本身
if (methodReturn!=null){
methodReturn="环绕通知中修改目标方法原来的执行结果";
}
System.out.println("执行了环绕通知，在目标方法之后，增加了事务提交功能，输出日志时间："+new Date());
return methodReturn;
}
}
异常通知@afterthrowing
语法@afterthrowing(value=“切入点表达式”，throwing=“自定义变量”)
package com.service.handle;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
import java.util.Date;
/***
* @asspect:切面类的注解
* 位置：在某个类的上面
* 作用：表示当前类是切面类
* 切面类：表示切面功能的类
*
*/
@Aspect
@Component
public class MyAspect {
//定义方法，表示切面的具体方法
/**
* 后置通知方法的定义
* 方法是public
* 方法没有返回值，
* 方法名称自定义
* 方法参数是Exception
*/
/**
* @Afterthrowing：异常通知
* 属性：value 切入点表达式，
* throwing 自定义变量，表示目标方法抛出的异常
* 变量名必须和通知方法一致
* 位置：在方法的上面，
* 特点：
* 1.在目标方法抛出异常后执行，没有异常时不执行
* 2.获取目标的异常信息
* 3.不是异常处理程序，可以得到发生异常的通知，可以发送邮件，短息通知开发人员，
* 看作是目标方法的监控程序
*
* 异常通知的执行
* try{
* omeerviceImplmpl。doSecond（）
* }catch{
* myAfterthrowing（e）
* }
*/
@AfterThrowing(value = "execution(* *..SomeServiceImpl.doSecond(..))",throwing = "ex")
public void myAfterthrowing(Exception ex){
System.out.println("异常出现，异常信息:"+ex.getMessage());
}
}
@After最终通知
语法：@After（value=“切入点表达式”）
package com.service.handle;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
/***
- @asspect:切面类的注解
- 位置：在某个类的上面
- 作用：表示当前类是切面类
- 切面类：表示切面功能的类
/
@Aspect
@Component
public class MyAspect {
//定义方法，表示切面的具体方法
/*
* 后置通知方法的定义
* 方法是public
* 方法没有返回值，
* 方法名称自定义
* 没有参数
/
/*
* @after：最终通知
* 属性：value 切入点表达式
* 位置：方法的上面
* 特点
* 1.目标方法后执行
* 2.总会被执行
* 3.可以用来做程序最后的收尾工作，例如清除临时变量
* 特点
* 最终通知一定会被执行
* try{
* omeServiceImpl.doThird(…)
* }finally{
* myafter()
* }
*
/
@After(value = "execution( *…SomeServiceImpl.doThird(…))")
public void myAfter(){
System.out.println(“最终通知，总会被执行”);
}
}
@pointcut定义切入点
当较多的通知方法使用相同的execution切入点表达式时，编写，维护均比较麻烦，该注解用于定义execution切入点表达式
其用法是，将@pointcut注解在一个方法上，以后所有的execution的value值均可使用该方法名作为切入点，代表的就是@pointcut定义的切入点，使用这个方法一般使用private的标识方法，即没有实际作用的方法
/**
* @point:定义和管理切入点，不是通知注解
* 属性：value 切入点表达式
* 位置：一个自定义的方法上面，这个方法是看作切入点表达式的别名
* 其他的通知注解中，可以使用方法名称，就表示使用这个切入点表达式了
*
*/
/**
* 为下面这个方法添加通知时
* 注解可以在这样写 @After(value="mypt()")
*/
@Pointcut("execution(* *..MyAspect.mypt(..))")
public void mypt(){
System.out.println("我的方法");
}
AOP总结
AOP是一种动态的技术思想，目的是实现业务功能和非业务功能的解耦合，业务功能是独立模块，其他功能也是独立模块，例如事物功能，日志等，让这些事物，日志功能能被复用
当目标方法需要一些功能时，可以在不想修改源代码的情况下，调用AOP技术在程序执行期间，生成代理对象。通过代理执行业务的方法，通知增加功能。
AOP作业
spring-AOP作业：使用AOP做方法的参数检查
要求对一个三个数相加的方法实现
1.当addNumber方法的参数不为null
2.当addNumber的参数大于0时才能执行addnumber方法计算三数的和
3.如果任意一个参数是 null，或者 小于0时，使返回结果为-1
4.使用AOP做参数检查
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
