spring学习14（AOP面向切面编程）

1. 要使用aop编程所需要的jar:
  aspectjrt.jar
  aspectjweaver.jar
  commons-logging-1.2.jar
  spring-aop-4.3.9.RELEASE.jar
  spring-aspects-4.3.9.RELEASE.jar
  spring-beans-4.3.9.RELEASE.jar
  spring-context-4.3.9.RELEASE.jar
  spring-core-4.3.9.RELEASE.jar
  spring-expression-4.3.9.RELEASE.jar
2.在配置文件加入aop命名空间
3 把切面加入ioc容器使用@Component 注解加入spring容器使用@Aspect标识为切面
4 在切面类中声明通知如 @Before
5 访问到方法细节在通知方法加入参数JoinPoint

注解方式：

模拟计算器在加减乘除打印日志

定义一个计算器接口

package chen.spring.aop;
public interface calculate {
    int add(int i, int j);
    int sub(int i, int j);
    int mul(int i, int j);
    int div(int i, int j);
}

计算器实现类并注解方式配置为bean

package chen.spring.aop;

import org.springframework.stereotype.Component;

@Component
public class JiShuanQi implements calculate{
    @Override
    public int add(int i, int j) {
        int r=i+j;
        System.out.println( r);
        return r;
    }

    @Override
    public int sub(int i, int j) {
        int r=i-j;
        System.out.println( r);
        return r;
    }

    @Override
    public int mul(int i, int j) {
        int r=i*j;
        System.out.println( r);
        return r;
    }

    @Override
    public int div(int i, int j) {
        int r=i/j;
        System.out.println( r);
        return r;
    }
}

切面类：

package chen.spring.aop;

import java.util.Arrays;

import java.util.List;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
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.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;


//使用@Order注解指定切面右下角 越小优先级越高
@Order(1)
@Aspect
@Component
public class LogAspect {
    //定义一个方法，用于声明切入点表达式，一般这个方法不需要其他代码
    //使用@Pointcut来声明切入点
    //后面的其他通知就可以直接使用方法名来引用当前的切入点表达式
    @Pointcut("execution(public int chen.spring.aop.calculate.*(int, int))")
    public void pointcut() {}
    
    
    //声明前置前置通知：在目标方法之前
//  @Before("execution(public int chen.spring.aop.calculate.*(int, int))")
    @Before("pointcut()")//使用了切入点声明
    public void beforeLog(JoinPoint jPoint) {
        String name=jPoint.getSignature().getName();//获取方法name
        List<Object> args=Arrays.asList(jPoint.getArgs());//获取参数
        System.out.println("前置通知 方法"+name +"参数"+args);
        
    }
    
    //后置通知：在目标方法执行后（无论发生错误）
    //在后置通知中还不能访问目标方法的结果
    @After("execution(public int chen.spring.aop.calculate.*(int, int))")
    public void afterLog(JoinPoint jPoint) {
        String name=jPoint.getSignature().getName();//获取方法name
        List<Object> args=Arrays.asList(jPoint.getArgs());//获取参数
        System.out.println("后置通知 方法"+name +"参数"+args);
    }
    
    //返回通知：在方法正确执行后执行的代码
    //可以访问返回值
    @AfterReturning(value="execution(public int chen.spring.aop.calculate.*(int, int))",
            returning="result")
    public void afterReturningLog(JoinPoint jPoint,Object result) {
        String name=jPoint.getSignature().getName();//获取方法name
        List<Object> args=Arrays.asList(jPoint.getArgs());//获取参数
        System.out.println("返回通知 方法"+name +" 参数="+args+" 返回值="+result);
        
    }
    //异常通知：在方法异常后执行的代码
    //可以指定特定异常才执行
    @AfterThrowing(value="execution(public int chen.spring.aop.calculate.*(int, int))",
            throwing="ex")
    public void afterThrowingLog(JoinPoint jPoint,Exception ex) {
        String name=jPoint.getSignature().getName();//获取方法name
        System.out.println("返回通知 方法"+name +" 返回值="+ex);
    }
    
    //环绕通知:需要ProceedingJoinPoint类型的参数
    //环绕通知类似于动态代理的全程：ProceedingJoinPoint类型的参数可以决定是否执行目标方法
    //且环绕通知必须有返回值，返回值即为目标方法的返回值
    @Around("execution(public int chen.spring.aop.calculate.*(int, int))")
    public Object aroundLog(ProceedingJoinPoint point) {
        String name=point.getSignature().getName();
        System.out.println("环绕通知 方法"+name);
        Object r=null;
        try {
            //前置通知
            r=point.proceed();//执行目标方法
            //返回通知
        } catch (Throwable e) {
            //异常通知
            e.printStackTrace();
        }
            //后置通知
        return r;
    }
}


    //1 需要的jar

    /**
    aspectjrt.jar
    aspectjweaver.jar
    commons-logging-1.2.jar
    spring-aop-4.3.9.RELEASE.jar
    spring-aspects-4.3.9.RELEASE.jar
    spring-beans-4.3.9.RELEASE.jar
    spring-context-4.3.9.RELEASE.jar
    spring-core-4.3.9.RELEASE.jar
    spring-expression-4.3.9.RELEASE.jar
     * */
    
    //2 在配置文件加入aop命名空间
    
    //3 把切面加入ioc容器 使用@Component  标识为切面使用@Aspect
    
    //4 在切面类中声明通知如 @Before
    
    //5 访问到方法细节在通知方法加入参数JoinPoint

配置文件：

<?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-4.3.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
<!--配置自动扫描 -->
<context:component-scan base-package="chen.spring.aop"></context:component-scan>
<!-- 使 aspectj 注解起作用 -->
<aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>
</beans>

必须<aop:aspectj-autoproxy/>启动注解配置

通知：

前置通知：在目标方法之前使用 @Before（execution（方法的全签名））可以使用通配符

    //声明前置前置通知：在目标方法之前
    @Before("execution(public int chen.spring.aop.calculate.*(int, int))")
    public void beforeLog(JoinPoint jPoint) {
        String name=jPoint.getSignature().getName();//获取方法name
        List<Object> args=Arrays.asList(jPoint.getArgs());//获取参数
        System.out.println("前置通知 方法"+name +"参数"+args);
        
    }

后置通知：在目标方法执行后（无论发生错误）并且后置通知中还不能访问目标方法的结果

//后置通知：在目标方法执行后（无论发生错误）
    //在后置通知中还不能访问目标方法的结果
    @After("execution(public int chen.spring.aop.calculate.*(int, int))")
    public void afterLog(JoinPoint jPoint) {
        String name=jPoint.getSignature().getName();//获取方法name
        List<Object> args=Arrays.asList(jPoint.getArgs());//获取参数
        System.out.println("后置通知 方法"+name +"参数"+args);
    }

返回通知：在方法正确执行后执行的代码并且可以访问返回值

//返回通知：在方法正确执行后执行的代码
    //可以访问返回值
    @AfterReturning(value="execution(public int chen.spring.aop.calculate.*(int, int))",
            returning="result")
    public void afterReturningLog(JoinPoint jPoint,Object result) {
        String name=jPoint.getSignature().getName();//获取方法name
        List<Object> args=Arrays.asList(jPoint.getArgs());//获取参数
        System.out.println("返回通知 方法"+name +" 参数="+args+" 返回值="+result);
        
    }

异常通知：在方法异常后执行的代码可以指定特定异常才执行

    //异常通知：在方法异常后执行的代码
    //可以指定特定异常才执行
    @AfterThrowing(value="execution(public int chen.spring.aop.calculate.*(int, int))",
            throwing="ex")
    public void afterThrowingLog(JoinPoint jPoint,Exception ex) {
        String name=jPoint.getSignature().getName();//获取方法name
        System.out.println("返回通知 方法"+name +" 返回值="+ex);
    }

环绕通知环绕通知:需要ProceedingJoinPoint类型的参数环绕通知类似于动态代理的全程：ProceedingJoinPoint类型的参数可以决定是否执行目标方法且环绕通知必须有返回值，返回值即为目标方法的返回值

//环绕通知:需要ProceedingJoinPoint类型的参数
    //环绕通知类似于动态代理的全程：ProceedingJoinPoint类型的参数可以决定是否执行目标方法
    //且环绕通知必须有返回值，返回值即为目标方法的返回值
    @Around("execution(public int chen.spring.aop.calculate.*(int, int))")
    public Object aroundLog(ProceedingJoinPoint point) {
        String name=point.getSignature().getName();
        System.out.println("环绕通知 方法"+name);
        Object r=null;
        try {
            //前置通知
            r=point.proceed();//执行目标方法
            //返回通知
        } catch (Throwable e) {
            //异常通知
            e.printStackTrace();
        }
            //后置通知
        return r;
    }

定义一个方法，用于声明切入点表达式，一般这个方法不需要其他代码使用@Pointcut来声明切入点后面的其他通知就可以直接使用方法名来引用当前的切入点表达式

//定义一个方法，用于声明切入点表达式，一般这个方法不需要其他代码
    //使用@Pointcut来声明切入点
    //后面的其他通知就可以直接使用方法名来引用当前的切入点表达式
    @Pointcut("execution(public int chen.spring.aop.calculate.*(int, int))")
    public void pointcut() {}

    //声明前置前置通知：在目标方法之前
    @Before("pointcut()")//使用了切入点声明
    public void beforeLog(JoinPoint jPoint) {
        String name=jPoint.getSignature().getName();//获取方法name
        List<Object> args=Arrays.asList(jPoint.getArgs());//获取参数
        System.out.println("前置通知 方法"+name +"参数"+args);
        
    }

配置文件方式：

<?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"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
    <!-- 配置bean -->
    <bean id="jsq" class="chen.spring.aop.JiShuanQi"></bean>
    <!-- 配置切面bean -->
    <bean id="aspect" class="chen.spring.aop.LogAspect"></bean>
    <!-- 配置AOP -->
    <aop:config>
        <!-- 配置切点表达式 -->
        <aop:pointcut
            expression="execution(public int chen.spring.aop.calculate.*(int, int))"
            id="pointcut" />
        <!-- 配置切面 -->
        <aop:aspect ref="aspect" order="1">
            <!-- 配置切面通知 -->
            <aop:before method="afterLog" pointcut-ref="pointcut" />
            <aop:after method="afterLog" pointcut-ref="pointcut" />
        </aop:aspect>
    </aop:config>

</beans>

1.配置bean
2.配置切面bean
3.配置AOP
1）配置切点表达式切点
2）配置切面关联切面bean
3）在切面配置中配置切面通知以及通知对应的方法

总结：

切面类要加入spring容器并使用@Aspect标识 spring就可以自动识别装配
当目标类方法拥有多个切面时可以在切面类使用@Order（数值）注解数值越小优先级越高（切面优先级）
切面原理动态代理
各个通知可以有相应的参数也可以获取相应的数据
切点：需要介入的目标方法切面：处理对应的类通知：介入目标方法的介入方法

最后编辑于：2017.12.09 16:55:11

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 213,099评论 6赞 492
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 90,828评论 3赞 387
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 158,540评论 0赞 348
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 56,848评论 1赞 285
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 65,971评论 6赞 385
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 50,132评论 1赞 291
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 39,193评论 3赞 412
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 37,934评论 0赞 268
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 44,376评论 1赞 303
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 36,687评论 2赞 327
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 38,846评论 1赞 341
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 34,537评论 4赞 335
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 40,175评论 3赞 317
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,887评论 0赞 21
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,134评论 1赞 267
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 46,674评论 2赞 362
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 43,741评论 2赞 351

spring学习14（AOP面向切面编程）

注解方式：

切面类：

通知：

配置文件方式：

总结：

推荐阅读更多精彩内容