Spring面向切面编程AOP详情

目录
  • 1. 面向切面编程
  • 2. AOP核心概念
  • 3. AOP的实现
  • 4. Spring 对AOP支持
    • 4.1 支持@Aspect
    • 4.2 声明一个切面
    • 4.3 声明一个切入点
    • 4.4 声明增强
  • 5. 用AOP实现日志拦截
    • 5.1 一般的实现
    • 5.2 仅拦截需要的方法
    • 5.3 requestId传递
    • 5.4 关于增强执行的顺序
  • 6. 思考

1. 面向切面编程

  • 定义:面向切面编程(AOP,Aspect Oriented Programming)是通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。
  • 作用:利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。
  • 主要功能:日志记录、性能统计、安全控制、事务处理、异常处理等。
  • 总结:面向切面编程是希望能够将通用需求功能从不相关的类当中分离出来,能够使得很多类共享一个行为,一旦发生变化,不必修改很多类,而只是修改这个行为即可。

AOP通过提供另一种思考程序结构的方式来补充了面向对象编程(OOP)。OOP中模块化的基本单元是类(class),而AOP中模块化的基本单元是切面(aspect)。可以这么理解,OOP是解决了纵向的代码复用问题,AOP是解决了横向的代码复用问题。

Spring的关键组件之一是AOP框架。虽然Spring IOC容器不依赖于AOP,意味着如果你不想使用AOP,则可以不使用AOP,但AOP补充了Spring IOC以提供一个非常强大的中间件解决方案。

2. AOP核心概念

  • 切面(aspect):在AOP中,切面一般使用@Aspect注解来标识。
  • 连接点(Join Point):在Spring AOP,一个连接点总是代表一次方法的执行。
  • 增强(Advice):在连接点执行的动作。
  • 切入点(Pointcout):说明如何匹配到连接点。引
  • 介(Introduction):为现有类型声明额外的方法和属性。
  • 目标对象(Target Object):由一个或者多个切面建议的对象,也被称为“建议对象”,由于Spring AOP是通过动态代理来实现的,这个对象永远是一个代理对象。
  • AOP代理(AOP proxy):一个被AOP框架创建的对象,用于实现切面约定(增强方法的执行等)。在Spring Framework中,一个AOP代理是一个JDK动态代理或者CGLIB代理。
  • 织入(Weaving):连接切面和目标对象或类型创建代理对象的过程。它能在编译时(例如使用AspectJ编译器)、加载时或者运行时完成。Spring AOP与其他的纯Java AOP框架一样是在运行时进行织入的。

Spring AOP包括以下类型的增强:

  • 前置增强(Before advice):在连接点之前运行,但不能阻止到连接点的流程继续执行(除非抛出异常)
  • 返回增强(After returning advice):在连接点正常完成后运行的增强(例如,方法返回没有抛出异常)
  • 异常增强(After thorwing advice):如果方法抛出异常退出需要执行的增强
  • 后置增强(After (finally) Advice):无论连接点是正常或者异常退出,都会执行该增强
  • 环绕增强(Around advice):围绕连接点的增强,例如方法的调用。环绕增强能在方法的调用之前和调用之后自定义行为。它还可以选择方法是继续执行或者去缩短方法的执行通过返回自己的值或者抛出异常。

3. AOP的实现

AOP的两种实现方式:静态织入(以AspectJ为代表)和动态代理(Spring AOP实现)

AspectJ是一个采用Java实现的AOP框架,它能够对代码进行编译(在编译期进行),让代码具有AspectJ的AOP功能,当然它也可支持动态代理的方式;

Spring AOP实现:通过动态代理技术来实现,Spring2.0集成了AspectJ,主要用于PointCut的解析和匹配,底层的技术还是使用的Spring1.x中的动态代理来实现。

Spring AOP采用了两种混合的实现方式:JDK动态代理和CGLib动态代理。

JDK动态代理:Spring AOP的首选方法。每当目标对象实现一个接口时,就会使用JDK动态代理。目标对象必须实现接口。

CGLIB:如果目标对象没有实现接口,则可以使用CGLIB代理。

4. Spring 对AOP支持

Spring可以使用两种方式来实现AOP:基于注解式配置和基于XML配置

下面介绍基于注解配置的形式

4.1 支持@Aspect

如果是Spring Framework,需要使用aspectjweaver.jar包,然后创建我们自己的AppConfig,如下,并加上@EnableAspectJAutoProxy注解开启AOP代理自动配置(Spring Boot默认是开启的,则不需要增加配置),

如下:

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {

}

4.2 声明一个切面

@Aspect //告诉Spring 这是一个切面
@Component  //交给Spring容器管理
public class MyAspect {

}

可以使用@Aspect来定义一个类作为切面,但是这样,该类并不会自动被Spring加载,还是需要加上@Component注解

4.3 声明一个切入点

一个切入点的生命包含两个部分:一个包含名称和任何参数的签名和一个切入点的表达式,这个表达式确定了我们对哪些方法的执行感兴趣。

我们以拦截Controller层中的MyController中的test方法为例子,代码如下:

@RestController
@RequestMapping("/my")
public class MyController {

    @GetMapping("/test")
    public void test() {
        System.out.println("test 方法");
    }
}

下面定义一个名为controller的切入点,该切入点与上述的test方法相匹配,切入点需要用@Pointcut注解来标注,如下:

  //表达式
  @Pointcut("execution (public * com.yc.springboot.controller.MyController.test())")
  public void controller(){}; //签名

切入点表达式的格式如下:

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?)
execution(方法修饰符(可选) 返回类型 类路径 方法名 参数 异常模式(可选))

AspectJ描述符如下:

AspectJ描述符 描述
arg() 限制连接点匹配参数为指定类型的执行方法
@args() 限制连接点匹配参数由指定注解标注的执行方法
execution() 用于匹配是连接点的执行方法
this() 限制连接点匹配的AOP代理的bean引用为指定类型的类
target 限制连接点匹配目标对象为指定类型的类
@target() 限制连接点匹配特定的执行对象,这些对象对应的类要具有指定类型的注解
within() 限制连接点匹配指定的类型
@within() 限制连接点匹配指定注解所标注的类型
@annotationn 限定匹配带有指定注解的连接点

常用的主要是:execution()

AspectJ类型匹配的通配符:

within() 限制连接点匹配指定的类型
@within() 限制连接点匹配指定注解所标注的类型
@annotationn 限定匹配带有指定注解的连接点

常用的匹配规则:

表达式 内容
execution(public * *(..))   匹配所有public方法
execution(* set*(..)) 匹配所有方法名开头为set的方法
execution(* com.xyz.service.AccountService.*(..)) 匹配AccountService下的所有方
execution(* com.xyz.service.*.*(..)) 匹配service包下的所有方法
execution(* com.xyz.service..*.*(..)) 匹配service包或其子包下的所有方法
@annotation(org.springframework.transaction.annotation.Transactional) 匹配所有打了@Transactional注解的方法
bean(*Service) 匹配命名后缀为Service的类的方法

4.4 声明增强

增强与切点表达式相关联,并且在与切点匹配的方法之前、之后或者前后执行。

在3当中已经对各类增强做了绍,这里就不详细展开了,下面直接罗列了各种增强的声明,用于拦截MyController中的各个方法

@Aspect //告诉Spring 这是一个切面
@Component  //告诉Spring容器需要管理该对象
public class MyAspect {

    //通过规则确定哪些方法是需要增强的
    @Pointcut("execution (public * com.yc.springboot.controller.MyController.*(..))")
    public void controller() {
    }

    //前置增强
    @Before("controller()")
    public void before(JoinPoint joinPoint) {
        System.out.println("before advice");
    }

    //返回增强
    @AfterReturning(
            pointcut = "controller()",
            returning = "retVal"
    )
    public void afterReturning(Object retVal) {
        System.out.println("after returning advice, 返回结果 retVal:" + retVal);
    }

    //异常增强
    @AfterThrowing(
            pointcut = "controller()",
            throwing = "ex"
    )
    public void afterThrowing(Exception ex) {
        System.out.println("after throwing advice, 异常 ex:" + ex.getMessage());
    }

    //后置增强
    @After("controller()")
    public void after(JoinPoint joinPoint) {
        System.out.println("after advice");
    }

    //环绕增强
    @Around("controller()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("before advice");
        //相当于是before advice
        Object reVal = null;
        try {
            reVal = joinPoint.proceed();
        } catch (Exception e) {
            //相当于afterthrowing advice
            System.out.println("afterthrowing advice");
        }
        //相当于是after advice
        System.out.println("after advice");
        return reVal;
    }
}

需要注意的是:

  • 在返回增强中,我们需要给@AfterReturing设置returning的值,且需要与方法的参数名一致,用于表示业务方法的返回值
  • 在异常增强中,需要给@AfterThrowing设置throwing的值,且需要与方法的参数名一致,用于表示业务方法产生的异常在环绕增强中,参数为ProceedingJoinPoint类型,它是JoinPoint的子接口,我们需要在这个方法中手动调用其proceed方法来触发业务方法
  • 在所有的增强方法中都可以申明第一个参数为JoinPoint(注意的是,环绕增强是使用ProceedingJoinPoint来进行申明,它实现了JoinPoint接口)
  • JoinPoint接口提供了几个有用的方法 :
    • getArgs():返回这个方法的参数
    • getThis():返回这个代理对象
    • getTarget():返回目标对象(被代理的对象)
    • getSignature():返回被增强方法的描述
    • toString():打印被增强方法的有用描述

下面为Mycontroller测试类:

@RestController
@RequestMapping("/my")
public class MyController {

    @GetMapping("/testBefore")
    public void testBefore() {
        System.out.println("testBefore 业务方法");
    }

    @GetMapping("/testAfterReturning")
    public String testAfterReturning() {
        System.out.println("testAfterReturning 业务方法");
        return "我是一个返回值";
    }

    @GetMapping("/testAfterThrowing")
    public void testAfterThrowing() {
        System.out.println("testAfterThrowing 业务方法");
        int a = 0;
        int b = 1 / a;
    }

    @GetMapping("/testAfter")
    public void testAfter() {
        System.out.println("testAfter 业务方法");
    }

    @GetMapping("/around")
    public void around() {
        System.out.println("around 业务方法");
    }
}

5. 用AOP实现日志拦截

5.1 一般的实现

打印日志是AOP的一个常见应用场景,我们可以对Controller层向外提供的接口做统一的日志拦截,用日志记录请求参数、返回参数、请求时长以及异常信息,方便我们线上排查问题,下面是核心类LogAspect的实现

/**
 * 日志的切面
 */
@Aspect
@Component
public class LogAspect {

    @Resource
    private IdWorker idWorker;

    @Pointcut("execution (public * com.yc.core.controller.*.*(..))")
    public void log(){}

    /**
     * 使用环绕增强实现日志打印
     * @param joinPoint
     * @return
     * @throws Throwable
     */
    @Around("log()")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        //获得执行方法的类和名称
        String className = joinPoint.getTarget().getClass().getName();
        //获得方法名
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        String methodName = signature.getMethod().getName();
        //获得参数
        Object[] args = joinPoint.getArgs();
        long requestId = idWorker.nextId();
        //打印参数
        LogHelper.writeInfoLog(className, methodName, "requestId:" + requestId + ",params:" + JSONObject.toJSONString(args));
        long startTime = System.currentTimeMillis();
        //执行业务方法
        Object result = null;
        try {
            result = joinPoint.proceed();
        } catch (Exception e) {
            LogHelper.writeErrLog(className, methodName, "requestId:" + requestId + ",异常啦:" + LogAspect.getStackTrace(e));
        }
        long endTime = System.currentTimeMillis();
        //打印结果
        LogHelper.writeInfoLog(className, methodName, "requestId:" + requestId + ",耗时:" + (endTime - startTime) +  "ms,result:" + JSONObject.toJSONString(result));
        //返回
        return result;
    }

    /**
     * 获取异常的堆栈信息
     * @param throwable
     * @return
     */
    public static String getStackTrace(Throwable throwable)
    {
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        try
        {
            throwable.printStackTrace(pw);
            return sw.toString();
        } finally
        {
            pw.close();
        }
    }
}
  • 在proceed()方法之前,相当于前置增强,收集类名、方法名、参数,记录开始时间,生成requestId
  • 在proceed()方法之后,相当于后置增强,并能获取到返回值,计算耗时
  • 在前置增强时,生成requestId,用于串联多条日志
  • 使用try、catch包裹proceed()方法,在catch中记录异常日志
  • 提供了getStackTrace方法获取异常的堆栈信息,便于排查报错详细情况

5.2 仅拦截需要的方法

但是上面的日志是针对所有controller层中的方法进行了日志拦截,如果我们有些方法不想进行日志输出,比如文件上传的接口、大量数据返回的接口,这个时候定义切入点的时候可以使用@annotation描述符来匹配加了特定注解的方法,步骤如下:

1. 先定义一个日志注解Log

/**
 * 自定义日志注解
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Log {
}

2.用@annotation定义切入点

    @Pointcut("@annotation(com.yc.core.annotation.Log)")
    public void logAnnotation(){}

3.在想做日志输出的方法上使用注解Log

    @Log
    @PostMapping(value = "testannotation")
    public AOPTestVO testannotation(@RequestBody AOPTestDTO aopTestDTO) {
        AOPTestVO aopTestVO = new AOPTestVO();
        aopTestVO.setCode(1);
        aopTestVO.setMsg("哈哈哈");
        return aopTestVO;
    }

这样,我们就可以自定义哪些方法需要日志输出了

5.3 requestId传递

后来有同事提到,如果这是针对Controller层的拦截,但是Service层也有自定义的日志输出,怎么在Service层获取到上述的requestId呢?

其实就是我们拦截之后,是否可以针对方法的参数进行修改呢?其实注意是看

result = joinPoint.proceed();

我们发现ProceedingJoinPoint还有另外一个带有参数的proceed方法,定义如下:

public Object proceed(Object[] args) throws Throwable;

我们可以利用这个方法,在环绕增强中去增加requestId,这样后面的增强方法或业务方法中就能获取到这个requestId了。

首先,我们先定义一个基类AOPBaseDTO,只有一个属性requestId

@Data
@ApiModel("aop参数基类")
public class AOPBaseDTO {
    @ApiModelProperty(value = "请求id", hidden = true)
    private long requestId;
}

然后我们让Controller层接口的参数AOPTestDTO继承上述AOPBaseDTO,如下:

@Data
@ApiModel("aop测试类")
public class AOPTestDTO extends AOPBaseDTO{

    @ApiModelProperty(value = "姓名")
    private String name;

    @ApiModelProperty(value = "年龄")
    private int age;
}

最后在环绕的增强中添加上requestId,如下:

    /**
     * 使用环绕增强实现日志打印
     * @param joinPoint
     * @return
     * @throws Throwable
     */
    @Around("logAnnotation()")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        //获得执行方法的类和名称
        String className = joinPoint.getTarget().getClass().getName();
        //获得方法名
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        String methodName = signature.getMethod().getName();
        //获得参数
        Object[] args = joinPoint.getArgs();
        long requestId = idWorker.nextId();
        for(int i = 0; i < args.length; i++) {
            if (args[i] instanceof AOPBaseDTO) {
                //增加requestId
                ((AOPBaseDTO) args[i]).setRequestId(requestId);
            }
        }
        //打印参数
        LogHelper.writeInfoLog(className, methodName, "requestId:" + requestId + ",params:" + JSONObject.toJSONString(args));
        long startTime = System.currentTimeMillis();
        //执行业务方法
        Object result = null;
        try {
            result = joinPoint.proceed(args);
        } catch (Exception e) {
            LogHelper.writeErrLog(className, methodName, "requestId:" + requestId + ",异常啦:" + LogAspect.getStackTrace(e));
        }
        long endTime = System.currentTimeMillis();
        //打印结果
        LogHelper.writeInfoLog(className, methodName, "requestId:" + requestId + ",耗时:" + (endTime - startTime) +  "ms,result:" + JSONObject.toJSONString(result));
        //返回
        return result;
    }

我们运行起代码,访问一下,下面是运行结果:

可以看到,我们的业务方法中已经能获取到requestId,如果Service层需要,可以通过传递AOPTestDTO,从中获取。

5.4 关于增强执行的顺序

  • 1. 针对不同类型的增强,顺序固定的,比如before在after前面
  • 2. 针对同一切面的相同类型的增强,根据定义先后顺序依次执行
  • 3. 针对不同切面的相同增强,可以通过使我们的切面实现Ordered接口,重写getOrder方法,返回值最小,优先级越高。注意的是before和after的相反的,before的优先级越高越早执行,after的优先级越高,越晚执行

6. 思考

  • 1. 代理对象是什么时候创建的?
  • 2. 当存在多个不同类型增强时,执行顺序是怎么保证的?
  • 3. 真正的业务方法是什么时候调用的,怎么做到只调用一次?

到此这篇关于Spring面向切面编程AOP详情的文章就介绍到这了,更多相关Spring面向切面编程内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Spring AOP使用@Aspect注解 面向切面实现日志横切的操作

    引言: AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术.AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型. 利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率. 在Spring AOP中业务逻辑仅仅只关注业务本身,将日志记录,性能统计,安全控制,事务处理,异

  • Springboot如何使用Aspectj实现AOP面向切面编程

    目录 要在 Springboot中声明 AspectJ 切面 引入jar包 网上也有说要在application.properties中添加 最后补充一点小知识 AspectJ 支持 5 种类型的通知注解 下面是我写的一些通知的实例 大家可以参考一下 要在 Springboot中声明 AspectJ 切面 需在 IOC 容器中将切面声明为 Bean 实例 即加入@Component 注解;当在 Spring IOC 容器中初始化 AspectJ 切面之后, Spring IOC 容器就会为那些与

  • Spring使用AspectJ的注解式实现AOP面向切面编程

    1.认识Spring AOP 1.1 AOP的简介 AOP:面向切面编程,相对于OOP面向对象编程. Spring的AOP的存在目的是为了解耦.AOP可以让一组类共享相同的行为.在OOP中只能通过继承类和实现接口,来使代码的耦合度增强,而且类的继承只能为单继承,阻碍更多行为添加到一组类上,AOP弥补了OOP的不足. 1.2 AOP中的概念 切入点(pointcut): 切入点(pointcut):在哪些类.哪些方法上切入. 通知(advice):在方法前.方法后.方法前后做什么. 切面(aspe

  • Spring AOP面向切面编程实现及配置详解

    动态代理 特点 字节码随用随创建,随用随加载 作用 不用修改源码对方法增强 分类 基于接口的动态代理 基于子类的动态代理 创建 使用Proxy类中的newProxyInstance方法 要求 被代理类最少实现一个接口,没有则不能使用 newProxyInstance方法参数 classLoader:类加载器 用于加载代理对象字节码的,和被代理对象使用相同的类加载器 class[ ]:字节码数组 用于让代理对象和被代理对象有相同方法,固定写法. InvocationHandler:用于提供增强的代

  • Spring 面向切面编程AOP实现详解

    简介 1.什么叫做面向切面编程? 概念:把一个个的横切关注点(某种业务的实现代码)放到某个模块中去,称之为切面.每个切面影响业务的一种功能,切面的目的就是为了功能增强,将需要增强的方法做成切面,实现对业务的增强,就是面向切面编程. 目的:将与业务本身无关,却被业务模块所共同调用的功能代码封装成切面,以减少系统的重复代码,降低耦合,提高可扩展性. 优势:把多个方法前/后的共同代码抽离出来,使用动态代理机制来控制,先执行抽离出来的代码,再执行每一个真实方法. 2.Spring中的AOP使用动态代理来

  • Spring AOP详解面向切面编程思想

    目录 1. 什么是 Spring AOP 2. AOP 的组成 2.1 切面 (Aspect) 2.2 切点 (Pointcur) 2.3 连接点 (Join Point) 2.4 通知 (Advice) 3. Spring AOP 的使用 3.1 添加 AOP 框架 3.2 定义切面和切点 3.3 定义通知 (五种) 4. Spring AOP 实现原理 4.1 织入 (Weaving) 4.2 JDK 和 CGLIB 实现的区别 1. 什么是 Spring AOP AOP (Aspect O

  • Spring超详细讲解AOP面向切面

    目录 简介 AOP底层原理 代理概念 JDK动态代理实现 Spring中的AOP 相关术语 AspectJ 实现AOP 不同通知类型实现 相同的切入点抽取 增强类优先级 完全使用注解开发 说明:基于atguigu学习笔记. 简介 AOP(Aspect Oriented Programming)是一种面向切面的编程思想.不同于面向对象里的继承思想,当需要为多个不具有继承关系的对象引人同一个公共行为时,也就是把程序横向看,寻找切面,插入公共行为. AOP目的是为了些把影响了多个类的公共行为抽取到一个

  • Spring AOP面向切面编程实现原理方法详解

    1. 什么是AOP AOP (Aspect Oriented Programming)意为:面向切面编程,通过预编译方式和运行期动态代理实现在不修改源代码的情况下,给程序动态统一添加功能的一种技术,可以理解成动态代理.是Spring框架中的一个重要内容.利用 AOP 可以对业务逻辑的各个部分进行隔离,使业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高开发的效率 2. Spring AOP ①. AOP 在Spring中的作用 提供声明式事务:允许用户自定义切面 ②. AOP 的基本概

  • Spring框架AOP面向切面编程原理全面分析

    目录 1.什么是AOP AOP面向切面的优势 AOP需要添加的依赖 2.简述AOP工作运行原理 动态创建的总结: 3.使用Spring创建AOP 测试类 Spring.xml 1.什么是AOP AOP:Aspect Oriented Programming ⾯向切⾯编程. AOP面向切面的优势 降低模块之间的耦合度. 使系统更容易扩展. 更好的代码复⽤. ⾮业务代码更加集中,不分散,便于统⼀管理. 业务代码更加简洁存粹,不参杂其他代码的影响. AOP 是对⾯向对象编程的⼀个补充,在运⾏时,动态地

  • Spring面向切面编程AOP详情

    目录 1. 面向切面编程 2. AOP核心概念 3. AOP的实现 4. Spring 对AOP支持 4.1 支持@Aspect 4.2 声明一个切面 4.3 声明一个切入点 4.4 声明增强 5. 用AOP实现日志拦截 5.1 一般的实现 5.2 仅拦截需要的方法 5.3 requestId传递 5.4 关于增强执行的顺序 6. 思考 1. 面向切面编程 定义:面向切面编程(AOP,Aspect Oriented Programming)是通过预编译方式和运行期间动态代理实现程序功能的统一维护

  • Python 面向切面编程 AOP 及装饰器

    目录 什么是 AOP 装饰器 函数装饰器 类装饰器 1.函数装饰函数 2.类装饰函数 3.函数装饰类 4.类装饰类 什么是 AOP AOP,就是面向切面编程,简单的说,就是动态地将代码切入到类的指定方法.指定位置上的编程思想就是面向切面的编程. 我们管切入到指定类指定方法的代码片段称为切面,而切入到哪些类.哪些方法则叫切入点.这样我们就可以把几个类共有的代码,抽取到一个切片中,等到需要时再切入对象中去,从而改变其原有的行为. 这种思想,可以使原有代码逻辑更清晰,对原有代码毫无入侵性,常用于像权限

  • 详解spring面向切面aop拦截器

    spring中有很多概念和名词,其中有一些名字不同,但是从功能上来看总感觉是那么的相似,比如过滤器.拦截器.aop等. 过滤器filter.spring mvc拦截器Interceptor .面向切面编程aop,实际上都具有一定的拦截作用,都是拦截住某一个面,然后进行一定的处理. 在这里主要想着手的是aop,至于他们的比较,我想等三个都一一了解完了再说,因此这里便不做过多的比较. 在我目前的项目实践中,只在一个地方手动显示的使用了aop,那便是日志管理中对部分重要操作的记录. 据我目前所知,ao

  • MVC AOP面向切面编程简单介绍及实例

    MVC AOP面向切面编程 AOP这个词相信大家都没有接触太多过,但是实际上你们已经有所接触了,就在设计模式中.AOP所用的思想其实和设计模式是一样的,即在不修改原代码的情况下统一增加或者修改功能.还有,AOP大多用在spring里面,但是本文所写的只是在MVC中的应用,要注意. 一.简介 所谓AOP(Aspect Oriented Programming的缩写)意为面向切面的编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术.AOP是OOP的延续,是软件开发中的一个热点,也是

  • 面向切面编程(AOP)的理解

    在传统的编写业务逻辑处理代码时,我们通常会习惯性地做几件事情:日志记录.事务控制及权限控制等,然后才是编写核心的业务逻辑处理代码.当代码编写完成回头再看时,不禁发现,扬扬洒洒上百行代码中,真正用于核心业务逻辑处理才那么几行,如图6-4所示.方法复方法,类复类,就这样子带着无可奈何遗憾地度过了多少个春秋.这倒也罢,倘若到了项目的尾声,突然决定在权限控制上需要进行大的变动时,成千上万个方法又得一一"登门拜访",痛苦"雪上加霜". 如果能把图6-4中众多方法中的所有共有代

  • 解析Spring中面向切面编程

    一.AOP--另一种编程思想 1.1.什么是 AOP AOP (Aspect Orient Programming),直译过来就是 面向切面编程.AOP 是一种编程思想,是面向对象编程(OOP)的一种补充.面向对象编程将程序抽象成各个层次的对象,而面向切面编程是将程序抽象成各个切面. 从<Spring实战(第4版)>图书中扒了一张图: 从该图可以很形象地看出,所谓切面,相当于应用对象间的横切点,我们可以将其单独抽象为单独的模块. 1.2.为什么需要 AOP 想象下面的场景,开发中在多个模块间有

随机推荐