Spring框架Day3--AOP的原理以及Spring中基于注解和xml的AOP配置

最新推荐文章于 2023-11-19 20:59:32 发布
最新推荐文章于 2023-11-19 20:59:32 发布
阅读量109 收藏
点赞数
文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42700882/article/details/112244830
版权

Spring框架

两大核心：IOC AOP
此篇将要讲解第二个核心AOP

第三天：

发现问题：

设想转账的场景，一方账户钱-，另一方账户钱+，-的和+的值理应相当。这是正常情况。但如果在转出和转入语句之间加一句会让运行时报错的语句，此时数据库里的值：转账方钱-，收款方钱没变。
在这里插入图片描述

原因分析：

在这里插入图片描述
QueryRunner多例，即在每次执行操作（CRUD）时都会从数据源中获取一个连接。在上上图transfer方法中和数据库交互了4次，也即建立了4次连接。前三次都成功提交了，然后发生了异常导致第四次不能提交，故造成了数据库数据没有满足事务一致性的原因。

解决思路：

为了让一整件事中的所有连接一起成功一起失败，需要进行捆绑，由同一个Connection控制。

解决方案：

使用ThreadLocal对象把Connection和当前线程绑定，使得一个线程中只有一个能控制事务的对象。创建以下两个工具类：

负责绑定线程和连接的工具类：ConnectionUtils.java

package com.itheima.utils;

import javax.sql.DataSource;
import java.sql.Connection;

/**
 * 连接的工具类，用于从数据源中获取连接，并且实现和线程的绑定
 */

public class ConnectionUtils {
    private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();

    private DataSource dataSource;//在这里不new 等待spring注入
    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    /**
     * 获取当前线程上的连接
     * @return
     */
    public Connection getThreadConnection(){
        try {
            //1.先从ThreadLocal上获取
            Connection conn = tl.get();
            //2.判断当前线程中有无连接
            if(conn == null){
                //3.若无，从数据源中获取一个连接，并且存入ThreadLocal中
                conn = dataSource.getConnection();
                tl.set(conn);
            }
            return conn;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 把连接和线程解绑
     */
    public void removeConnection(){
        tl.remove();
    }
}

负责事务管理的工具类：TransactionManager.java

package com.itheima;

import com.itheima.utils.ConnectionUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import java.sql.SQLException;

/**
 * 和事务管理相关的工具类，包含：开启事务、提交事务、回滚事务、释放连接
 */

public class TransactionManager {
    private ConnectionUtils connectionUtils;//等待spring注入
    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }

    /**
     * 开启事务--前置
     */
    public void beginTransaction(){
        try {
            connectionUtils.getThreadConnection().setAutoCommit(false);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    /**
     * 提交事务--后置
     */
    public void commitTransaction(){
        try {
            connectionUtils.getThreadConnection().commit();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    /**
     * 回滚事务--异常
     */
    public void rollbackTransaction(){
        try {
            connectionUtils.getThreadConnection().rollback();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    /**
     * 释放连接--最终
     */
    public void release(){
        try {
            connectionUtils.getThreadConnection().close();//还回连接池中
            connectionUtils.removeConnection();//把连接和线程解绑
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    //环绕通知
    public Object aroundTxManager(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try {
            Object[] args = pjp.getArgs();//得到方法执行所需要的参数
            System.out.println("环绕通知-前置");
            beginTransaction();
            rtValue = pjp.proceed(args);//明确调用业务层方法（切入点方法）
            System.out.println("环绕通知-后置");
            commitTransaction();
            return rtValue;
        } catch (Throwable throwable) {
            System.out.println("环绕通知-异常");
            rollbackTransaction();
            throw new RuntimeException(throwable);
        } finally {
            System.out.println("环绕通知-最终");
            release();
        }
    }
}

真正的事务控制应该写在业务层。

业务层 AccountServiceImpl.java 中：

1.注入事务管理工具类对象

2.在每个CRUD操作的方法中都要加上事务控制：开启事务-执行操作-提交事务-（返回结果）-（回滚操作）-释放连接

@Autowired
private TransactionManager txManager;

public List<Account> findAllAccount() {
    try {
        //1.开启事务
        txManager.beginTransaction();
        //2.执行操作
        List<Account> accounts = accountDao.findAllAccount();
        //3.提交事务
        txManager.commitTransaction();
        //4.返回结果
        return accounts;
    } catch (Exception e) {
        //5.回滚操作
        txManager.rollbackTransaction();
        throw new RuntimeException(e);
    } finally {
        //6.释放连接
        txManager.release();
    }
}

此时运行，如果在钱入账语句前放一句会报异常的语句，则双方的账号前都不变，即不转出也不转入，事务一致性达到。

问题再发现：

但是每个方法中都有同样的1、3、5、6步骤的代码使得整个业务层太冗余了。而动态代理能解决这种同样的反复出现的代码。

【引出动态代理】

动态代理：生产商一开始负责生产以及销售和售后，直接和顾客交接忙不过来，后来有了经销商专门负责销售和售后，成为了顾客和生产商中间的桥梁。经销商就是代理。

动态代理：
* 特点：字节码随用随创建，随用随加载
* 作用：在不修改源码的基础上对方法增强
* 分类：基于接口的动态代理
*      基于子类的动态代理


    * 基于接口的动态代理：
    *      涉及的类：Proxy
    *      提供者：JDK官方
    * 如何创建代理对象：
    *      使用Proxy类中的newProxyInstance方法
    * 创建代理对象的要求：
    *      被代理类最少实现一个接口，若没有则不能使用
    * newProxyInstance方法的参数：
    *      ClassLoader：类加载器，用于加载代理对象字节码，和被代理对象使用相同的类加载器
    *                   固定写法，代理谁就是谁.getClass().getClassLoader()
    *      Class[]:字节码数组，用于让代理对象和被代理对象有相同的方法（即实现同一个接口）
    *                   固定写法，代理谁就是谁.getClass().getInterfaces()
    *      InvocationHandler:用于提供增强的代码，让我们写如何代理。
    *                        我们一般都是写一个该接口的实现类，通常情况下是匿名内部类，但不是必须的。
    *                        此接口的实现类是谁用谁写。

    * 基于子类的动态代理：
    *      涉及的类：Enhancer
    *      提供者：第三方cglib库
    * 如何创建代理对象：
    *      使用Enhancer类中的create方法
    * 创建代理对象的要求：
    *      被代理类最不能是最终类
    * newProxyInstance方法的参数：
    *      Class：字节码，用于指定被代理对象的字节码
    *                   固定写法，代理谁就是谁.getClass().getClassLoader()
    *      Callback:用于提供增强的代码，让我们写如何代理。
    *               我们一般都是写一个该接口的实现类，通常情况下是匿名内部类，但不是必须的。
    *               此接口的实现类是谁用谁写。
    *               我们一般写的都是该接口的子接口实现类：MethodIntercepter

单独开一个例子讲解动态代理的两种类型：

现有Producer生产者 & Client消费者两个类，生产者负责saleProduct销售和afterSale售后功能，其中销售是通过经销商的，所以要分给经销商百分之20的利润。

1.基于接口的动态代理

​ 前提：被代理类Product类实现了一个接口，以下是Client类中代码，用proxy增强。

IProducer proxyProducer = (IProducer)Proxy.newProxyInstance(producer.getClass().getClassLoader(),
        producer.getClass().getInterfaces(),
        new InvocationHandler() {
            /**
             * 作用：执行被代码对象的任何接口方法都会经过该方法。
             * @param proxy    代理对象的引用
             * @param method   当前执行的方法
             * @param args     当前执行方法所需的参数
             * @return         和被代理对象方法有相同的返回值
             * @throws Throwable
             */
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //提供增强的代码
                Object returnValue = null;
                //1.获取方法执行的参数
                Float money = (Float)args[0];
                //2.判断当前方法是不是销售
                if("saleProduct".equals(method.getName())){
                    //消费者付的钱中：80%的钱归producer,20%归代理商（经销商）
                    returnValue = method.invoke(producer,money*0.8f);
                }
                return returnValue;
            }
        });
proxyProducer.saleProduct(10000f);

2.基于子类的动态代理

​ 前提：被代理类最不能是最终类

Producer cglibProducer = (Producer) Enhancer.create(producer.getClass(), new MethodInterceptor() {
    /**
     * 执行被代理对象的任何方法都会经过该方法
     *
     * @param o
     * @param method
     * @param objects
     *    以上三个参数和基于接口的动态代理中invoke方法的参数是一样的（proxy，method，args）
     * @param methodProxy   当前执行方法的代理对象
     * @return
     * @throws Throwable
     */
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        //提供增强的代码
        Object returnValue = null;
        //1.获取方法执行的参数
        Float money = (Float)objects[0];
        //2.判断当前方法是不是销售
        if("saleProduct".equals(method.getName())){
            //消费者付的钱中：80%的钱归producer,20%归代理商（经销商）
            returnValue = method.invoke(producer,money*0.8f);
        }
        return returnValue;
    }
});
cglibProducer.saleProduct(1200f);

在项目中动态代理的优势：1.连接池，对connection的close（）方法增强，加回到池里。2.request方法增强。

回到刚刚Account的项目中

刚刚提到每个CRUD方法都要写开启、提交、回滚、释放事务的代码过于冗余。可以用动态代理对每个方法增强。

解决：创建一个工厂类BeanFactory.java, 用于创建业务层的代理对象的工厂。这样一来，IAccountService类中的所有方法只需要完成业务逻辑，事务控制交给此工厂类。
好处：
1.达到分离的效果
2.提高代码可重用性，提高开发效率
3.便于维护

工厂类BeanFactory:

package com.itheima.factory;

import com.itheima.TransactionManager;
import com.itheima.service.IAccountService;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 用于创建Service的代理对象的工厂
 */
public class BeanFactory {

    private IAccountService accountService;//等待注入

    public final void setAccountService(IAccountService accountService) {
        this.accountService = accountService;
    }

    private TransactionManager txManager;//等待spring注入

    public void setTxManager(TransactionManager txManager) {
        this.txManager = txManager;
    }

    /**
     * 获取Service代理对象
     *
     * @return
     */
    public IAccountService getAccountService() {
        return (IAccountService) Proxy.newProxyInstance(accountService.getClass().getClassLoader(),
                accountService.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     * 添加事务的支持
                     * @param proxy
                     * @param method
                     * @param args
                     * @return
                     * @throws Throwable
                     */
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        Object rtValue = null;
                        try {
                            //1.开启事务
                            txManager.beginTransaction();
                            //2.执行操作
                            rtValue = method.invoke(accountService, args);
                            //3.提交事务
                            txManager.commitTransaction();
                            //4.返回结果
                            return rtValue;
                        } catch (Exception e) {
                            //5.回滚事务
                            txManager.rollbackTransaction();
                            throw new RuntimeException(e);
                        } finally {
                            //6.释放连接
                            txManager.release();
                        }
                    }
                });
    }
}

AOP（Aspect Oriented Programming）：面向切面编程

作用：在程序运行期间不修改源码，对已有方法增强。

实现：动态代理技术【上述】

Spring中的AOP是通过配置的方式【注解 & xml】实现上述的工厂代理类

AOP术语：

  1. JoinPoint（连接点）-- 业务层中所有的方法。
  2. Pointcut（切入点）-- 业务层中需要被增强的方法，有些不需要被增强的方法直接pass。【所有的切入点都是连接点】
  3. Advice（通知/增强）-- 拦截到连接点后要做的事务支持的事情。其中：开启事务->前置通知、提交事务->后置通知、回滚操作->异常通知、释放连接->最终通知，环绕通知：从前置到最终的整个过程。
  4. Target（目标对象）-- 被代理对象
  5. Weaving（织入）-- 加入事务支持的过程
  6. Proxy（代理）-- 一个类被AOP织入增强后，就产生一个结果代理类
  7. Aspect（切面）-- 切入点和通知的结合（配置对应关系）

Spring基于xml的AOP配置：

Spring中基于xml的aop配置步骤
    1.把通知Bean也交给Spring来管理
    2.使用aop：config标签表明开始aop配置
    3.使用aop：aspect标签表明配置切面
               id属性：是给切面提供一个唯一标识
               ref属性：是指定通知类bean的id
    4.在aop：aspect标签的内部使用对应的标签来配置通知的类型
            aop：before：表示配置前置通知
            method属性：用于指定logger类中哪个方法是前置通知
            pointcut:用于指定切入点表达式，该表达式的含义指的是对业务层中哪些方法增强

            切入点表达式的写法：
                关键字：execution
                表达式：访问修饰符 返回值 包名.包名.包名.....类名.方法名（参数）
                标准写法：public void com.itheima.service.impl.AccountServiceImpl.saveAccount()
                【访问修饰符可省略】
                返回值可以使用通配符表示任何返回值：
                         * com.itheima.service.impl.AccountServiceImpl.saveAccount()
                包名可以使用通配符 表示任意包 但是有几级包就需要几个*. ：
                         * *.*.*.*.AccountServiceImpl.saveAccount()
                包名可以使用..表示当前包及其子包：
                         * *..AccountServiceImpl.saveAccount()
                类名和方法名都可以使用*来实现通配：
                         * *..*.*()
                参数列表：
                         1.可以直接写数据类型：
                             基本类型直接写名称        int
                             引用类型写包名.类名的方式  java.lang.Spring
                         2.可以使用通配符表示任意类型，但是必须有参数
                         3.可以使用..表示有无参数均可，有参数可以是任意类型
                全通配写法：（但是可能配多了 有些满足全通配写法的切入点表达式的方法不需要被增强也被增强了）
                         * *..*.*(..)
                实际开发中切入点表达式的通常写法：
                         切到业务层实现类下的所有方法：  * com.itheima.service.impl.*.*(..)

在bean.xml配置文件中，

  1. 导入依赖：xmlns:aop

  2. 配置业务层对象

  3. 配置通知类

  4. 配置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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--配置Spring的IOC，把Service对象配置进来-->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>

    <!--1.配置Logger类-->
    <bean id="logger" class="com.itheima.service.utils.Logger"></bean>
    <!--2.配置aop-->
    <aop:config>
        <!--配置切入点表达式，id属性用于指定表达式的唯一标识，下面都可用id来指代对应的表达式，使得更加简洁。
            此标签写在aop：aspect标签内部只能适用于当前切面使用
            还可以写在aop：aspect外面，此时变成了所有切面可用，但是一定要放在所有aop：aspect之前写（以此种情况为例）-->
        <aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..))"></aop:pointcut>
        <!--配置切面-->
        <aop:aspect id="logAdvice" ref="logger">
            <!--配置通知的类型 + 建立通知方法和切入点方法的关联-->
<!--            <aop:before method="beforePrintLog" pointcut-ref="pt1"></aop:before>-->
<!--            <aop:after-returning method="afterReturningPrintLog" pointcut-ref="pt1"></aop:after-returning>-->
<!--            <aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"></aop:after-throwing>-->
<!--            <aop:after method="afterPrintLog" pointcut-ref="pt1"></aop:after>-->
            <!--配置环绕通知 详细注释请看logger类中-->
                <aop:around method="aroundPrintLog" pointcut-ref="pt1"></aop:around>
        </aop:aspect>
    </aop:config>
</beans>

通知类Logger.java

package com.itheima.service.utils;
import org.aspectj.lang.ProceedingJoinPoint;

public class Logger {
    /**
     * 前置通知
     */
    public void beforePrintLog(){
        System.out.println("前置通知->Logger类中的beforePrintLog方法开始记录日志了。");
    }

    /**
     * 后置通知
     */
    public void afterReturningPrintLog(){
        System.out.println("后置通知->Logger类中的afterReturningPrintLog方法开始记录日志了。");
    }

    /**
     * 异常通知
     */
    public void afterThrowingPrintLog(){
        System.out.println("异常通知->Logger类中的afterThrowingPrintLog方法开始记录日志了。");
    }

    /**
     * 最终通知
     */
    public void afterPrintLog(){
        System.out.println("最终通知->Logger类中的afterPrintLog方法开始记录日志了。");
    }

    /**
     * 环绕通知
     * 问题:当配置了环绕通知之后，切入点方法没有执行，而通知方法执行了
     * 分析：通过对比动态代理中的环绕通知代码，发现动态代理的环绕通知有明确的切入点调用，而此处代码中没有
     * 解决：Spring框架为我们提供了一个接口：ProceedingJoinPoint,该接口有一个方法：Proceed()，该方法相当于明确调用切入点方法
     *      该接口可以作为环绕通知的方法参数，在程序执行是spring框架会我们提供该接口的实现类供我们使用
     * Spring中的环绕通知：
     *      是框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式。
     *
     * 既可以配置通知，也可以在代码中写环绕通知。
     */
    public Object aroundPrintLog(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try {
            Object[] args = pjp.getArgs();//得到方法执行所需要的参数
            System.out.println("环绕通知-前置->Logger类中的aroundPrintLog方法开始记录日志了。");
            rtValue = pjp.proceed(args);//明确调用业务层方法（切入点方法）
            System.out.println("环绕通知-后置->Logger类中的aroundPrintLog方法开始记录日志了。");
            return rtValue;
        } catch (Throwable throwable) {
            System.out.println("环绕通知-异常->Logger类中的aroundPrintLog方法开始记录日志了。");
            throw new RuntimeException(throwable);
        } finally {
            System.out.println("环绕通知-最终->Logger类中的aroundPrintLog方法开始记录日志了。");
        }
    }
}

Spring基于注解的AOP配置：

bean.xml：
只剩下以下两个，可以都用注解代替：(此时需要写在主配置类里)
@ComponentScan
@EnableTransactionManagement
但不想建配置类了，懒。

  1. 加入依赖：xmlns:context
  2. 扫包
  3. 配置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: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">

    <!--配置Spring创建容器时要扫描的包-->
    <context:component-scan base-package="com.itheima"></context:component-scan>

    <!--配置spring开启注解的AOP支持-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

Logger类：

​ 切记：@Before(“pt1()”)中的括号不能省！

package com.itheima.service.utils;

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

@Component("logger")
@Aspect//表示当前类是切面类
public class Logger {
    @Pointcut("execution(* com.itheima.service.impl.*.*(..))")
    private void pt1(){}

  //  @Before("pt1()")
    public void beforePrintLog(){
        System.out.println("前置通知->Logger类中的beforePrintLog方法开始记录日志了。");
    }

   // @AfterReturning("pt1()")
    public void afterReturningPrintLog(){
        System.out.println("后置通知->Logger类中的afterReturningPrintLog方法开始记录日志了。");
    }
    
   // @AfterThrowing("pt1()")
    public void afterThrowingPrintLog(){
        System.out.println("异常通知->Logger类中的afterThrowingPrintLog方法开始记录日志了。");
    }

  //  @After("pt1()")
    public void afterPrintLog(){
        System.out.println("最终通知->Logger类中的afterPrintLog方法开始记录日志了。");
    }
    
    @Around(("pt1()"))
    public Object aroundPrintLog(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try {
            Object[] args = pjp.getArgs();//得到方法执行所需要的参数
            System.out.println("环绕通知-前置->Logger类中的aroundPrintLog方法开始记录日志了。");
            rtValue = pjp.proceed(args);//明确调用业务层方法（切入点方法）
            System.out.println("环绕通知-后置->Logger类中的aroundPrintLog方法开始记录日志了。");
            return rtValue;
        } catch (Throwable throwable) {
            System.out.println("环绕通知-异常->Logger类中的aroundPrintLog方法开始记录日志了。");
            throw new RuntimeException(throwable);
        } finally {
            System.out.println("环绕通知-最终->Logger类中的aroundPrintLog方法开始记录日志了。");
        }
    }
}

结束！

不试一下怎么知道我不行？
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
【框架源码篇 03】Spring源码手写篇-手写AOP
10-21
【Spring源码篇 03】Spring源码手写篇-手写AOP Spring框架是Java开发中广泛使用的轻...通过阅读和学习这些代码，你可以更深入地掌握Spring AOP的工作原理，这对于提升你的Spring框架应用能力和源码阅读能力大有裨益。
spring AOP和事务
weixin_44343761的博客
10-07 244
前置项目用来引出AOP的作用 ​ 实现转账功能,aaa转账给bbb package cn.tedu.service.impl; import cn.tedu.dao.IAccountDao; import cn.tedu.entity.Account; import cn.tedu.service.IAccountService; import cn.tedu.utils.TransactionManager; import java.util.List; /** * 账户业务
Spring AOP之异步执行@Aync
诗人不写诗
05-04 4453
异步执行的功能在业务场景中使用的地方不多，但是这种功能不可或缺。Spring给我们提供了很方便的使用方式，这里来解析一下这个功能。异步执行肯定要使用到线程，所以在SpringBoot中肯定有配置线程池的地方，因为所有的异步任务都会丢给线程池来执行。 事实上，Spring就是这么做的，如果你没有配置线程池，那么Spring每次在执行异步任务时，会即时新建一个线程来执行任务，如果你配置了自己的线程池，那么异步任务会交给配置的线程池来执行。在应用中有较高频率使用异步任务的情况下，最好是配置线程池，用于节省线程创建
Spring（三）父子容器、国际化、异步调用、定时器、缓存
HK的博客
05-01 3494
父子容器、国际化、@Async、@Scheduled、@Cacheable
java 切面 不执行,解决springboot的aop切面不起作用问题(失效的排查)
weixin_42650811的博客
03-11 5359
检查下springboot的启动类是否开启扫描@springbootapplication@componentscan(basepackages = {"com.zhangpu.springboot"})另外springboot默认开启的enableaspectjautoproxy为true如果不放心可以增加：@enableaspectjautoproxy(proxytargetclass=tru...
AOP切面编程以及事务管理
九点六
05-13 388
💎AOP切面编程 📄AOP概念与原理 ✂AOP编程的概念 AOP切面编程能帮助我们在不修改现有代码的情况下，对程序的功能进行扩展，符合程序的“开闭原则”（对扩展开放，对修改封闭），往往用于实现日志处理，权限控制，性能检测，事务控制。 📝AOP的原理 AOP的实现原理就是利用动态代理； 在有接口的情况下，使用JDK动态代理； 在没有接口的情况下，使用cglib动态代理 🧾AOP的常用术语 1、连接点 Joint point 类中可以被增强的方法，称为连接点 2、切入点 Pointcut 实际被增强的方法 3
day3-springAOP.md
10-15
通过配置 XML 文件或者使用注解，开发者可以方便地定义切面、通知以及切入点等。Spring AOP 主要依赖于动态代理技术，具体而言： - 当代理对象实现接口时，Spring 使用 JDK 动态代理。 - 当代理对象没有实现接口时...
day39-Spring 06-Spring的AOP：带有切点的切面
04-26
在"day39-Spring 06-Spring的AOP：带有切点的切面"这个主题中，我们将深入探讨如何在Spring中实现带有切点的切面，以及它们如何与源码和工具结合使用。 首先，理解AOP的基本概念非常重要。AOP的核心是切面（Aspect...
day2-Spring IOC 和 DI 注解开发.md
10-15
### Spring IOC与DI注解开发知识点详解 #### 一、Spring框架...通过以上内容，我们可以了解到Spring框架中IOC和DI的基本概念，以及如何配置和使用数据源（连接池）。这为开发高效稳定的企业级应用提供了坚实的基础。
【框架源码篇 04】Spring源码手写篇-Bean定义配置化
10-21
在本篇【框架源码篇 04】中，我们将深入探讨Spring框架的核心概念——Bean定义配置化。Spring是Java领域最广泛使用的依赖注入（Dependency Injection，简称DI）和面向切面编程（Aspect-Oriented Programming，简称...
spring笔记下(AOP、事务管理)
白豆五的博客
01-26 1362
todo
脏读、不可重复读、幻读
chengwai26的博客
08-08 330
1. 脏读 ：脏读就是指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问 这个数据，然后使用了这个数据。 2. 不可重复读 ：是指在一个事务内，多次读同一数据。在这个事务还没有结束时，另外一个事务也访问该同一数据。那么，在第一个事务中的两 次读数据之间，由于第二个事务的修改，那么第一个事务两次读到的的数据可能是不一样的。这样就发生了在一个事务
5.1 Spring_AOP_事务
weixin_45813215的博客
05-03 325
AOP 1.1 AOP简介和作用【理解】 AOP(Aspect Oriented Programming)面向切面编程，一种编程范式，指导开发者如何组织程序结构 OOP(Object Oriented Programming)面向对象编程 作用：在不惊动原始设计的基础上为其进行功能增强。简单的说就是在不改变方法源代码的基础上对方法进行功能增强。 Spring理念：无入侵式/无侵入式 面向对象(OOP)->面向切面(AOP) 面向切面(AOP): 是一种编程思想 动态代理 动态代理: 其实就
AOP、spring事务管理
weixin_52270382的博客
05-09 588
AOP简介、AOP入门案例、AOP配置管理、AOP通知类型、业务层接口执行效率、AOP通知获取数据、百度网盘密码数据兼容、处理AOP事务管理
Spring中AOP及事务管理详解
阿杰的博客
09-05 1098
AOP：Aspect Oriented Programming，面向切面编程。是通过预编译方式（aspectj）或者运行期动态代理（Spring）实现程序功能的统一维护的技术。AOP是OOP（面向对象编程）的技术延续，是软件开发中的一个热点，也是Spring中的一个重要内容。利用AOP可以实现对业务逻辑各个部分之间的隔离，从而使得业务逻辑各部分之间的耦合性降低，提高程序的可重用性，同时提高了开发效率。作用：不修改源码的情况下，进行功能增强，通过动态代理实现的优势：减少重复代码，提高开发效率，方便维护比如：给
Spring AOP与事务
weixin_65440201的博客
09-02 474
AOP是在不改原有代码的前提下对其进行增强。面向切面编程，一种编程范式，指导开发者如何组织程序结构。AOP是一种编程思想，编程思想主要的内容就是指导程序员该如何编写程序。1.2AOP作用作用:在不惊动原始设计的基础上为其进行功能增强，前面咱们有技术就可以实现这样的功能即代理模式。1.3AOP核心概念为了能更好的理解AOP的相关概念，我们准备了一个环境，整个环境的内容我们暂时可以不用关注，最主要的类为://记录程序当前执行执行（开始时间）//业务执行万次i
Spring AOP及事务说明
m0_72167535的博客
04-05 903
事务的传播行为我们只需要掌握两个：REQUIRED、REQUIRES_NEW。REQUIRED ：大部分情况下都是用该传播行为即可。REQUIRES_NEW ：当我们不希望事务之间相互影响时，可以使用该传播行为。比如：下订单前需要记录日志，不论订单保存成功与否，都需要保证日志记录能够记录成功。什么是AOP？* AOP英文全称：Aspect Oriented Programming（面向切面编程、面向方面编程），其实说白了，面向切面编程就是面向特定方法编程。
Spring AOP和事务学习
2301_80951806的博客
11-19 38
1.1：事务的简介：举个简单的例子，转账业务会有两次数据层的调用，一次是加钱一次是减钱把事务放在数据层，加钱和减钱就有两个事务没办法保证加钱和减钱同时成功或者同时失败这个时候就需要将事务放在业务层进行处理。Spring为了管理事务，提供了一个平台事务管理器PlatformTransactionManager。1.2事务的概念：事务是数据库操作的最小工作单元，是作为单个逻辑工作单元执行的一系列操作，这些操作作为一个整体一起向系统提交，要么都执行、要么都不执行；
spring-boot-starter-aop和spring-boot-starter-parent的区别
最新发布
03-17
spring-boot-starter-aop和spring-boot-starter-parent是Spring Boot框架的两个重要组件，它们有以下区别： 1. spring-boot-starter-aop： - spring-boot-starter-aop是一个用于支持面向切面编程（AOP）的Spring ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不试一下怎么知道我不行？

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值