【Spring学习笔记】—— （三）AOP

最新推荐文章于 2022-08-12 16:03:23 发布
最新推荐文章于 2022-08-12 16:03:23 发布
阅读量341 收藏
点赞数
分类专栏： Java学习路线 # SSM 文章标签： spring java aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41133986/article/details/104904572
版权

系列博客：

文章目录

一、案例分析

/**
 * 账户的业务层实现类
 *
 * 事务控制应该都是在业务层
 */
public class AccountServiceImpl implements IAccountService{

    private IAccountDao accountDao;

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    @Override
    public List<Account> findAllAccount() {
       return accountDao.findAllAccount();
    }

    @Override
    public Account findAccountById(Integer accountId) {
        return accountDao.findAccountById(accountId);

    }

    @Override
    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }

    @Override
    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }

    @Override
    public void deleteAccount(Integer acccountId) {
        accountDao.deleteAccount(acccountId);
    }
}

1. 存在的问题

问题就是： 事务被自动控制了。换言之，我们使用了 connection 对象的 setAutoCommit(true) 此方式控制事务，如果我们每次都执行一条 sql 语句，没有问题，但是如果业务方法一次要执行多条 sql 语句，这种方式就无法实现功能了。

请看下面的示例： 我们在业务层中多加入一个方法。

   @Override
    public void transfer(String sourceName, String targetName, Float money) {
        System.out.println("transfer....");
            //2.1根据名称查询转出账户
            Account source = accountDao.findAccountByName(sourceName);
            //2.2根据名称查询转入账户
            Account target = accountDao.findAccountByName(targetName);
            //2.3转出账户减钱
            source.setMoney(source.getMoney()-money);
            //2.4转入账户加钱
            target.setMoney(target.getMoney()+money);
            //2.5更新转出账户
            accountDao.updateAccount(source);

			int i=1/0; //此语句出错

            //2.6更新转入账户
            accountDao.updateAccount(target);
    }

ini i = 1/0 这条语句是错误的，无法执行，则 2.6 也无法执行，转账失败。
但是因为我们是每次执行持久层方法都是独立事务，导致无法实现事务控制（不符合事务的一致性）

2. 解决问题

解决办法： 让业务层来控制事务的提交和回滚


/**
 * 账户的业务层实现类
 *
 * 事务控制应该都是在业务层
 */
public class AccountServiceImpl_OLD implements IAccountService{

    private IAccountDao accountDao;
    private TransactionManager txManager;

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

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

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

    }

    @Override
    public Account findAccountById(Integer accountId) {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            Account account = accountDao.findAccountById(accountId);
            //3.提交事务
            txManager.commit();
            //4.返回结果
            return account;
        }catch (Exception e){
            //5.回滚操作
            txManager.rollback();
            throw new RuntimeException(e);
        }finally {
            //6.释放连接
            txManager.release();
        }
    }

    @Override
    public void saveAccount(Account account) {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            accountDao.saveAccount(account);
            //3.提交事务
            txManager.commit();
        }catch (Exception e){
            //4.回滚操作
            txManager.rollback();
        }finally {
            //5.释放连接
            txManager.release();
        }

    }

    @Override
    public void updateAccount(Account account) {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            accountDao.updateAccount(account);
            //3.提交事务
            txManager.commit();
        }catch (Exception e){
            //4.回滚操作
            txManager.rollback();
        }finally {
            //5.释放连接
            txManager.release();
        }

    }

    @Override
    public void deleteAccount(Integer acccountId) {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            accountDao.deleteAccount(acccountId);
            //3.提交事务
            txManager.commit();
        }catch (Exception e){
            //4.回滚操作
            txManager.rollback();
        }finally {
            //5.释放连接
            txManager.release();
        }

    }

    @Override
    public void transfer(String sourceName, String targetName, Float money) {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作

            //2.1根据名称查询转出账户
            Account source = accountDao.findAccountByName(sourceName);
            //2.2根据名称查询转入账户
            Account target = accountDao.findAccountByName(targetName);
            //2.3转出账户减钱
            source.setMoney(source.getMoney()-money);
            //2.4转入账户加钱
            target.setMoney(target.getMoney()+money);
            //2.5更新转出账户
            accountDao.updateAccount(source);

            int i=1/0;

            //2.6更新转入账户
            accountDao.updateAccount(target);
            //3.提交事务
            txManager.commit();

        }catch (Exception e){
            //4.回滚操作
            txManager.rollback();
            e.printStackTrace();
        }finally {
            //5.释放连接
            txManager.release();
        }


    }
}

TransActionManager

/**
 * 和事务管理相关的工具类，它包含了，开启事务，提交事务，回滚事务和释放连接
 */
public class TransactionManager {

    private ConnectionUtils connectionUtils;

    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }

    /**
     * 开启事务
     */
    public  void beginTransaction(){
        try {
            connectionUtils.getThreadConnection().setAutoCommit(false);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /**
     * 提交事务
     */
    public  void commit(){
        try {
            connectionUtils.getThreadConnection().commit();
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /**
     * 回滚事务
     */
    public  void rollback(){
        try {
            connectionUtils.getThreadConnection().rollback();
        }catch (Exception e){
            e.printStackTrace();
        }
    }


    /**
     * 释放连接
     */
    public  void release(){
        try {
            connectionUtils.getThreadConnection().close();//还回连接池中
            connectionUtils.removeConnection();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

3. 新的问题

上面通过对业务层的改造，已经可以实现事务控制了，但是由于我们添加了事务控制，也产生了一个新的问题： 业务层方法变得臃肿了，里面充斥着很多重复代码。并且业务层方法和事务控制方法耦合了。
试想一下，如果我们此时提交，回滚，释放资源中任何一个方法名变更，都需要修改业务层的代码，况且这还只是一个业务层实现类，而实际的项目中这种业务层实现类可能有十几个甚至几十个。

4. 解决问题 - 动态代理

使用 动态代理 技术解决

动态代理解析参见此篇博客：Java - 反射/动态代理

5. 动态代理的特点

字节码随用随创建，随用随加载。
它与 静态代理 的区别也在于此。因为 静态代理 是字节码一上来就创建好，并完成加载。
装饰者模式 就是 静态代理 的一种体现。

6. 动态代理常用的有两种方式

  1. 使用 JDK 官方的 Proxy 类创建代理对象
/**
 * 定义一个接口
 */
interface Hello{
    void morning(String name);
}

/**
 * 动态代理创建接口实例
 */
public class dynamic_proxy{
    public static void main(String[] args) {
        InvocationHandler handler = new InvocationHandler(){
        
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println(method);
                if(method.getName().equals("morning")){
                    System.out.println("Good Morning," + args[0]);
                }
                return null;
            }
        };
        Hello hello = (Hello) Proxy.newProxyInstance(Hello.class.getClassLoader(), new Class[]{Hello.class}, handler);
        hello.morning("Jack");
        

    }
}
  1. 使用 CGLib 的 Enhancer 类创建代理对象
    在这里插入图片描述

7. 解决案例中的问题

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

    private IAccountService accountService;

    private TransactionManager txManager;

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


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

    /**
     * 获取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
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        if("test".equals(method.getName())){
                            return method.invoke(accountService,args);
                        }

                        Object rtValue = null;
                        try {
                            //1.开启事务
                            txManager.beginTransaction();
                            //2.执行操作
                            rtValue = method.invoke(accountService, args);
                            //3.提交事务
                            txManager.commit();
                            //4.返回结果
                            return rtValue;
                        } catch (Exception e) {
                            //5.回滚操作
                            txManager.rollback();
                            throw new RuntimeException(e);
                        } finally {
                            //6.释放连接
                            txManager.release();
                        }
                    }
                });

    }
}

二、Spring 中的 AOP

1. 什么是 AOP

Aspect Oriented Programming: 面向切面编程。通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。降低耦合，提高程序的可重用性，同时提高开发效率。

简单的说：就是把程序中重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。

2. AOP 的作用和优势

  • 降低耦合
  • 减少重复代码
  • 提高开发效率
  • 维护方便

3. AOP 的实现方式

动态代理

三、基于 XML 的 AOP 配置

1. 代码准备

/**
 * 账户的业务层接口
 */
public interface IAccountService {

    /**
     * 模拟保存账户
     */
   void saveAccount();

    /**
     * 模拟更新账户
     * @param i
     */
   void updateAccount(int i);

    /**
     * 删除账户
     * @return
     */
   int  deleteAccount();
}

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
public class Logger {

    /**
     * 用于打印日志：计划让其在切入点方法执行之前执行（切入点方法就是业务层方法）
     */
    public  void printLog(){
        System.out.println("Logger类中的pringLog方法开始记录日志了。。。");
    }
}

利用 AOP 实现每次调用 service 的方法之前都调用 printLog 方法

2. 具体配置步骤

a. 导入约束和依赖

<?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
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
  		
  	<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>

        <!--负责解析切入点表达式-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.7</version>
        </dependency>
    </dependencies>
  		
</beans>

b. 配置 Spring 的 IoC

<!-- 配置srping的Ioc,把service对象配置进来-->
<bean id="accountService" class="com.smallbeef.service.impl.AccountServiceImpl"></bean>

<!-- 配置Logger类 -->
<bean id="logger" class="com.smallbeef.utils.Logger"></bean>

c. 配置 AOP

  • 使用 aop:config 标签表明开始 AOP 的配置
  • 使用 aop:aspect 标签表明配置切面
    id 属性：是给切面提供一个唯一标识
    ref 属性：是指定通知类 bean 的 id。
  • 在 aop:aspect 标签的内部使用对应标签来配置通知的类型（四种常用的通知类型 见下文）
    我们现在示例是让 printLog 方法在切入点方法执行之前之前：所以是前置通知
    aop:before：表示配置前置通知
    method 属性：用于指定Logger类中哪个方法是前置通知
    pointcut 属性：用于指定 切入点表达式，该表达式的含义指的是对业务层中哪些方法增强

切入点表达式的写法：
关键字：execution (表达式)
表达式：
访问修饰符 返回值 包名.包名.包名…类名.方法名(参数列表)


标准的表达式写法：
public void com.smallbeef.service.impl.AccountServiceImpl.saveAccount()
访问修饰符可以省略
void com.smallbeef.service.impl.AccountServiceImpl.saveAccount()
返回值可以使用通配符，表示任意返回值
* com.smallbeef.service.impl.AccountServiceImpl.saveAccount()
包名可以使用通配符，表示任意包。但是有几级包，就需要写几个 *.
* ....AccountServiceImpl.saveAccount())
包名可以使用 .. 表示当前包及其子包
* …AccountServiceImpl.saveAccount()
类名和方法名都可以使用 * 来实现通配
* ….()
参数列表：
可以直接写数据类型：
基本类型直接写名称 int
引用类型写包名.类名的方式 java.lang.String
可以使用通配符表示任意类型，但是必须有参数
可以使用 .. 表示有无参数均可，有参数可以是任意类型
全通配写法：
* ….*(…)


实际开发中切入点表达式的通常写法：
切到业务层实现类下的所有方法
* com.smallbeef.service.impl.*.*(..)

 <!--配置AOP-->
    <aop:config>
        <!--配置切面 -->
        <aop:aspect id="logAdvice" ref="logger">
            <!-- 配置通知的类型，并且建立通知方法和切入点方法的关联-->
            <aop:before method="printLog" pointcut="execution(* com.smallbeef.service.impl.*.*(..))"></aop:before>
        </aop:aspect>
    </aop:config>

3. 通用化切入点表达式

配置切入点表达式，方便代码书写
id属性用于指定表达式的唯一标识。expression属性用于指定表达式内容

此标签写在 aop:aspect 标签 内部 只能当前切面使用。
它还可以写在 aop:aspect 外面，此时就变成了所有切面可用

注：该标签必须写在切面之前

	<aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..))"></aop:pointcut>

通过 point-ref 属性引用

 <aop:before method="beforePrintLog" pointcut-ref="pt1" ></aop:before>

4. 四种常用的通知类型

	<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>-->

	 </aop:aspect>

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
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方法开始记录日志了。。。");
    }
}

5. 环绕通知

			<!-- 配置环绕通知 -->
            <aop:around method="aroundPringLog" pointcut-ref="pt1"></aop:around>

  • 问题：
    当我们配置了环绕通知之后，切入点方法没有执行，而通知方法执行了。

  • 分析：
    通过对比动态代理中的环绕通知代码，发现动态代理的环绕通知有明确的切入点方法调用，而我们的代码中没有。

  • 解决：
    Spring框架为我们提供了一个接口：ProceedingJoinPoint。该接口有一个方法 proceed()，此方法就相当于明确调用切入点方法。
    该接口可以作为环绕通知的方法参数，在程序执行时，Spring 框架会为我们提供该接口的实现类供我们使用。

  • Spring中的环绕通知：
    它是 Spring 框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式。

    public Object aroundPringLog(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try{
            Object[] args = pjp.getArgs();//得到方法执行所需的参数

            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置通知");

            rtValue = pjp.proceed(args);//明确调用业务层方法（切入点方法）

            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。后置通知");

            return rtValue;
        }catch (Throwable t){
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。异常通知");
            throw new RuntimeException(t);
        }finally {
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。最终通知");
        }
    }

要增加的方法在 proceed 之前调用就是前置通知，在之后调用就是后置通知，
在异常中调用就是异常通知，在 finally 中调用就是最终通知

四、基于注解的 AOP 配置

1. 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: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.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

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

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

不使用 xml 的配置方式

@ComponentScan(basePackages="com.smallbeef") =
<context:component-scan base-package=“com.smallbeef”></context:component-scan>

@EnableAspectJAutoProxy = < aop:aspectj-autoproxy>< /aop:aspectj-autoproxy >

@Configuration 
@ComponentScan(basePackages="com.smallbeef") 
@EnableAspectJAutoProxy 
public class SpringConfiguration { 

}

2. 注解替代原先 xml 中 IoC 和 AOP 的配置

@Aspect 表示当前类是一个切面类 = < aop:aspect > 标签

@Pointcut 配置切入点表达式

@Pointcut("execution(* com.smallbeef.service.impl.*.*(..))")
    private void pt1(){}

@Before("pt1()") 前置通知

@AfterReturning("pt1()") 后置通知

@AfterThrowing("pt1()") 异常通知

@After("pt1()") 最终通知

@Around("pt1()") 环绕通知

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
@Component("logger")
@Aspect//表示当前类是一个切面类
public class Logger {

    /**
     * 配置切入点表达式
     */
    @Pointcut("execution(* com.smallbeef.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 aroundPringLog(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try{
            Object[] args = pjp.getArgs();//得到方法执行所需的参数

            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置");

            rtValue = pjp.proceed(args);//明确调用业务层方法（切入点方法）

            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。后置");

            return rtValue;
        }catch (Throwable t){
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。异常");
            throw new RuntimeException(t);
        }finally {
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。最终");
        }
    }
}

/**
 * 账户的业务层实现类
 */
@Service("accountService")
public class AccountServiceImpl implements IAccountService{

    @Override
    public void saveAccount() {
        System.out.println("执行了保存");
        int i=1/0;
    }

    @Override
    public void updateAccount(int i) {
        System.out.println("执行了更新"+i);

    }

    @Override
    public int deleteAccount() {
        System.out.println("执行了删除");
        return 0;
    }
}
飞天小牛肉
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring学习笔记——AOP
qq_47102228的博客
04-11 715
Spring AOP，AspectJ
JavaEE精讲之Spring框架实战 ——学习笔记.zip
09-18
在本学习笔记中，我们将深入探讨JavaEE中的Spring框架，这是一个强大的、全面的企业级应用程序开发框架，它简化了Java开发并提供了丰富的功能。Spring的核心特性包括依赖注入（DI）、面向切面编程（AOP）以及对Java ...
Spring_事务控制_动态代理
底层码农
05-03 6729
Spring_事务控制_动态代理
Spring学习笔记——Spring AOP
运气只是当机会来临时，你已为它准备好。
04-15 536
Spring AOP AOP（Aspect-Oriented Programming，面向切面编程），通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术，AOP是OOP（面向对象编程）的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离。从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 AOP用来封装多个类的公共行为，将与业务无关，却被业务模块共同调用的逻辑封装起来，减少系统
Spring学习笔记——AOP篇
qq_53149124的博客
08-12 877
除了spring的几个基础包外还需要导入aspectjweaver，下面是maven导入的配置信息 常用名词 名词 解释 连接点 可以被增强的方法 切入点 实际被增强的方法。切入点就是被增强的连接点 通知 增强的逻辑实现 切面 通知和切入点的组合 常用的通知类型 类型 解释 前置通知 在被增强方法之前执行的逻辑部分 后置通知 在被增强方法之后执行的逻辑部分，如果被增强方法出现异常就不会执行了 环绕通知 在被增强方法之前和之后执行的逻辑部分 异常通知
Spring学习笔记——06AOP
bingque6535的博客
08-27 103
一. 什么是aop AOP（Aspect Oriented Programming）称为面向切面编程，在程序开发中主要用来解决一些系统层面上的问题，比如日志，事务，权限等. 在不改变原有的逻辑的基础上，增加一些额外的功能。代理也是这个功能，读写分离也能用aop来做。 OP利用一种称为"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的
Spring5学习笔记——AOP
MCC
01-07 233
Spring5AOP概念 AOP 概念
Spring学习笔记2——AOP
bains的博客
07-07 189
AOP概念 简介 AOP为Aspect Oriented Programming的缩写，意为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。OOP的延续，Spring框架中的一个重要内容，函数式编程的一种衍生范型；利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分的耦合度降低，提高程序的可重用性，同时提高开发效率。 作用和优势 作用：在程序云溪期间，在不修改源码的情况下对方法进行功能增强； 优势：减少重复代码，提高开发效率，便于维护。 底层实现 AOP的底
Spring学习笔记3——AOP
Willow的博客
05-18 307
AOP概述 AOP是Aspect-Oriented Programming（面向切面编程）的简称。Aspect是一种新的模块化机制，用来描述分散在对象、类或函数中的横切关注点（crosscutting concern）。从关注点中分离出横切关注点是面向切面的程序设计的核心概念。分离关注点使解决特定领域问题的代码从业务逻辑中独立出来，业务逻辑的代码中不再含有针对特定领域问题代码的调用，业务逻辑同特定领域问题的关系通过切面来封装、维护，这样原本分散在整个应用程序中的变动就可以很好地管理起来。 虽然利用面
SpringBoot学习笔记——AOP全局统一日志管理
12-21
【SpringBoot学习笔记——AOP全局统一日志管理】 在软件开发中，日志记录是一项至关重要的任务，它有助于追踪操作记录、系统监控以及满足审计需求。SpringBoot作为一个流行的Java微服务框架，提供了AOP（面向切面...
Spring学习笔记系列之三
最新发布
10-26
本篇我们将聚焦于"Spring学习笔记系列之三"中的关键知识点——SpringMVC的源码分析，特别是父子容器的启动原理。这个主题是理解Spring MVC工作流程、定制化配置以及优化应用程序性能的关键。 首先，我们要明白...
Spring学习笔记+学习源码.zip
05-12
这份"Spring学习笔记+学习源码.zip"资源包含了深入学习Spring及其相关技术的知识点，以及实践代码，对提升Spring技能将大有裨益。 首先，我们来详细讨论Spring框架的主要组件和功能： 1. **依赖注入（Dependency ...
Spring 学习笔记三
05-25
《Spring 学习笔记三——深入理解Spring框架》 在我们的Spring学习旅程中，这篇笔记将带领大家更深入地探讨Spring框架的核心特性及其工作原理。Spring作为Java开发中广泛使用的轻量级框架，其强大的功能和灵活性...
【JSP+Servlet】实现登录和注册
小牛肉的博客
02-28 9752
JSP+SerVlet，对Servlet和Dao层进行优化，抽取出共同代码 只实现了简单的登录和注册，用户名查重、记住用户名和密码、验证码、表单校验并没有实现 ???? GitHub源码地址 文章目录前端界面代码结构1. 建立登录注册相关模型（Bean层）建立用户表user建立对应的User类2. 建立Utils层获取数据库连接3. 建立Dao层操作数据库数据建立BaseDao, ...
SSM整合高级实例：学生管理系统（包含增删改查和分页功能）
小牛肉的博客
05-27 3458
SSM整合高级实例：学生管理系统（包含增删改查和分页功能）
【Jsp+Servlet】实现图书增删改查和分页显示
小牛肉的博客
02-29 2928
1. 数据库建表 book表
【Spring Boot + Vue 前后端分离 - 图书管理Demo】——【一】环境准备
小牛肉的博客
02-17 1719
SpringBoot + Vue + Element UI 简单实现图书的增删改查操作 前后端分离就是将一个单体应用拆分成两个独立的应用，前后端通过JSON格式进行数据交换； 前端HTML -----> Ajax --------> Restful 后端数据接口 文章目录Demo最终效果：项目结构：一、环境准备二、新建Vue工程三、新建Spring Boot工程 Demo...
Netty 实战：实现基本聊天功能
小牛肉的博客
12-17 1536
???? 实例：Netty 实现聊天功能 ???? 本文属于 CS-Wiki 仓库中教程的一篇文章，有些知识点在之前的文章中已经详细解释过，如果不了解的话可前来学习：⭐ CS-Wiki（Gitee 推荐项目）仓库地址 本项目基于： Java 8 IDEA 2020 Netty 4.1.42 1. 新建项目并导入依赖 新建一个 Maven 项目并导入 Netty 4 依赖： <dependencies> <dependency> <group
【Spring Boot + Vue 前后端分离 - 图书管理Demo】——【二】查操作
小牛肉的博客
02-18 1519
文章目录一、 主界面样式二、 menu 与 router的绑定，实现页面跳转1. 在views中新建`BookManager.vue (查询图书页面)、BookUpdate.vue（图书信息修改页面）、AddBook.vue（添加图书页面）`2. 配置路由（router/`index.js` )3. 修改`App.vue`, 实现menu 与 router的绑定（页面跳转）三、前后端信息传递，显...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

飞天小牛肉

您的鼓励是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值