深入理解springboot 2.0的AOP

怼烎@ 2022-02-28 01:58 148阅读 0赞

针对于SpringBoot 2.0 来讲，AOP 的概念 过于抽象，对初学者不是很友好，并且在实际项目中应用  
也是很少，毕竟AOP 的性能很是低下，同样类似于声明式事务，在大型 的项目中，使用spring 的编程式 事务会很多，毕竟性能；

好了，继上一篇blog 入门讲解spring 的AOP 也有一段时间了，现在总结下AOP 的使用以及深入理解，当然，本Blog 不是在讲 AOP 的源码，而是，在简单 demo 中 使用AOP ，一个字，照着敲，敲一遍有点概念，敲两遍基本知道怎么个流程了，绝不是赏花似的 瞄几眼能够比拟的。

> 日常源码分享：  
> [https://github.com/medoo-Ai/springboot][https_github.com_medoo-Ai_springboot]  
> AOP 实现原理 以及AOP概念可以参考 我的上一篇blog  
> [https://blog.csdn.net/weixin\_42323802/article/details/82468900][https_blog.csdn.net_weixin_42323802_article_details_82468900]

1.1、基础创建maven 等就不累述，创建启动类AopApp.java  
首先定义一个简单的HelloWorldService ,并创建实现类

public interface HelloService { 
         void sayHello(String name);
    }

@Slf4j
    public class HelloServiceImpl implements HelloService { 
    
        public void sayHello(String name) { 
            if (name == null || name.trim() == "") { 
                log.info("name 不能为空 {}",name);
            }
            System.out.println(name);
        }
    }

1.2、自定义拦截器 MyInterceptor.java

> 可以参考我的这篇 blog  
> [https://blog.csdn.net/weixin\_42323802/article/details/83656729][https_blog.csdn.net_weixin_42323802_article_details_83656729]  
> 这里简单实现一个自定义的interceptor

@Slf4j
    public class MyInterceptor implements Interceptor { 
    
        public boolean before() { 
          log.info("before start running ");
            return true;
        }
    
        public void after() { 
          log.info("after start running ");
    
        }
    
        public Object around(Invocation invocation) throws Throwable { 
            log.info("before running ");
            Object proceed = invocation.proceed();
            log.info("after running ");
            return proceed;
        }
    
        public void afterReturning() { 
            log.info("afterReturning start running ");
        }
    
        public void afterThrowing() { 
            log.info("afterThrowing start running ");
        }
    
        public boolean useAround() { 
            log.info("useAround start running ");
            return true;
        }
    }

1.3、 AOP 实现大家都知道 是基于代理实现，代理有jdk 和cglib ，无论哪种方式，都是基于代理对象 调用执行方法 完成AOP 的一个过程；

public class AopDemo { 
    
        //public static Object getProxyBean(Object target, Interceptor interceptor)
        public static void main(String[] args) { 
            HelloService proxy=(HelloService)ProxyBean.getProxyBean(new HelloServiceImpl(),new MyInterceptor());
            proxy.sayHello("dadoudou");
        }
    }

2019.03.24       13：47    更

2.1、 对数据库 进行insert 操作测试

public class UserService { 
    
        public int insertUser() { 
            UserDao userDao = new UserDao();
            User user = new User();
            user.setUsername("user_name_1");
            user.setNote("note_1");
            Connection conn = null;
            int result = 0;
            try { 
                // 获取数据事务连接
                Class.forName("com.mysql.jdbc.Driver");
                conn = DriverManager.getConnection(
                    "jdbc:mysql://localhost:3306/chapter3", "root", "123456");
                // 非自动提交事务
                conn.setAutoCommit(false);
                result = userDao.insertUser(conn, user);
                // 提交事务
                conn.commit();
            } catch (Exception e) { 
                try { 
                    // 回滚事务
                    conn.rollback();
                } catch (SQLException ex) { 
                    ex.printStackTrace();
                }
                e.printStackTrace();
            } finally { 
                // 释放数据连接资源
                if (conn != null) { 
                    try { 
                        conn.close();
                    } catch (SQLException e) { 
                        e.printStackTrace();
                    }
                }
            }
            return result;
        }
    }
    /**** imports ****/
    public class UserDao { 
    
        public int insertUser(Connection conn, User user) throws SQLException { 
            PreparedStatement ps = null;
            try { 
                ps = conn.prepareStatement("insert into t_user(user_name, note) values( ?, ?)");
                ps.setString(1, user.getUsername());
                ps.setString(2, user.getNote());
                return ps.executeUpdate();
            } finally { 
                ps.close();
            }
        }
    }

2.2、 @AspectJ 的注解方式 实现 AOP 的过程、

> 连接点（join point）： Spring 只能支持拦截方法，AOP 将通过动态代理把Method 织入对应的流程中。  
> 举栗子 ： service 中存在不同的方法 ，每一个method 都是一个 特定的连接点、

切点（point cut）： 指定 特定的 Join point ；

> 通知（advice）：  
> 就是按照约定的流程下的方法，分为前置通知（before advice）、后置通知（after advice）、环绕通知（around advice）、事后返回通知（afterReturning advice）和异常通知（afterThrowing advice），它会根据约定织入流程中，需要弄明白它们在流程中的顺序和运行的条件。  
> 目标对象（target）：即被代理对象，例如，约定编程中的 HelloServiceImpl 实例就是一个目标对象，它被代理了。

引入（introduction）：是指引入新的类和其方法，增强现有 Bean 的功能。  
织入（weaving）：通过 代理 将 通知 织入约定流程的过程。  
切面（aspect）：是一个可以定义切点、各类通知和引入的内容；

[https_github.com_medoo-Ai_springboot]: https://github.com/medoo-Ai/springboot
[https_blog.csdn.net_weixin_42323802_article_details_82468900]: https://blog.csdn.net/weixin_42323802/article/details/82468900
[https_blog.csdn.net_weixin_42323802_article_details_83656729]: https://blog.csdn.net/weixin_42323802/article/details/83656729