spring框架学习(三)——AOP( 面向切面编程)

AOP 即 Aspect Oriented Program 面向切面编程
  首先,在面向切面编程的思想里面,把功能分为核心业务功能,和周边功能
    所谓的核心业务,比如登陆,增加数据,删除数据都叫核心业务
    所谓的周边功能,比如性能统计,日志,事务管理等等

  周边功能在Spring的面向切面编程AOP思想里,即被定义为切面

  在面向切面编程AOP的思想里面,核心业务功能和切面功能分别独立进行开发
  然后把切面功能和核心业务功能 "编织" 在一起,这就叫AOP

原理图

  1. 功能分两大类,辅助功能和核心业务功能
  2. 辅助功能和核心业务功能彼此独立进行开发
  3. 比如登陆功能,即便是没有性能统计和日志输出,也可以正常运行
  4. 如果有需要,就把"日志输出" 功能和 "登陆" 功能 编织在一起,这样登陆的时候,就可以看到日志输出了
  5. 辅助功能,又叫做切面,这种能够选择性的,低耦合的把切面和核心业务功能结合在一起的编程思想,就叫做切面编程

         spring框架学习(三)——AOP( 面向切面编程)

准备业务类 ProductService

package com.how2java.service;
 
public class ProductService {
     
    public void doSomeService(){
         
        System.out.println("doSomeService");
         
    }
     
}

准备一个测试类 TestSpring

package com.how2java.test;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import com.how2java.service.ProductService;
 
public class TestSpring {
 
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext(new String[] { "springconfig.xml" });
        ProductService s = (ProductService) context.getBean("s");
        s.doSomeService();
    }
}

准备一个日志切面LoggerAspect

package com.how2java.aspect;
import org.aspectj.lang.ProceedingJoinPoint;
 
public class LoggerAspect {
 
    public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("start log:" + joinPoint.getSignature().getName());
        Object object = joinPoint.proceed();
        System.out.println("end log:" + joinPoint.getSignature().getName());
        return object;
    }
}

设置配置文件springconfig.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                 http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--声明业务对象-->     <bean name="s" class="com.how2java.service.ProductService"/> <!--声明日志切面-->    <bean id="loggerAspect" class="com.how2java.aspect.LoggerAspect"/>    <!--aop配置过程-->    <aop:config>         <aop:pointcut id="loggerCutpoint"                  expression="execution(* com.how2java.service.ProductService.*(..)) "/>         <aop:aspect id="logAspect" ref="loggerAspect">               <aop:around pointcut-ref="loggerCutpoint" method="log"/>         </aop:aspect>     </aop:config> </beans>

aop配置过程每一步的含义解释: 

<aop:pointcut id="loggerCutpoint" expression="execution(* com.how2java.service.ProductService.*(..)) "/>

这一句是声明切点,切点的 id 叫 loggerCutPoint ,用来标记这个切入点,这个expression表示:满足expression中的方法调用之后,就会去进行切面操作,类似于触发了切面:

  1. 第一个 * 代表返回任意类型:可以是void,int,string。。。。具体可根据调用的方法的返回类型决定

  2. com.how2java.service.ProductService.*(..) :表示包名为 com.how2java.service下的ProductService 类的任意方法  ( 这里的通配符 * 表示任意方法,(..)表示方法的参数是任意数量和类型 )

简单说就是,只要com.how2java.service这个包中的ProductService类的任意一个函数被调用,不管你的返回值是什么,都会触发开关,我就会去执行切面,也就是辅助功能。针对ProductService类中只有doSomeService()一个函数方法,* com.how2java.service.ProductService.*(..)也可以写成 void com.how2java.service.ProductService.doSomeService()。但是辅助功能是什么呢,就是下面三句:

<aop:aspect id="logAspect" ref="loggerAspect">
  <aop:around pointcut-ref="loggerCutpoint" method="log"/>
</aop:aspect>

这三句是定义了一个切面,上面说只要触发开关,就会去执行切面,就是指的这里的切面,所谓切面,就是一个类中的方法而已,在本案例中就是指  loggerAspect类中的log()方法,id="logAspect"  表示切面的id,ref="loggerAspect"指明切面所属的类,pointcut-ref="loggerCutpoint" 指明触发切面的切点id,method="log" 指明执行切面时所用的方法名。

测试类运行的结果如下

spring框架学习(三)——AOP( 面向切面编程)

------------------------------------------------------

需要注意的是,一个切点也可以设置多个切面,我们重新创建了两个loggerAspect2和loggerAspect3,如下

spring框架学习(三)——AOP( 面向切面编程)spring框架学习(三)——AOP( 面向切面编程)spring框架学习(三)——AOP( 面向切面编程)

配置文件改为

<?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.xsd">
       <bean name="s" class="com.how2java.service.ProductService"/>

    <bean id="loggerAspect2" class="com.how2java.aspect.LoggerAspect2"/>
    <bean id="loggerAspect3" class="com.how2java.aspect.LoggerAspect3"/>

    <aop:config>
        <aop:pointcut id="loggerCutpoint"
                      expression="execution(void com.how2java.service.ProductService.doSomeService()) "/>     <aop:aspect id="logAspect2" ref="loggerAspect2">
            <aop:before pointcut-ref="loggerCutpoint" method="log"/>
        </aop:aspect>
        <aop:aspect id="logAspect3" ref="loggerAspect3">
            <aop:after pointcut-ref="loggerCutpoint" method="log"/>
        </aop:aspect>
    </aop:config>
</beans>

运行结果为

spring框架学习(三)——AOP( 面向切面编程)

 ------------------------------------------------------

 AOP的过程分为两步:1,在业务类中插入切点,2,将切点和切面类关联起来

 业务类就是核心类,就是网站的主要功能,切面就是辅助功能,日志,统计之类的

通过配置,可以实现,在某个方法调用的时候,触发别的方法执行,就好像在监视目标方法,你被执行,就触发我执行。

下面简单介绍一下通知:

  通知定义了切面要完成的工作内容和何时完成工作,就是什么时候去做辅助功能,功能具体是什么代码

  五种类型

    1. Before——在方法调用之前调用通知

    2. After——在方法完成之后调用通知,无论方法执行成功与否

    3. After-returning——在方法执行成功之后调用通知

    4. After-throwing——在方法抛出异常后进行通知

    5. Around——通知包裹了被通知的方法,在被通知的方法调用之前和调用之后执行自定义的行为

   前四个好理解的,最后一个around 表示切面在被监视的函数运行前后都会执行,下面是切面要执行的函数 log,log函数有一个形参 joinPoint 这个可以理解为断点,中间一句代表的就是被监视的程序运行,在被监视的程序运行时,可以替换他的形参,这个是 around 厉害的地方,如果被监视的程序,运行的时候输入的是一个haha字符串作为实参,但是经过log方法之后,这个参数就被替换为abc了

public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("我在被监视程序之前。。。");
        Object object = joinPoint.proceed(new Object[]{"abc"});
        System.out.println("我在被监视程序之后。。。" );
        return object;
    }

注:关于joinPoint的详细介绍,请点击此处查看

相关推荐