关闭

Spring全家桶(八)AOP核心思想与AspectJ 5种类型通知

标签: springaopAspectjAspect
1185人阅读 评论(0) 收藏 举报
分类:

一、AOP核心思想

AOP是Aspect-Oriented Programming的缩写,翻译为面向切面编程。我个人理解切面就是一个方面。
例子,一个接口里面有增删改查四个方法:

package com.stuspring.aop.impl;

/**
 * Created by bee on 17/5/15.
 */
public interface ArithmeticCalculator {
     int add(int i,int j);
     int sub(int i,int j);
     int mul(int i,int j);
     int div(int i,int j);
}

实现类:

package com.stuspring.aop.impl;

import org.springframework.stereotype.Component;

/**
 * Created by bee on 17/5/15.
 */
@Component("arithmeticCalculator")
public class ArithmeticCalculatorImpl implements ArithmeticCalculator {
    @Override
    public int add(int i, int j) {
        int result=i+j;
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result=i-j;
        return result;
    }

    @Override
    public int mul(int i, int j) {
        int result=i*j;
        return result;
    }

    @Override
    public int div(int i, int j) {
        int result=i/j;
        return result;
    }
}

如果想给这四个方法分别加上前置日志功能,以其中一个为例,add方法变这样:

  @Override
    public int add(int i, int j) {
        System.out.println("The method add begins with " +i+","+j);
        int result=i+j;
        return result;
    }

手动给每个方法都加上固然可行,但是维护起来过于麻烦,面向切面编程就是为了解决这一问题。AOP的好处就是每个逻辑位于一个位置,代码不分散便于维护和升级,业务模块更简洁。

加一个日志切面:

package com.stuspring.aop.impl;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.List;

/**
 * Created by bee on 17/5/15.
 */

@Aspect
@Component
public class LoggingAspect {

    /**
     * 前置通知 方法开始之前执行
     * @param joinPoint
     */
    @Before("execution(public int com.stuspring.aop.impl.ArithmeticCalculatorImpl.*(int,int))")
    public void beforeMethod(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        List<Object> agrs = Arrays.asList(joinPoint.getArgs());
        System.out.println("The method " + methodName + " begins with " + agrs);
    }

    /**
     * 后置通知,方法执行完之后执行,不论方法是否出现异常
     * 后置通知中不能访问目标方法的执行结果
     */
    @After("execution(public int com.stuspring.aop.impl.ArithmeticCalculatorImpl.*(int,int))")
    public void afterMethod(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("The method " + methodName + " ends with " + args);
    }
}

新建spring配置文件beans-aspect.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"
       xmlns:content="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/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">

    <content:component-scan base-package="com.stuspring.aop.impl"/>
    <aop:aspectj-autoproxy/>
</beans>

附maven依赖:

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.8.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.3.8.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>4.3.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>4.3.8.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.8.10</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.10</version>
        </dependency>

二、五种类型通知

  1. @Before前置通知:方法开始之前执行。

     /**
         * 前置通知 方法开始之前执行
         * @param joinPoint
         */
        @Before("execution(public int com.stuspring.aop.impl.ArithmeticCalculatorImpl.*(int,int))")
        public void beforeMethod(JoinPoint joinPoint) {
            String methodName = joinPoint.getSignature().getName();
            List<Object> agrs = Arrays.asList(joinPoint.getArgs());
            System.out.println("The method " + methodName + " begins with " + agrs);
        }
  2. @After后置通知:方法开始之后执行,不论方法是否出现异常。

       /**
         * 后置通知,方法执行完之后执行,不论方法是否出现异常
         * 后置通知中不能访问目标方法的执行结果
         */
        @After("execution(public int com.stuspring.aop.impl.ArithmeticCalculatorImpl.*(int,int))")
        public void afterMethod(JoinPoint joinPoint) {
            String methodName = joinPoint.getSignature().getName();
            List<Object> args = Arrays.asList(joinPoint.getArgs());
            System.out.println("The method " + methodName + " ends with " + args);
        }
  3. @AfterRunning:返回通知,在方法返回结果之后执行。

        /**
         * 返回通知,在方法正常结束之后执行的代码
         * 返回通知可以访问方法的返回值
         */
    
        @AfterReturning(value="execution(public int com.stuspring.aop.impl.ArithmeticCalculatorImpl.*(int,int))",returning = "result")
        public void afterReturning(JoinPoint joinPoint,Object result){
    
            String methodName=joinPoint.getSignature().getName();
            System.out.println("The method "+methodName+" ends with "+result);
        }
  4. @AfterThrowing:异常通知,在方法抛出异常之后。

        /**
         * 异常通知:在方法抛出异常之后执行
         * @param joinPoint
         * @param e
         */
    
        @AfterThrowing(value="execution(public int com.stuspring.aop.impl.ArithmeticCalculatorImpl.*(int,int))",throwing = "e")
        public void afterThrowing(JoinPoint joinPoint,Exception e){
            String methodName=joinPoint.getSignature().getName();
            System.out.println("The method "+methodName+" occurs execution: "+e);
        }
  5. @Around:环绕通知,围绕方法执行。

        /**
         * 环绕通知需要携带ProceedingJoinPoint类型的参数
         * 环绕通知类似于动态代理的全过程:ProceedingJoinPoint类型的参数可以决定是否执行目标方法
         * 环绕通知必须有返回值,返回值即为目标方法的返回值
         *
         * @param pjd
         */
        @Around("execution(public int com.stuspring.aop.impl.ArithmeticCalculatorImpl.*(..))")
        public Object aroundMethod(ProceedingJoinPoint pjd) {
    
            Object result = null;
            String methodName = pjd.getSignature().getName();
    
            try {
                //前置通知
                System.out.println("--->The method " + methodName + " begins with " + Arrays.asList(pjd.getArgs()));
                //执行目标方法
                result = pjd.proceed();
                //后置通知
                System.out.println("--->The method " + methodName + " ends with " + result);
    
            } catch (Throwable e) {
                //异常通知
                System.out.println("The method "+methodName+" occurs exception : "+e);
            }
    
            //后置通知
            System.out.println("The Method "+methodName+" ends!");
            return result;
        }

三、指定切面的优先级

切面的优先级可以用@Order注解指定,传入的整数值越小,优先级越高。
这里写图片描述

四、复用切点表达式

   /**
     *  定义一个方法用于声明切入点表达式。一般地,该方法不需要再写其它代码。
     */
    @Pointcut("execution(public int com.stuspring.aop.impl.ArithmeticCalculatorImpl.*(int,int))")
    public void declareJoinPointExpression(){
    }
    /**
     * 前置通知 方法开始之前执行
     * @param joinPoint
     */

    @Before("declareJoinPointExpression()")
    public void beforeMethod(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        List<Object> agrs = Arrays.asList(joinPoint.getArgs());
        System.out.println("The method " + methodName + " begins with " + agrs);
    }

外部类引用可以使用报名加方法名的方法。

五、配置文件方式配置AOP

接口:

package com.stuspring.aop.fileimpl;

/**
 * Created by bee on 17/5/16.
 */
public interface ArithmeticCalculator {
    int add(int i,int j);
    int sub(int i,int j);
    int mul(int i,int j);
    int div(int i,int j);
}

实现类:

package com.stuspring.aop.fileimpl;

/**
 * Created by bee on 17/5/16.
 */
public class ArithmeticCalculatorImpl implements ArithmeticCalculator {
    @Override
    public int add(int i, int j) {
        int result=i+j;
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result=i-j;
        return result;
    }

    @Override
    public int mul(int i, int j) {
        int result=i*j;
        return result;
    }

    @Override
    public int div(int i, int j) {
        int result=i/j;
        return result;
    }
}

日志切面:

package com.stuspring.aop.fileimpl;

import org.aspectj.lang.JoinPoint;

/**
 * Created by bee on 17/5/16.
 */
public class LoggingAspect {

    public void beforeMethod(JoinPoint joinPoint){
        String methodName=joinPoint.getSignature().getName();
        System.out.println("The method begins with "+methodName);
    }
}

参数验证切面:

package com.stuspring.aop.fileimpl;

import org.aspectj.lang.JoinPoint;

/**
 * Created by bee on 17/5/16.
 */
public class ValidationAspect {

    public void validateArgs(JoinPoint joinPoint){
        System.out.println("validationMethod......");
    }
}

Spring配置文件:

<?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
       http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

    <!--配置bean-->
    <bean id="arithmeticCalculator" class="com.stuspring.aop.fileimpl.ArithmeticCalculatorImpl"/>
    <bean id="loggingAspect" class="com.stuspring.aop.fileimpl.LoggingAspect"/>
    <bean id="validationAspect" class="com.stuspring.aop.fileimpl.ValidationAspect"/>

    <aop:config>
        <!--配置切面表达式-->
        <aop:pointcut id="pointcut" expression="execution(public int com.stuspring.aop.fileimpl.ArithmeticCalculatorImpl.*(int,int))"/>
        <!--配置切面通知-->
        <aop:aspect ref="loggingAspect" order="2">
            <aop:before method="beforeMethod" pointcut-ref="pointcut"/>
        </aop:aspect>

        <aop:aspect ref="validationAspect" order="1">
            <aop:before method="validateArgs" pointcut-ref="pointcut"/>
        </aop:aspect>

    </aop:config>
</beans>

Main测试方法:

package com.stuspring.aop.fileimpl;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Created by bee on 17/5/16.
 */
public class Main {

    public static void main(String[] args) {
        ApplicationContext ctx=new ClassPathXmlApplicationContext("beans-aspectfile.xml");
        ArithmeticCalculator calculator= (ArithmeticCalculator) ctx.getBean("arithmeticCalculator");
        System.out.println(calculator.add(2,4));
    }
}
2
0
查看评论

转载的spring cloud的全家桶,有空学习下

Spring Cloud Config:配置管理开发工具包,可以让你把配置放到远程服务器,目前支持本地存储、Git以及Subversion。  Spring Cloud Bus:事件、消息总线,用于在集群(例如,配置变化事件)中传播状态变化,可与Spring Cloud Config联合实现热部署...
  • ivan0609
  • ivan0609
  • 2017-06-22 14:55
  • 1407

c++的点点滴滴(1)----关于枚举

关于枚举(转载) 至从C语言开始enum类型就被作为用户自定义分类有限集合常量的方法被引入到了语言当中,而且一度成为C++中定义编译期常量的唯一方法(后来在类中引入了静态整型常量)。 根据上面对enum类型的描述,有以下几个问题: 1.到底enum所定义出来的类型是一个什么样的类型呢?...
  • liuxincumt
  • liuxincumt
  • 2011-11-16 19:33
  • 268

Spring全家桶(二)Bean之间的关系、自动装配、作用域和使用外部文件

五、Bean的自动装配Spring IOC容器可以自动装配Bean,需要在bean的autowire属性里指定自动装配的模式。<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="...
  • napoay
  • napoay
  • 2017-05-16 11:25
  • 1144

Spring全家桶(九)Spring JdbcTemplate

一、Spring JDBCSpring JDBC是在JDBC API的基础上定义一个抽象层,用以简化JDBC操作。Spring JdbcTemplate是Spring JDBC框架的核心,为不同类型的JDBC操作提供模板方法,每个模板方法都能控制整个过程,并允许覆盖过程中的特定任务。基于此,可以在保...
  • napoay
  • napoay
  • 2017-05-31 13:24
  • 1896

Spring Cloud全家桶主要组件及简要介绍

一、微服务简介微服务是最近的一两年的时间里是很火的一个概念。感觉不学习一下都快跟不上时代的步伐了,下边做一下简单的总结和介绍。何为微服务?简而言之,微服务架构风格这种开发方法,是以开发一组小型服务的方式来开发一个独立的应用系统的。其中每个小型服务都运行在自己的进程中,并经常采用HTTP资源API这样...
  • u010870518
  • u010870518
  • 2017-09-01 17:30
  • 10479

spring全家桶+redis+nginx+activeq+solr商城项目

  • 2017-11-21 17:19
  • 48B
  • 下载

spring学习笔记(3)-aspectj的五种通知方法

aspectj的五种通知方法 1.@Before前置通知,在方法执行之前执行 2.@After后置通知,在方法执行之后执行 3.@AfterReturning返回通知,在方法返回结果之后返回,可以访问方法的返回值,进行操作,例如写日志 4.@AfterThrowing异常通知,关联的方法若抛...
  • qq_29346449
  • qq_29346449
  • 2016-04-04 22:50
  • 1159

Spring全家桶(一)HelloWorld与入门基础

Spring学习笔记一:理解Spring特点、IOC和DI以及入门例子
  • napoay
  • napoay
  • 2017-05-16 11:23
  • 2758

Spring全家桶(三)Spring SpEL

九、SpELSpEL是Spring表达式语言(Spring Expression Language)的简称,是一个支持运行查询和操作对象图的强大的表达式语言。SpEL的语法类似EL,SpEL使用#{}作为界定符,所有在大括号内的字符都将被认为是SpEL。SpEL为bean的属性进行动态赋值提供便利。...
  • napoay
  • napoay
  • 2017-05-16 11:27
  • 936

Spring AOP的五种通知类型

Spring AOP通知(advice)分成五类: 前置通知[Before advice]:在连接点前面执行,前置通知不会影响连接点的执行,除非此处抛出异常。 正常返回通知[After returning advice]:在连接点正常执行完成后执行,如果连接点抛出异常,则不会执行。 异常...
  • sinat_32689811
  • sinat_32689811
  • 2017-03-28 22:20
  • 322
    《从Lucene到Elasticsearch:全文检索实战》
    Lucene、ES、ELK开发交流群:370734940
    Lucene、ES、ELK开发交流
    个人资料
    • 访问:935743次
    • 积分:9246
    • 等级:
    • 排名:第2379名
    • 原创:209篇
    • 转载:2篇
    • 译文:6篇
    • 评论:468条
    StackOverFlow
    http://stackoverflow.com/users/6526424
    统计
    博客专栏
    文章分类
    最新评论