SpringAOP简单例子

转自：https://blog.csdn.net/lp1052843207/article/details/52460601
AOP（Aspect-OrientedProgramming，面向切面编程，好多人喜欢说面向方面编程，我觉得切面更容易解释AOP。）

面向切面编程，有效的降低了代码之间的耦合性，易于维护；例如：我们习惯在代码中加上一些日志信息，在程序出错时方便快速查找找到问题，通常做法是在请求进入方法的时候打印日志，退出前打印日志，还有在出错时打印日志，那么问题就来了，每个方法中都需要打印日志，这些相同的部分就可以当做一个切面，通过配置切点来触发所需要的功能，比如，我需要在请求进入方法的时候打印，即可使用aop当中的前置通知来做到，这样就不需要每个方法中都去写一遍，配置好之后引用即可。

aop代码实例：

1.创建一个控制台程序；导入包

2.创建接口

package com.AspectTest.service;
public interface personServer {
    public void save(String uname,int age); 
}

3.接口的实现

package com.AspectTest.service;
public class personServerImpl implements personServer{
    @Override
    public void save(String uname,int age) {
        int a=0;
        age= age/a;//打开上面两行报错，可触发异常通知
        System.out.println("come in personServerImpl save method...");
    }
}

4.创建（aop）切面类

package com.AspectTest.aop;
import java.util.Arrays;
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.stereotype.Component;

@Aspect//声明这是一个切面
@Component//声明这是一个组件，泛指...可以去掉
public class AspectIntercepter {

      @Pointcut(value="execution(* com.AspectTest.service.personServerImpl.*(..))")
      private void pointCut(){//定义一个切入点 后面的通知直接引入切入点方法pointCut即可            personServerImpl下面的所有方法
      }

       //环绕通知（连接到切入点开始执行，下一步进入前置通知，在下一步才是执行操作方法）
        @Around(value="pointCut()")
        public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable{
            System.out.println("@Around进入环绕通知...");
            Object object = pjp.proceed();//执行该方法
            System.out.println(pjp.getThis()+"  操作结束，退出方法;环绕[@Around]结束！...");
            return object;
        }

        //前置通知（进入环绕后执行，下一步执行方法）
        @Before(value="pointCut()")
        public void doAccessCheck(JoinPoint joinPoint){
            System.out.println("@Before前置通知:"+Arrays.toString(joinPoint.getArgs()));
        }

        //异常通知（出错时执行）
        @AfterThrowing(value="pointCut()",throwing="ex")
        public void doAfterThrow(JoinPoint joinPoint,Throwable ex){
            System.out.println("@AfterThrowing例外通知(异常通知)"+Arrays.toString(joinPoint.getArgs()));
            System.out.println("@AfterThrowing异常信息："+ex);
        }

        //后置通知(返回之前执行)
        @After(value="pointCut()")
        public void after(){
            System.out.println("@After后置通知...");
        }

        //最终通知（正常返回通知，最后执行）
        @AfterReturning(value="pointCut()")
        public void doAfter(){
            System.out.println("@AfterReturning最终通知...End!");
        }
}

5.配置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"
    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.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
    <!-- 使 AspectJ 的注解起作用 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

    <bean id="personServiceBean" class="com.AspectTest.service.personServerImpl"/>  
    <bean id="myInterceptor" class="com.AspectTest.aop.AspectIntercepter"/> 

</beans>

6.创建测试类

package com.AspectTest;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.AspectTest.service.personServer;
public class SpringAopTest {
        @Test
        public void inteceptorTest(){
            ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext-aop.xml");
            personServer bean = (personServer)ctx.getBean("personServiceBean");
            bean.save("badMonkey",23);

//          personServer p = new personServerImpl();//通过new对象是不会触发aop的
//          p.save("11", "22");
        }
}

【运行结果1】：
@Around进入环绕通知…
@Before前置通知:[badMonkey, 23]
come in personServerImpl save method…
com.AspectTest.service.personServerImpl@11023cad 操作结束，退出方法;环绕[@Around]结束！…
@After后置通知…
@AfterReturning最终通知…End!

【运行结果2】：

@Around进入环绕通知…
@Before前置通知:[badMonkey, 23]
@After后置通知…
@AfterThrowing例外通知(异常通知)[badMonkey, 23]
@AfterThrowing异常信息：java.lang.ArithmeticException: / by zero

注：

AspectJ使用org.aspectj.lang.JoinPoint接口表示目标类连接点对象，如果是环绕增强时，使用org.aspectj.lang.ProceedingJoinPoint表示连接点对象，该类是JoinPoint的子接口。任何一个增强方法都可以通过将第一个入参声明为JoinPoint访问到连接点上下文的信息。我们先来了解一下这两个接口的主要方法：
1)JoinPoint
 java.lang.Object[] getArgs()：获取连接点方法运行时的入参列表；
 Signature getSignature() ：获取连接点的方法签名对象；
 java.lang.Object getTarget() ：获取连接点所在的目标对象；
 java.lang.Object getThis() ：获取代理对象本身；
2)ProceedingJoinPoint
ProceedingJoinPoint继承JoinPoint子接口，它新增了两个用于执行连接点方法的方法：
 java.lang.Object proceed() throws java.lang.Throwable：通过反射执行目标对象的连接点处的方法；
 java.lang.Object proceed(java.lang.Object[] args) throws java.lang.Throwable：通过反射执行目标对象连接点处的方法，不过使用新的入参替换原来的入参。

猜你喜欢