SpringAop介绍及使用

最新推荐文章于 2022-12-16 09:59:17 发布

俺叫牛爱芳

最新推荐文章于 2022-12-16 09:59:17 发布

阅读量99

点赞数

文章标签： spring

本文链接：https://blog.csdn.net/l32273/article/details/123686118

版权

一、AOP介绍
1、AOP关键性概念：
连接点（Joinpoint）：程序执行过程中明确的点，如方法的调用，或者异常的抛出

目标（Target）:被通知（被代理）的对象。——注1：完成具体的业务逻辑。

通知（Advice）:在某个特定的连接点上执行的动作，同时Advice也是程序代码的具体实现，例如一个实现日志记录的代码（通知有些书上也称为处理）——注2：完成切面编程。

代理（Proxy）:将通知应用到目标对象后创建的对象（代理=目标+通知）。例子：外科医生+护士——注3：只有代理对象才有AOP功能，而AOP的代码是写在通知的方法里面的。

切入点（Pointcut）：多个连接点的集合，定义了通知应该应用到那些连接点。（也将Pointcut理解成一个条件，此条件决定了容器在什么情况下将通知和目标组合成代理返回给外部程序）

适配器（Advisor）:适配器=通知（Advice）+切入点（Pointcut）

2、如何实现AOP
目标对象只负责业务逻辑代码
通知对象负责AOP代码，这二个对象都没有AOP的功能，只有代理对象才有

二、前置通知
价值:创建session，开启事务

将相关资料导入：

MyMethodBeforeAdvice类：

package com.lv.aop.advice;
 
import java.lang.reflect.Method;
import java.util.Arrays;
 
import org.springframework.aop.MethodBeforeAdvice;
 
/**
 * 前置通知
 * 调用项目中的某一接口实现类的方式时，将类名.方法名，携带的参数，作为日志存储到数据库。
 * @author Administrator
 *
 */
public class MyMethodBeforeAdvice implements MethodBeforeAdvice {
//    target:目标对象
//    method：被触发的目标对象的方法
//    args：目标对象的目标方法的携带的参数
    public void before(Method method, Object[] args, Object target) throws Throwable {
        String targetName = target.getClass().getName();
        String methodName = method.getName();
        String params = Arrays.toString(args);
        String msg = "【系统日志】：正在调用->"+targetName+"."+methodName+",携带的参数："+params;
        System.out.println(msg);
 
    }
 
}

BookBizImpl类：

package com.lv.aop.biz.imp1;
 
import com.lv.aop.biz.IBookBiz;
import com.lv.aop.exception.PriceException;
 
public class BookBizImpl implements IBookBiz {
 
    public BookBizImpl() {
        super();
    }
 
    public boolean buy(String userName, String bookName, Double price) {
        // 通过控制台的输出方式模拟购书
        if (null == price || price <= 0) {
            throw new PriceException("book price exception");
        }
        System.out.println(userName + " buy " + bookName + ", spend " + price);
        return true;
    }
 
    public void comment(String userName, String comments) {
        // 通过控制台的输出方式模拟发表书评
        System.out.println(userName + " say:" + comments);
    }
 
}

IBookBiz类：

package com.lv.aop.biz;
 
public interface IBookBiz {
    // 购书
    public boolean buy(String userName, String bookName, Double price);
 
    // 发表书评
    public void comment(String userName, String comments);
}

PriceException类：

package com.lv.aop.exception;
 
public class PriceException extends RuntimeException {
 
    public PriceException() {
        super();
    }
 
    public PriceException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
 
    public PriceException(String message, Throwable cause) {
        super(message, cause);
    }
 
    public PriceException(String message) {
        super(message);
    }
 
    public PriceException(Throwable cause) {
        super(cause);
    }
    
}

定义目标

测试

public class Demo {
    public static void main(String[] args) {


    //AOP的关键性概念
    //1)连接点：程序之间过程中明确的点，如方法的调用，异常的抛出
    //2)目标：被通知被代理的对象（完成1具体执行的业务逻辑）
    //3）通知：在某种特定的连接点上所执行的动作
    //4)代理：将通知应用到目标上所创建的对象（代理=通知+目标）
    //!!!!只有完整的代理对象才具备AOP的特性，而AOP代码是写在通知中的
    //5)切入点：多个连接点的集合，将通知应用到某些连接点
    //6)适配器：通知+切入点(相当于必须满足切入点的条件才会应用通知部分)

    //初始化容器
    ApplicationContext ac=
            new ClassPathXmlApplicationContext("spring.xml");
//        BookBizImpl target = ac.getBean("bookBizTarget", BookBizImpl.class);
        target.buy("张三","好看",100d);
        target.comment("张三","好看雀氏好看");

结果

spring.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--定义目标-->
    <bean id="bookBizTarget" class="com.zking.spring02.biz.BookBizImpl">
    </bean>

    <!--定义通知-->
    <!--前置通知-->
    <bean id="beforeAdvice" class="com.zking.spring02.advice.BeforeAdvice">

    </bean>
    <!--后置通知-->
    <bean id="afterAdvice" class="com.zking.spring02.advice.AfterAdvice">

    </bean>

    <!--环绕通知-->
    <bean id="aroundAdvice" class="com.zking.spring02.advice.AroundAdvice">

    </bean>

    <!--异常通知-->
    <bean id="exceptionAdvice" class="com.zking.spring02.advice.ExceptionAdvice">

    </bean>

    <!--适配器-->
    <bean id="regexpMethod" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <!--通知-->
        <property name="advice">
            <ref bean="afterAdvice"/>
        </property>
        <!--切入点-->
<!--        <property name="pattern">-->
<!--            <value>.*buy</value>-->
<!--        </property>-->
        <!--切入点-->
        <property name="patterns">
            <list>
                <value>.*buy</value>
            </list>
        </property>
    </bean>
    <!--代理=通知加目标,只有代理对象才具备完整的AOP特性，而AOP代码是写在通知中的-->
    <bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!--通知-->
        <property name="interceptorNames">
            <list>
<!--                <value>beforeAdvice</value>-->
<!--                <value>afterAdvice</value>-->
<!--                <value>aroundAdvice</value>-->
<!--                <value>exceptionAdvice</value>-->
                <value>regexpMethod</value>
            </list>
        </property>
        <!--目标-->
        <property name="target">
          <ref bean="bookBizTarget"/>
        </property>
        <!--定义代理对象实现的接口-->
        <property name="proxyInterfaces">
            <list>
                <value>com.zking.spring02.biz.IBookBiz</value>
            </list>
        </property>
    </bean>

1.前置通知

代理对象

package com.zking.spring02.advice;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;
import java.util.Arrays;

/**
 * 前置通知：用于目标方法被调用时之前日志收集
 */
public class BeforeAdvice implements MethodBeforeAdvice {
    /**
     *
     * @param method    目标方法
     * @param args      目标方法所执行的参数
     * @param target    目标对象
     * @throws Throwable
     */
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        //获取被调用的方法名
        String methodName=method.getName();
        //获取目标方法的全路径名
        String className=target.getClass().getName();

        System.out.println("[前置通知]"+className+"."+methodName+"执行参数:"+ Arrays.toString(args));

    }
}

2.后置通知

package com.zking.spring02.advice;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;
import java.util.Arrays;

public class AfterAdvice implements AfterReturningAdvice {
    /**
     *
     * @param returnvalue   目标方法的返回值
     * @param method        目标方法
     * @param args          目标方法的执行参数
     * @param target        目标对象
     * @throws Throwable
     */
    @Override
    public void afterReturning(Object returnvalue, Method method, Object[] args, Object target) throws Throwable {
            //获取方法名
//        String methodName=method.getName();
//        //获取目标方法的全路径名
//        String className = target.getClass().getName();
//        System.out.println("[后置通知]"+className+"."+methodName+"执行参数"+ Arrays.toString(args)+"返回值"+returnvalue);

        System.out.println("[适配器] 买书返利两元");
    }
}

3.环绕通知

package com.zking.spring02.advice;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

import java.lang.reflect.Method;
import java.util.Arrays;

/**
 * 环绕通知
 */
public class AroundAdvice implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        //获取目标对象
        Object target = invocation.getThis();
        //获取目标方法
        Method method = invocation.getMethod();
        //获取目标方法的执行参数
        Object[] arguments = invocation.getArguments();


        //环绕通知
        System.out.println("[环绕通知]"+target.getClass()+"."+method.getName()+"执行参数"+ Arrays.toString(arguments));

        //执行目标方法
        Object returnValue = invocation.proceed();
        //环绕通知
        System.out.println("[环绕通知]"+target.getClass()+"."+method.getName()+"执行参数"+ Arrays.toString(arguments)+"返回值"+returnValue);

        return returnValue;
    }
}

4.异常通知

价格异常的类MyThrowsAdvice：

package com.zking.spring02.advice;

import org.springframework.aop.ThrowsAdvice;

public class ExceptionAdvice implements ThrowsAdvice {
    public void afterThrowing( PriceException ex ) {
        System.out.println("[异常通知]  买书价格异常,购买失败");
    }
}

5.适配器

 <!--适配器-->
    <bean id="regexpMethod" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <!--通知-->
        <property name="advice">
            <ref bean="afterAdvice"/>
        </property>
        <!--切入点-->
<!--        <property name="pattern">-->
<!--            <value>.*buy</value>-->
<!--        </property>-->
        <!--切入点-->
        <property name="patterns">
            <list>
                <value>.*buy</value>
            </list>
        </property>
    </bean>
    <!--代理=通知加目标,只有代理对象才具备完整的AOP特性，而AOP代码是写在通知中的-->
    <bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!--通知-->
        <property name="interceptorNames">
            <list>
<!--                <value>beforeAdvice</value>-->
<!--                <value>afterAdvice</value>-->
<!--                <value>aroundAdvice</value>-->
<!--                <value>exceptionAdvice</value>-->
                <value>regexpMethod</value>
            </list>
        </property>
        <!--目标-->
        <property name="target">
          <ref bean="bookBizTarget"/>
        </property>
        <!--定义代理对象实现的接口-->
        <property name="proxyInterfaces">
            <list>
                <value>com.zking.spring02.biz.IBookBiz</value>
            </list>
        </property>
    </bean>
</beans>

总结：如果只有目标，则只会去做核心业务逻辑处理，不会收集日志；
         如果只有通知，则只会去做日志记录，不会执行核心业务逻辑；
         通知应用到目标上才能得到代理对象（通知+目标=代理）
         只有完整的代理对象才具备AOP的特性，而AOP的公共代码（日志收集）是写在通知中的！！