Java开发SSM框架-Spring-AOP

最新推荐文章于 2025-01-17 01:04:45 发布

原创最新推荐文章于 2025-01-17 01:04:45 发布 · 196 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#spring #java #aop

本文介绍了Spring AOP的概念，包括其作为面向对象编程的补充，以及依赖于动态代理的实现方式。详细讲解了AOP的基本概念如切入点、通知类型，并通过实例展示了配置文件方式和注解方式在项目中的应用步骤。通过配置文件实现时，涉及切入点表达式的编写和通知的定义。而注解方式则简化了配置，直接在切面类中设置切入点和通知。

Spring AOP

在这里插入图片描述

什么是AOP：
在这里插入图片描述 AOP是把对象或固定的流程"切开"找到其中的公共行为，并将其提取同意处理的同一种思想。AOP可以认为是对OOP(面向对象编程)的一种补充，这种横向式的编程方式更容易处理不同对象，不同模块之间的共同业务，如访问控制，事务控制，性能监测等。

AOP依赖动态代理实现的

在这里插入图片描述
在代理模式中可以为原对象设置一个代理对象，被代理的对象也可称为目标对象。代理对象为目标对象方法提供一个代理方法。在这种模式下，给编程人员的感觉是在原有代码乃至原业务流程都不修改的情况下，直接在业务流程中切入新代码，增加新功能，这就是AOP。

AOP基本概念：
在这里插入图片描述
切入点详解：

通知类型：

前置通知: 在目标方法执行之前,执行前置通知
后置通知: 在目标方法执行之后,执行后置通知
异常通知: 在目标方法执行并抛出异常时,执行异常通知
最终通知: 在目标方法执行之后或抛出异常时,执行最终通知
环绕通知: 在前置通知和目标方法之前,以及最终通知之前执行环绕通知

SpringAOP在项目中的运用：
实现AOP的方式有两种一种是通过配置文件方式实现，一种是注解方式实现。
在这里插入图片描述

配置文件方式：
第1步: 添加jar包
Spring基本jar+AOP相关jar
在这里插入图片描述
第2步: 编写切面类

第3步: 编写Spring配置文件
a.将切面类交给Spring管理
b.配置面向切面
在这里插入图片描述

第4步: 编写程序,测试

已保存用户为例
建立UserDao接口以及实现类：

public interface UserDao {
    public int addUser(User user);
}

@Repository("userDao")//把该Bean交给Spring容器管理，即在配置文件中注册该类Id值为userDao
public class UserDaoImpl implements UserDao {
    @Override
    public int addUser(User user) {
        System.out.println("添加成功");
        return 1;
    }
}

编写业务接口以及实现类

public interface UserService {
    public int addUser(User user);
}

@Service("userService")//把该Bean交给Spring容器管理，即在配置文件中注册该类Id值为userService
public class UserServiceImpl implements UserService {
    @Resource(name = "userDao")
    private UserDao dao;
    @Override
    public int addUser(User user) {
        return  dao.addUser(user);
    }
}

编写切面类：

package aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import java.util.Arrays;
//切面类
@Component   //把该Bean交给Spring容器管理，即在配置文件中注册切面类Id值为类名首字面小写myAOP
public class MyAOP {
    //定义前置通知
    public void before(JoinPoint jp){
        System.out.println("调用："+jp.getTarget()+"的"+jp.getSignature().getName()+"方法，方法入参："+ Arrays.toString(jp.getArgs()));
    }
    //定义后置通知
    public void afterReturning(JoinPoint jp,Object resultData){
        System.out.println("调用："+jp.getTarget()+"的"+jp.getSignature().getName()+"方法，返回值为："+resultData);
    }
    //定义异常通知
    @AfterThrowing(pointcut = "pointcut()",throwing = "e")
    public void afterThrowing(JoinPoint jp,RuntimeException e){
        System.out.println("调用："+jp.getSignature().getName()+"方法出现异常。"+e);
    }
    //定义最终通知
    public void after(JoinPoint jp){
        System.out.println(jp.getSignature().getName()+"方法执行结束。");
    }
    //定义环绕通知
    public Object around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("调用："+jp.getTarget()+"的"+jp.getSignature().getName()+"方法，方法入参为："+Arrays.toString(jp.getArgs()));
        Object result = null;
        try {
            result = jp.proceed();
            System.out.println("调用："+jp.getTarget()+"的"+jp.getSignature().getName()+"方法，返回值为："+result);
            return result;
        } catch (Throwable throwable) {
            System.out.println(jp.getSignature().getName()+"方法发生异常"+throwable);
            throw throwable;
        }finally{
            System.out.println(jp.getSignature().getName()+"方法执行结束。");
        }
    }
}

编写配置文件

<?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:Content="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
        <!--开启自动扫描，扫描每个包下的所有bean-->
        <Content:component-scan base-package="dao,bean,aop,service"/>
    <!--配置切面-->
        <aop:config>
            <!--配置切入点-->
            <aop:pointcut id="pointcut" expression="execution(* service.UserService.*(..))"/>
            <!--引用包含通知方法的类-->
            <aop:aspect ref="myAOP">
                <!--定义前置通知-->
                <aop:before method="before" pointcut-ref="pointcut"/>
                <!--定义后置通知-->
                <aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="resultData"/>
                <!--定义异常通知-->
                <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="e"/>
                <!--定义最终通知-->
                <aop:after method="after" pointcut-ref="pointcut"/>
                <!--定义环绕通知-->
                <aop:around method="around" pointcut-ref="pointcut"/>
            </aop:aspect>
        </aop:config>
</beans>

以上配置文件中主要包含以下几项内容
1.在beans元素中需要添加aop命名空间，以导入与AOP相关的标签。
2.与AOP相关的配置都放在aop:config标签中。
3.aop:pointcut表示切入点，id属性为该切入点的名称，expression属性为该切入点的表达式，execution是切入点指示符，它的括号中是一个切入点表达式，可以配置需要切入增强处理的方法的特征，切入点表达式支持模糊匹配，以下为常用的模糊匹配：

public * addUser(entity.User): “*” 表示匹配所有类型的返回值。
public void (entity.User): "" 表示匹配所有的方法名。
public void addUser(…) “…” 表示匹配任意参数个数和类型。
* com.service.*.*(..): 匹配com.service包下所有类的所有方法。
* com.service..*.*(..): 匹配com.service包及其子包下所有类的所有方法。

4.aop:aspect引用通知的Bean，ref属性指定通知Bean的名称。

aop:before前置增强，属性pointcut-ref属性表示引用的切入点。
aop:after-returning 后置增强，属性pointcut-ref属性表示引用的切入点，returning属性表示需要注入返回值的属性名。

5.把通知处理插入切入点的过程称为织入，可以理解为把衣服上的Logo使用针线织入衣服的过程。

测试类：

public class UserServiceTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.addUser(new User(1,"张三",'男',22,"北京"));
    }
}

测试结果：
在这里插入图片描述
如果方法执行中遇到异常：不会执行后置通知

@Repository("userDao")
public class UserDaoImpl implements UserDao {
    @Override
    public int addUser(User user) {
        int i=2/0;//异常
        System.out.println("添加成功");
        return 1;
    }
}

在这里插入图片描述
注解方式实现
第1步: 添加jar包：和xml方式一样
Spring基本jar+AOP相关jar
第2步:编写切面类,设置切入点和通知 ·

第3步: 开启aspectj自动代理,并注册切面类

保存用户例子：
UserDAO接口和UserService接口及实现类和以上一样：

编写切面类设置切入点和通知：

package aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

//定义切面
@Aspect
@Component
public class MyAOP {
    //定义切入点
    @Pointcut("execution(* service.UserService.*(..))")
    public void pointcut(){}
    //定义前置通知
    @Before("pointcut()")
    public void before(JoinPoint jp){
        System.out.println("调用："+jp.getTarget()+"的"+jp.getSignature().getName()+"方法，方法入参："+ Arrays.toString(jp.getArgs()));
    }
    //定义后置通知
    @AfterReturning(pointcut = "pointcut()",returning = "resultData")
    public void afterReturning(JoinPoint jp,Object resultData){
        System.out.println("调用："+jp.getTarget()+"的"+jp.getSignature().getName()+"方法，返回值为："+resultData);
    }
    //定义异常通知
    @AfterThrowing(pointcut = "pointcut()",throwing = "e")
    public void afterThrowing(JoinPoint jp,RuntimeException e){
        System.out.println("调用："+jp.getSignature().getName()+"方法出现异常。"+e);
    }
    //定义最终通知
    @After("pointcut()")
    public void after(JoinPoint jp){
        System.out.println(jp.getSignature().getName()+"方法执行结束。");
    }
    //定义环绕通知
    @Around("pointcut()")
    public Object around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("调用："+jp.getTarget()+"的"+jp.getSignature().getName()+"方法，方法入参为："+Arrays.toString(jp.getArgs()));
        Object result = null;
        try {
            result = jp.proceed();
            System.out.println("调用："+jp.getTarget()+"的"+jp.getSignature().getName()+"方法，返回值为："+result);
            return result;
        } catch (Throwable throwable) {
            System.out.println(jp.getSignature().getName()+"方法发生异常"+throwable);
            throw throwable;
        }finally{
            System.out.println(jp.getSignature().getName()+"方法执行结束。");
        }
    }
}

在配置文件中开启aspectj自动代理：

<?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:Content="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
        <Content:component-scan base-package="service,bean,aop,dao"/><!--扫描包下所有的类-->
        <aop:aspectj-autoproxy/> <!--开启自动代理-->
</beans>

编写测试类：

package test;

import bean.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.UserService;

public class UserServiceTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.addUser(new User(1,"张胜男",'男',22,"北京"));
    }
}