JAVA spring框架学习笔记（三）

最新推荐文章于 2024-09-27 00:45:01 发布

Kwjdefulgn

最新推荐文章于 2024-09-27 00:45:01 发布

阅读量110

点赞数

文章标签： java spring

本文链接：https://blog.csdn.net/weixin_42038564/article/details/116267654

版权

本文详细介绍了Spring框架中的AOP（面向切面编程）概念，包括连接点、切入点、通知、切面和织入等核心概念，并通过实例展示了如何使用@AspectJ注解实现各种类型的通知（前置、返回、异常、最终和环绕）。此外，还讨论了AOP在日志记录、性能统计和事务处理等场景中的应用，强调了其降低耦合度、提高代码复用性和系统扩展性的作用。

摘要由CSDN通过智能技术生成

JAVA spring框架学习笔记（三）

AOP（面向切面编程）： 相较于oop面向对象编程来说，AOP关注的不再是程序代码中某个类，某些方法，AOP考虑的更多是一种面到面的切入，即层到层的一种切入。

AOP的应用： 主要应用于日志记录、性能统计、安全控制、事务处理等方面。

AOP的特点：

降低模块间的耦合度，提高业务代码的聚合度（高内聚低耦合）
提高了代码的复用性
提高系统的扩展性
可在不影响原有功能的基础上添加新功能

AOP基本概念
Joinpoint（连接点）
指被拦截到的每个点，即spring中被拦截到的每一个方法，一个连接点代表一个方法的执行。

Pointcut（切入点）
对连接点进行拦截的定义（即规定拦截哪些方法，对哪些方法进行处理）

Advice（通知）
拦截到每一个连接点（每一个方法）之后所要做的后序操作。

前置通知——before（）执行方法前的通知
返回通知——afterReturn（）方法正常结束返回后的通知
异常抛出通知——afterReturn（）
最终通知——after（）无论方法是否异常，均会执行该通知。类似于一个异常检测中的final
环绕通知——around（）

Aspect（切面）
切入点与通知的结合。切面是针对大量的类。

Weave（织入）
将切面应用到目标对象并生成代理对象的过程。

Introduction（引入）
在不修改原有应用程序代码的情况下，在程序运行期为类动态添加方法或字段的过程。

AOP5五种通知实例：

// LogCut：定义切面: 切点+通知
package com.ltc.aspect;

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 由切入点与通知的结合
 * 
 * 定义切入点 Pointcut 规定需要拦截哪些方法，哪些方法需要处理 @PointCut("匹配规则")
 * 
 * 定义通知 前置通知 @Before 返回通知 @AfterReturn 异常通知 @AfterThrowing 最终通知 @After
 * 环绕通知 @Around
 */
@Component // 将对象交给IOC容器维护
@Aspect // 表示当前是一个切面类
public class LogCut {
    /**
     * 定义切入点
     * 
     * 注：表达式的第一个* 代表的是方法的修饰范围 可选项：private protected public(* 表示所有范围)
     */
    @Pointcut("execution(* com.ltc..*.*(..))")
    public void cut() {
        System.out.println("cut");
    }

    /**
     * 定义前置通知 方法执行前的通知
     */
    // value中的value字段的方法名一定要加括号表示是一个方法
    @Before(value = "cut()")
    public void before() {
        System.out.println("前置通知... 方法执行前执行的通知");
    }

    /**
     * 定义返回通知...方法正常执行完时执行的通知(出现异常时不会通知)
     */
    @AfterReturning(value = "cut()")
    public void afterReturn() {
        System.out.println("返回通知.. 方法正常执行时执行的通知");
    }

    /**
     * 定义最终通知 方法正常执行完时的通知(无论方法能否正常执行，即出现异常时也会通知)
     */

    @After(value = "cut()")
    public void after() {
        System.out.println("最终通知...方法执行结束后执行的通知");
    }

    /**
     * 定义异常通知 方法执行抛出异常时执行的通知
     */
    @AfterThrowing(value = "cut()", throwing = "e")
    public void throwReturn(Exception e) {
        System.out.println("异常通知...方法执行抛出异常时执行的通知" + e.getMessage());
    }

    // 环绕通知包含实现了上述四种通知
    @Around(value = "cut()")
    public Object around(ProceedingJoinPoint pjp) {
        // 前置通知
        System.out.println("环绕通知-前置通知...");
        Object object = null;
        try {
            object = pjp.proceed();
            // 返回通知
            System.out.println("环绕通知-返回通知...");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("环绕通知-异常通知...");
        }

        // 最终通知
        System.out.println("环绕通知-最终通知...");

        return object;
    }
}

package com.ltc.service;

import org.springframework.stereotype.Service;

@Service
public class UserService {

    public void test() {
        int i = 1 / 0;
        System.out.println("UserService...");
    }

}

package com.ltc.dao;

import org.springframework.stereotype.Repository;

@Repository
public class UserDao {
    public void test() {
        System.out.println("UserDao...");
    }
}

package com.ltc;

import com.ltc.dao.UserDao;
import com.ltc.service.UserService;

import org.apache.naming.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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

        // 得到上下文环境
        ClassPathXmlApplicationContext cp = new ClassPathXmlApplicationContext("spring.xml");

        UserService userService = (UserService) cp.getBean("userService");
        userService.test();

        // UserDao userDao = (UserDao) cp.getBean("userDao");
        // userDao.test();
        // System.out.println("okkkk");
    }
}

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"
    xmlns:context="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">

    <!-- 开启自动扫描，并设置扫描范围 -->
    <context:component-scan base-package="com.ltc"/>
    <!-- 开启aop自动代理 -->
    <aop:aspectj-autoproxy/>
</beans>

若不想使用@aspect等注解的方式，也可以在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"
    xmlns:context="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">

    <!-- 开启自动扫描，并设置扫描范围 -->
    <context:component-scan base-package="com.ltc"/>
    <aop:config> 
           <!-- ref中所有的方法名首字母都需要小写！！！ -->
        <aop:aspect ref="logCut">
            <!-- 定义切点 id对应的是切面类中的切入点的方法-->
            <aop:pointcut id="cut" expression="execution(* com.ltc..*.*(..))"/>
            <aop:before method="before" pointcut-ref="cut"/>
            <aop:after-returning method="afterReturn" pointcut-ref="cut"/>
            <aop:after-throwing method="throwReturn" throwing="e" pointcut-ref="cut"/>
            <aop:after method="after" pointcut-ref="cut"/>
            <aop:around method="around" pointcut-ref="cut"/>
        </aop:aspect>
    </aop:config>
</beans>