手写Spring框架准备工作之Spring核心AOP

最新推荐文章于 2023-10-21 16:51:39 发布
最新推荐文章于 2023-10-21 16:51:39 发布
阅读量262 收藏
点赞数

Spring AOP 知识点思维导图

file

什么是 AOP?

AOP(Aspect-oriented Programming) , 名字与 OOP(Object-oriented programming) 仅差一个字母, 其实它是对 OOP 编程的一种补充. AOP 翻译过来叫面向切面编程, 核心就是这个切面. 切面表示从业务逻辑中分离出来的横切逻辑, 比如性能监控, 日志记录, 权限控制等, 这些功能都可以从核心业务逻辑代码中抽离出来. 也就是说, 通过 AOP 可以解决代码耦合问题, 让职责更加单一.

我们来通过代码来理解下概念, 这里有一个转账业务:

public interface IAccountService {
    //主业务逻辑: 转账
    void transfer();
}
public class AccountServiceImpl implements IAccountService {
    @Override
    public void transfer() {
        System.out.println("调用dao层,完成转账主业务.");
    }
}

现在有一个需求是, 在转账之前需要验证用户身份, 一般情况下我们直接就去修改源代码了:

public class AccountServiceImpl implements IAccountService {
    @Override
    public void transfer() {
	  System.out.println("对转账人身份进行验证.");


        System.out.println("调用dao层,完成转账主业务.");
    }
}

但作为一个"有经验"的 Java 开发, 我们知道 “身份验证” 这个业务完全是可以剥离出来的, 所以使用下代理设计模式的思想:

public class AccountProxy implements IAccountService {
    //目标对象
    private IAccountService target;


    public AccountProxy(IAccountService target) {
        this.target = target;
    }


    /**
     * 代理方法,实现对目标方法的功能增强
     */
    @Override
    public void transfer() {
        before();
        target.transfer();
    }


    /**
     * 身份验证
     */
    private void before() {
        System.out.println("对转账人身份进行验证.");
    }
}


public class Client {
    public static void main(String[] args) {
        //创建目标对象
        IAccountService target = new AccountServiceImpl();
        //创建代理对象
        AccountProxy proxy = new AccountProxy(target);
        proxy.transfer();
    }
}

AOP 的实现原理就是代理设计模式, 上面这个是静态代理, 但 Spring AOP 是通过动态代理实现的, 所以我们需要了解下动态代理: https://blog.csdn.net/litianxiang_kaola/article/details/85335700

AOP 并不是由 Spring 独创, 在 Spring 之前就有了 AOP 开源框架—AspectJ, 而且 AspectJ 的 AOP 功能要比 Spring 更强大, 所以在 Spring 的后期版本中就集成了 AspectJ. 但我们还是有必要了解下 Spring 的 AOP 功能.

AOP 术语

  • Targe 目标对象

  • Joinpoint 连接点, 所有可能被增强的方法都是连接点.

  • Pointcut 切入点, 将被增强的方法.

  • Advice 增强, 从主业务逻辑中剥离出来的横切逻辑.

  • Aspect 切面, 切入点加上增强就是切面.

  • Weaving 织入, 把切面应用到目标对象上的过程.

  • Proxy 代理对象, 被增强过的目标对象.

Advice 常见类型

  • 前置增强 org.springframework.aop.MethodBeforeAdvice, - 在目标方法执行前实施增强.

  • 后置增强 org.springframework.aop.AfterReturningAdvice, 在目标方法执行后实施增强.

  • 环绕增强 org.aopalliance.intercept.MethodInterceptor, 在目标方法执行前后都实施增强.

  • 异常抛出增强 org.springframework.aop.ThrowsAdvice, 在方法抛出异常后实施增强.

  • 引入增强 org.springframework.aop.IntroductionInterceptor, 对类进行增强, 即在目标类中添加一些新的方法和属性.

Spring AOP 之编程式

我们用编程式来感受下 Spring AOP. 下面例子使用的是环绕增强.

(1) 业务类

public interface IAccountService {
    //主业务逻辑: 转账
    void transfer();
}
public class AccountServiceImpl implements IAccountService {
    @Override
    public void transfer() {
        System.out.println("调用dao层,完成转账主业务.");
    }
}

(2) 增强

public class AccountAdvice implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        before();
        Object result = invocation.proceed();
        after();
        return result;
    }


    private void before() {
        System.out.println("Before");
    }


    private void after(){
        System.out.println("After");
    }
}

(3) 测试

public class Test {
    public static void main(String[] args) {
        //创建代理工厂
        ProxyFactory proxyFactory = new ProxyFactory();
        //配置目标对象
        proxyFactory.setTarget(new AccountServiceImpl());
        //配置增强
        proxyFactory.addAdvice(new AccountAdvice());


        IAccountService proxy = (IAccountService) proxyFactory.getProxy();
        proxy.transfer();
    }
}


结果:
Before
调用dao层,完成转账主业务.
After

Spring AOP 之声明式

Spring AOP 之声明式就是使用配置文件来声明各种 bean.

(1) 业务类

public interface IAccountService {
    //主业务逻辑: 转账
    void transfer();
}
public class AccountServiceImpl implements IAccountService {
    @Override
    public void transfer() {
        System.out.println("调用dao层,完成转账主业务.");
    }
}

(2) 增强

public class AccountAdvice implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        before();
        Object result = invocation.proceed();
        after();
        return result;
    }


    private void before() {
        System.out.println("Before");
    }


    private void after(){
        System.out.println("After");
    }
}

(3) 配置文件

<?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"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd">


    <!--声明bean-->
    <bean id="accountService" class="org.service.impl.AccountServiceImpl"></bean>
    <bean id="accountAdvice" class="org.aspect.AccountAdvice"></bean>


    <!--配置代理工厂-->
    <bean id="accountProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!--目标接口-->
        <property name="interfaces" value="org.service.IAccountService"/>
        <!--目标对象-->
        <property name="target" ref="accountService"/>
        <!--增强-->
        <property name="interceptorNames" value="accountAdvice"/>
    </bean>


</beans>

(4) 测试

public class Test {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring/spring-service.xml");
        IAccountService proxy = (IAccountService) context.getBean("accountProxy");
        proxy.transfer();
    }
}


结果:
Before
调用dao层,完成转账主业务.
After

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"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd">


    <!--声明bean-->
    <bean id="accountService" class="org.service.impl.AccountServiceImpl"></bean>
    <bean id="accountAdvice" class="org.aspect.AccountAdvice"></bean>


    <!--配置切面-->
    <bean id="accountAspect" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <!--增强-->
        <property name="advice" ref="accountAdvice"/>
        <!--切入点-->
        <property name="pattern" value="org.service.impl.AccountServiceImpl.transfer.*"/>
    </bean>




    <!--配置代理-->
    <bean id="accountProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!--目标对象-->
        <property name="target" ref="accountService"/>
        <!--切面-->
        <property name="interceptorNames" value="accountAspect"/>
    </bean>


</beans>

这里的切面配置的是基于正则表达式的 RegexpMethodPointcutAdvisor, 表示拦截所有以 “transfer” 开头的方法. 除此之外, Spring AOP 还有以下配置:

  • org.springframework.aop.support.DefaultPointcutAdvisor 匹配继承了该类的切面.

  • org.springframework.aop.support.NameMatchMethodPointcutAdvisor 根据方法名称进行匹配.

  • org.springframework.aop.support.StaticMethodMatcherPointcutAdvisor 用于匹配静态方法.

Spring AOP 之自动代理

让用户去配置一个或少数几个代理, 似乎还可以接受, 但随着项目的扩大, 代理配置会越来越多, 这个时候再让你手动配置, 那整个人都不好了. 不过不用担心, Spring AOP 为我们提供了自动生成代理的功能.

在声明式的代码基础上修改下配置文件和测试类:

(1) 配置文件

<?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"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!--声明bean-->
    <bean id="accountService" class="org.service.impl.AccountServiceImpl"></bean>
    <bean id="accountAdvice" class="org.aspect.AccountAdvice"></bean>


    <!--配置切面-->
    <bean id="accountAspect" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <!--增强-->
        <property name="advice" ref="accountAdvice"/>
        <!--切入点-->
        <property name="pattern" value="org.service.impl.AccountServiceImpl.transfer.*"/>
    </bean>


    <!--配置自动代理: 自动扫描所有切面类, 并为其生成代理-->
    <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>
</beans>

(2) 测试

public class Test{
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring/spring-service.xml");
        IAccountService proxy = (IAccountService) context.getBean("accountService");
        proxy.transfer();
    }
}


结果:
Before
调用dao层,完成转账主业务.
After

Spring + AspectJ

在企业开发中几乎不使用 Spring 自身的 AOP 功能, 而是用 AspectJ 代替, Spring 在后期自己集成了 AspectJ 也间接证明了 AspectJ 的强大, 我们下面来了解下 Spring + AspectJ.

AspectJ 增强类型

  • 前置增强
    注解: @Before, 配置: < aop:before>

  • 后置增强
    注解: @After, 配置: < aop:after>

  • 环绕增强
    注解: @Around, 配置: < aop:around>

  • 异常抛出增强
    注解: @AfterThrowing, 配置: < aop:after-throwing>

  • 引入增强
    注解: @DeclareParents, 配置: < aop:declare-parents> 切入点表达式

execution(* org.service.impl.AccountServiceImpl.*(..))

  • execution()表示拦截方法, 括号中可定义需要匹配的规则.

  • 第一个 “*” 表示方法的返回值是任意的.

  • 第二个 “*” 表示匹配该类中所有的方法.

  • (…) 表示方法的参数是任意的. 可以看到, AspectJ 的切入点表达式要比 Spring AOP 的正则表达式可读性更强.

Spring AspectJ 实例—基于配置

(1) 业务类

public interface IAccountService {
    //主业务逻辑: 转账
    void transfer();
}
public class AccountServiceImpl implements IAccountService {
    @Override
    public void transfer() {
        System.out.println("调用dao层,完成转账主业务.");
    }
}

(2) 增强

public class AccountAdvice{
    //前置增强
    public void myBefore(JoinPoint joinPoint){
        before();
    }


    //后置增强
    public void myAfter(JoinPoint joinPoint) {
        after();
    }


    //环绕增强
    public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
        before();
        Object result  = joinPoint.proceed();
        after();
        return result;
    }


    //抛出异常增强
    public void myThrowing(JoinPoint joinPoint, Throwable e) {
        System.out.println("抛出异常增强：" + e.getMessage());
    }




    private void before() {
        System.out.println("Before");
    }


    private void after(){
        System.out.println("After");
    }
}

(3) 配置

<?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"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!--声明bean-->
    <bean id="accountService" class="org.service.impl.AccountServiceImpl"></bean>
    <bean id="accountAdvice" class="org.aspect.AccountAdvice"></bean>


    <!--切面-->
    <aop:config>
        <aop:aspect ref="accountAdvice">
            <!--切入点表达式-->
            <aop:pointcut expression="execution(* org.service.impl.AccountServiceImpl.*(..))" id="myPointCut"/>
            <!--环绕增强-->
            <aop:around method="myAround" pointcut-ref="myPointCut"/>
        </aop:aspect>
    </aop:config>
</beans>

(4) 测试

public class Test{
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring/spring-service.xml");
        IAccountService proxy = (IAccountService) context.getBean("accountService");
        proxy.transfer();
    }
}


结果:
Before
调用dao层,完成转账主业务.
After
Spring AspectJ 实例—基于注解

(1) 业务类

public interface IAccountService {
    //主业务逻辑: 转账
    void transfer();
}
@Component
public class AccountServiceImpl implements IAccountService {
    @Override
    public void transfer() {
        System.out.println("调用dao层,完成转账主业务.");
    }
}

(2) 切面

这里就不再叫增强了, 因为有了切入点和增强, 叫切面更好.

@Component
@Aspect
public class AccountAspect{
    //切入点
    @Pointcut("execution(* org.tyshawn.service.impl.AccountServiceImpl.*(..))")
    private void pointCut(){};


    //前置增强
    @Before("pointCut()")
    public void myBefore(JoinPoint joinPoint){
        before();
    }


    //后置增强
    @After("pointCut()")
    public void myAfter(JoinPoint joinPoint) {
        after();
    }


    //环绕增强
    @Around("pointCut()")
    public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
        before();
        Object result  = joinPoint.proceed();
        after();
        return result;
    }


    //抛出异常增强
    @AfterThrowing(value = "pointCut()", throwing = "e")
    public void myThrowing(JoinPoint joinPoint, Throwable e) {
        System.out.println("抛出异常增强：" + e.getMessage());
    }


    private void before() {
        System.out.println("Before");
    }


    private void after(){
        System.out.println("After");
    }
}

(3) 配置

<?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"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd">


    <!--注解扫描-->
    <context:component-scan base-package="org.tyshawn"></context:component-scan>
    <!--自动代理 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

(4) 测试

public class Test{
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring/spring-service.xml");
        IAccountService proxy = (IAccountService) context.getBean("accountServiceImpl");
        proxy.transfer();
    }
}
结果:
Before
Before
调用dao层,完成转账主业务.
After
After

来源:https://url.cn/5UHOZrO

开源项目推荐

作者的其他开源项目推荐：

  1. Pre基于Spring Boot 、Spring Security 、Vue的前后端分离的的RBAC权限管理系统

  2. Prex基于Spring Cloud、Oauth2 、Vue的前后端分离的微服务架构RBAC权限管理系统

  关注公众号回复开源项目即可获取

小东啊
关注
仿 Spring 手写 IoC、AOP 框架.rar
10-23
依赖注入是Spring的核心特性之一，它允许开发者将对象的创建和管理权交给框架，从而降低组件之间的耦合度。在IoC中，对象并不直接创建其依赖的对象，而是通过容器来提供这些依赖。这样，当需要改变某个依赖时，只...
手写Spring框架---AOP实现
汤键的博客
06-18 809
手写Spring框架---AOP实现
【框架源码篇 03】Spring源码手写篇-手写AOP
studyday1的博客
10-21 263
手写IoC和DI后已经实现的类图结构。
手写SpringAOP
专注Java（全栈）应用开发，求知若渴，虚心若愚，talk is cheap, show me the code.
04-12 303
CG are superficial brothers, you will have an evaluation of any behavior, do not ask simple questions, solve the best independently.
手写Spring框架 IOC 和 AOP
05-17 512
代码演示视频：链接：https://pan.baidu.com/s/1QnEc9uAXDdgTsdEb6wjzHQ?pwd=44ih 该项目是博主帮某985大学学生做的一个项目 详细介绍：手写Spring框架 IOC 和 AOP | 言曌博客 一、功能介绍 实现了 IOC 和 AOP 功能，xml 配置和 注解扫描两种 xml 标签如 beans bean id class scope(single/prototype) autowired(byType/byName) name pro..
手写spring第九章-Spring中整合AOP
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
07-31 236
由于篇幅的原因，笔者就以前置增强作为示例来实现基于手写的Spring整合AOP。我们都知道下定义了一个名为Advice的接口，我们通过语义就知道他是进行相关增强操作的。由于我们本文的目的是实现方法前置增强。既然有了前置增强这样的接口，我们就可以继承这个接口定义本文所需要实现方法前置增强的接口了有了这样一个动作后，我们自然是需要获取这个增强对象，很多人可能会认为我们应该在或者中增加一个getAdvice的方法方便我们去获取增强对象。
手写Spring框架之: HelloSpring
最新发布
02-01
在本教程中，我们将深入探讨如何手写Spring框架的核心部分，以实现一个简化的"HelloSpring"示例。Spring框架是Java开发中的一个基石，它提供了依赖注入、面向切面编程（AOP）以及用于构建企业级应用的全面解决方案。...
手写spring框架ioc+aop+mvc
11-01
Spring 框架是 Java 开发中的核心工具之一，它为开发者提供了强大的依赖注入（IOC）和面向切面编程（AOP）功能，同时也包含了 MVC 模式来支持 web 应用开发。在这个"手写 spring 框架 ioc+aop+mvc"的项目中，我们将...
手写springAop框架3.zip
03-19
手写Spring AOP框架可以帮助我们深入理解AOP的工作原理，进一步提升我们的编程技能。通过这个过程，我们可以更熟练地运用Spring AOP来实现代码的解耦和功能增强，从而提高软件的可维护性和扩展性。在实践中，掌握...
手写简易AOP，彻底悟懂AOP
qq_63815371的博客
11-10 1015
AOP 意为：面向切面编程，通过预编译的方式和运行期间动态代理实现程序功能功能的统一维护。其实 AOP 也是 OOP 的延续，在 Spring 框架中是一个非常重要的内容，使用 AOP 可以对业务逻辑的各个部分进行隔离，从而使各模块间的业务逻辑耦合度降低，提高代码的可复用性，同时也能提高开发效率。
手写 Spring Aop篇
@Bean
07-19 317
上面三篇文档介绍了bean的生命周期。通知是如何绑定的，代理对象是如何产生的以及aop是如何调用的呢。 一个aop切面包含了哪些内容了 一个切面有多个切入点，每个切入点有不同的通知，通知分为before after around(此环境) around 的通知有两个也是之前和之后，这个之前会在before之前执行，这个之后会在after之前执行。 那么aop是如何调用的呢。比如我们需要增强A类的query方法。如果A是一个接口，代理对象通过jdk动态代理生成，如果是一个类，代理对象通过cglib生成
[手写spring](5)实现AOP机制（完结）
秃头披风侠的博客
07-01 659
我们实现和原生spring相类似的AOP机制，即通过在切面类中的方法上面通过注解指定要切入的位置。当然，使用方法肯定也要和原生的一样，实现主要的功能。 自定义JoinPoint 定义存储切面类的集合 定义MethodInfo内部类 解析切面表达式 判断是否为目标方法 初始化aspectClass容器 对切面类进行排序 实现AOP 测试
手把手教你手写Spring框架(附源码)
10-17
  Java框架一直以来都是面试必备的知识点，而学习Java框架，不管在成熟的大公司，快速发展的公司，还是创业阶段的公司，都能对当前正在开发中的系统有整体的认知，从而更好的熟悉和学习技术。 本教程以项目实战为导向，帮助广大学员手把手教学，本课程从无到有，循序渐进的手写mvc框架，由于官方的框架比较复杂，为了让同学们能够学懂，先从简单地IOC框架入手，然后不断地升级和迭代，逐渐成为官方比较接近的Spring框架。希望同学们通过我的课程学习，能成为自己手动编写框架的高手，深化框架的使用，同时积累一定的代码量，在公司成为顶梁柱。 项目工程截图:    
手写Spring框架之AOP
Tyshawn的博客
01-25 7310
简介 手写Spring框架第一篇博客(必读): 手写Spring框架 前面两篇博客已经实现了Bean容器, IOC功能和MVC功能, 本篇博客来实现AOP功能和事务管理. 在看下面的内容之前, 一定要先回顾下Spring AOP和动态代理. Spring AOP 动态代理 handwritten-mvc-framwork 实现 定义注解 (1) 切面注解 @Target(ElementType.T...
（二）手写spring AOP框架
Maybe_9527的博客
01-20 939
目录前言AOP是什么AOP框架要做什么AOP技术元素分析Advice设计插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 前言 本篇基于（一）手写spring IOC容器手写AOP框架。采用问答形式，逐步梳理手写aop过程。 AOP是什么 Aspect Oriented Programmin
手写实现Spring AOP
Jet_Green的博客
08-09 3148
Spring IOC、AOP可谓是spring中两大王牌 上次我们手写了IOC，那么今天我们来手写一下AOP 感谢这篇博主的手写AOP博文（https://blog.csdn.net/qq_35704236/article/details/79997182） 我是学习他的写法，然后将一些我不懂的代码进行了注释解释，应该可以更加适合小白学习吧。 一.准备 首先我们都知道Spring AOP...
手写Spring框架
热门推荐
Tyshawn的博客
01-25 2万+
在学习完Spring框架之后, 我们知道了 Spring容器, IOC, AOP, 事务管理, SpringMVC 这些Spring的核心内容, 也知道了它们底层实现的基本原理, 比如Spring容器就是个Map映射, IOC底层就是反射机制, AOP底层是动态代理, SpringMVC不就是对Servlet进行了下封装嘛! 哈哈, 当然这些只是些皮毛, Spring除此之外还有更加复杂的设计, ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值