【Spring高级】AOP和动态代理

最新推荐文章于 2024-07-12 15:53:15 发布
最新推荐文章于 2024-07-12 15:53:15 发布
阅读量934 收藏 17
点赞数 32
分类专栏： # Spring高级 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43745578/article/details/136858833
版权
本文详细介绍了Java中AOP的三种实现方式：SpringAOP的代理模式（默认JDK代理和CGLIB代理）、AspectJ的编译时织入和JavaAgent的字节码修改，探讨了切点、切面和Advisor的概念及其在Spring中的应用。
摘要由CSDN通过智能技术生成

目录


在Java中，AOP（面向切面编程）的实现可以通过以下几种方法：

  1. Spring AOP：Spring框架提供了强大的AOP支持。Spring AOP主要基于代理模式实现，可以应用于方法执行的前后，异常处理等场景。Spring AOP可以通过XML配置或注解的方式实现。Spring AOP默认使用JDK动态代理，如果目标对象实现了接口，则使用JDK动态代理，否则使用CGLIB代理。
  2. AspectJ：AspectJ是一个基于Java语言的AOP框架，它扩展了Java语言，提供了更丰富的AOP特性。AspectJ使用编译时织入，而不是运行时织入，因此它可以应用于任何Java应用程序，而不仅仅是Spring应用程序。AspectJ提供了更强大的功能，如环绕通知（around advice）、前置通知（before advice）、后置通知（after advice）和异常通知（after throwing advice）等。
  3. Java Agent:它是一种特殊的工具，可以在 JVM 启动时或运行时加载，以修改类的字节码，从而实现 AOP 效果。

AspectJ实现AOP

一般我们说Spring的AOP都是代理增强，但是一种是利用插件AspectJ直接修改class文件来实现增强。

准备 service

package com.cys.spring.chapter08;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

@Service
public class MyService {

    private static final Logger log = LoggerFactory.getLogger(MyService.class);

    public static void foo() {
        log.debug("foo()");
    }
}

这里要注意的是，这个aspectj类是没有交给Spring容器进行管理的

创建切面类

package com.cys.spring.chapter08;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


@Aspect // 注意此切面并未被 Spring 管理
public class MyAspect {

    private static final Logger log = LoggerFactory.getLogger(MyAspect.class);

    @Before("execution(* com.itheima.service.MyService.foo())")
    public void before() {
        log.debug("before()");
    }
}

测试类：

package com.cys.spring.chapter08;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;


@SpringBootApplication
public class TestAspectj {

    private static final Logger log = LoggerFactory.getLogger(TestAspectj.class);

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(TestAspectj.class, args);
        MyService service = context.getBean(MyService.class);
        log.debug("service class: {}", service.getClass());
        service.foo();
        context.close();

    }
}

运行结果发现，我们的service class并不是代理类，但是却实现了增强，打印了before()。

这是因为我们使用的是aspectj插件进行的实现，因此无需容器也可以进行增强。

aspectj插件进行的实现，可以直接修改的是.class文件的字节码，因此静态类或不用容器直接调用对象的方法也可以执行。

Java Agent实现AOP

准备工作

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
 
@Service
public class MyService {
 
    private static final Logger log = LoggerFactory.getLogger(MyService.class);
 
    final public void foo() {
        log.debug("foo()");
        this.bar();
    }
 
    public void bar() {
        log.debug("bar()");
    }
}

切面类

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
@Aspect // 注意此切面并未被 Spring 管理
public class MyAspect {
 
    private static final Logger log = LoggerFactory.getLogger(MyAspect.class);
     //MyService类中的所有方法都被增强
    @Before("execution(* com.itheima.service.MyService.*())")
    public void before() {
        log.debug("before()");
    }
}

测试

import com.itheima.service.MyService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
 
@SpringBootApplication
public class A10 {
 
    private static final Logger log = LoggerFactory.getLogger(A10.class);
 
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(A10.class, args);
        MyService service = context.getBean(MyService.class);
 
        log.debug("service class: {}", service.getClass());
        service.foo();
 
      
    }
}

运行得到结果，并没有得到增强。

因为我们 第一没有用aop的增强 第二没有加入插件 aspectj的插件 所以没有进行增强。

下面使用agent增强 ：

运行时需要在 VM options 里加入 -javaagent:C:/Users/manyh/.m2/repository/org/aspectj/aspectjweaver/1.9.7/aspectjweaver-1.9.7.jar
把其中 C:/Users/manyh/.m2/repository 改为你自己 maven 仓库起始地址

Proxy（代理）模式实现AOP

这也是最重要的实现方式。上面两种了解即可。

JDK代理

JDK代理是JDK自带的技术，他只能对接口进行代理。在生成代理类时，JDK实际上是在运行时动态地创建字节码。这个过程是透明的，你不需要直接处理字节码。

以下是JDK动态代理的基本步骤：

  1. 定义接口：首先，我们需要定义一个接口，该接口将声明目标对象需要实现的方法。
  2. 实现目标对象：接着，我们需要实现这个接口，定义目标对象的具体行为。
  3. 实现InvocationHandler：我们需要创建一个类来实现InvocationHandler接口，并重写其invoke方法。这个方法会在代理对象上的方法被调用时被调用，我们可以在这里添加额外的逻辑，可以使用Lambda表达式。
  4. 创建代理对象：最后，我们使用Proxy类的静态方法newProxyInstance来创建一个代理对象。这个方法需要三个参数：类加载器、代理接口数组和InvocationHandler对象。

示例：

package com.cys.spring.chapter08;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;


public class JdkProxyDemo {

    interface Foo {
        void foo();
    }

    static class Target implements Foo {

        @Override
        public void foo() {
            System.out.println("target foo");
        }
    }

    public static void main(String[] args) {
        // 原对象
        Target target = new Target();

        // 获取classLoader，用来加载在运行期间动态生成字节码
        ClassLoader classLoader = JdkProxyDemo.class.getClassLoader();
        Foo proxyInstance = (Foo) Proxy.newProxyInstance(classLoader, new Class[] {Foo.class}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("before...");
                Object res = method.invoke(target, args);
                System.out.println("after...");
                return res;
            }
        });

        proxyInstance.foo();
    }
}

运行结果如下：

before...
target foo
after...

这样，我们就成功地在运行时动态地为目标对象的方法前后都添加了额外的逻辑。

特点：

  1. 代理对象和原对象是兄弟关系，他们都实现了接口Foo
  2. 目标对象可以是final的，后面讲的CGLIB代理就不可以

CGLIB代理

CGLIB（Code Generation Library）是一个第三方库，它扩展了JDK的动态代理，允许对没有实现接口的类进行代理。CGLIB通过继承目标类来创建代理对象，而不是像JDK动态代理那样实现接口。因此，CGLIB代理的对象必须是可继承的。

CGLIB代理的工作原理大致如下：

  1. 生成子类：CGLIB在运行时动态生成一个目标类的子类。这个子类继承了目标类，并覆盖了目标类中的方法。
  2. 方法拦截：CGLIB通过修改字节码来在子类中插入额外的逻辑。具体来说，它会修改方法调用指令，使得当这些方法在代理对象上被调用时，它们会先调用一个拦截器（Interceptor）对象的方法。
  3. 拦截器实现：你需要提供一个实现了MethodInterceptor接口的类作为拦截器。这个类需要实现intercept方法，该方法会在代理对象的方法被调用时被调用。你可以在这个方法中添加额外的逻辑，并决定是否调用目标对象的方法。
  4. 创建代理对象：使用Enhancer类来创建代理对象。Enhancer是CGLIB库中的一个核心类，它提供了创建代理对象的方法。你需要设置拦截器，并指定要代理的目标类。
  5. 方法调用：当通过代理对象调用一个方法时，CGLIB会先调用拦截器的intercept方法。在这个方法中，你可以添加任何你想要的额外逻辑，然后决定是否调用目标对象的方法。如果决定调用目标对象的方法，你可以使用MethodProxy对象来调用它。
  6. 字节码操作：为了实现上述功能，CGLIB使用ASM库来在运行时动态地修改字节码。ASM库允许你读取、修改和写入Java类的字节码。CGLIB通过ASM库修改目标类的字节码，以在方法调用前插入拦截器的逻辑。

示例：

package com.cys.spring.chapter08;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.InvocationHandler;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * @author Ethan
 * @date 2024/3/6
 * @description
 */
public class CglibProxyDemo {

    static class Target {
        public void foo() {
            System.out.println("target foo");
        }
    }


    public static void main(String[] args) {
        Target target = new Target();
        Target proxy = (Target) Enhancer.create(Target.class, new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("before...");
                Object res = method.invoke(target, args);
                System.out.println("after...");
                return res;
            }
        });
        proxy.foo();
    }

}

运行结果一样。

另外我们发现，上面的invoke方法还有一个参数MethodProxy，使用他也可以完成代理，并且避免使用反射，他有两种方式使用：

// 1. 使用MethodProxy。不再使用反射
Object res = methodProxy.invoke(target, args);
// 2. 连原对象target都不需要了，需要代理对象
Object res = methodProxy.invokeSuper(o, args);

特点:

  1. 原对象与代理对象是父子关系，即代理对象继承了原对象；
  2. 因此原对象和原对象的方法都不能是final修饰。

AOP的底层实现

切点

在Spring中其提供了PointCut接口来表示切点，其源码如下：

package org.springframework.aop;


public interface Pointcut {

   /**
    * 返回类过滤器
    */
   ClassFilter getClassFilter();

   /**
    * 返回方法过滤器
    */
   MethodMatcher getMethodMatcher();


   /**
    * Canonical Pointcut instance that always matches.
    */
   Pointcut TRUE = TruePointcut.INSTANCE;

}

其中最重要的两个方法是获取类过滤器和方法过滤器的方法。

在AspectJ中，有一个实现类AspectJExpressionPointcut，其源码如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

使用 AspectJExpressionPointcut，可以定义复杂的切入点表达式，包括基于方法名、参数类型、返回类型、执行者（target）、参数值等的匹配规则。

Aspect与Advisor切面

在Sping底层，有两个切面的概念，一个是aspect，一个是advisor。

Aspect（切面）

Aspect 是一个模块化的组件，它封装了横切关注点（cross-cutting concerns）。横切关注点通常指的是那些跨越多个应用程序模块或对象的关注点，如日志记录、事务管理、安全检查等。一个切面可以包含一个或多个通知（advice），这些通知定义了何时以及如何执行横切逻辑。

在Spring AOP中，切面通常使用AspectJ的注解（如@Aspect、@Before、@After、@Around等）来定义。一个切面可能包含多个通知，每个通知都对应一个特定的连接点（join point），如方法执行、异常处理等。

Advisor（通知器）

Advisor 是Spring AOP中的另一个核心概念。它封装了一个通知（advice）和一个切入点表达式（pointcut expression），用于确定何时应用通知。切入点表达式定义了哪些连接点（如方法调用）将触发通知的执行。

在Spring AOP中，Advisor 通常以编程方式创建，而不是通过AspectJ注解。Advisor 的一个常见实现是DefaultPointcutAdvisor，它接受一个Pointcut和一个Advice作为参数。

区别与联系

  • 区别：
    • Aspect 是一个更高级的概念，它封装了多个横切关注点，并通常使用AspectJ注解来定义。
    • Advisor 是一个更底层的概念，它封装了一个通知和一个切入点表达式，用于确定何时应用通知。
  • 联系：
    • 在Spring AOP中，Aspect 可以被自动注册为Advisor。当Spring容器检测到带有AspectJ注解的类时，它会将这些类注册为Aspect，并将它们转换为Advisor。
    • 你可以手动创建和配置Advisor，但这通常不是必需的，因为Spring可以自动为你处理Aspect到Advisor的转换。

AOP底层的实现演示

为了更方便我们演示底层细节，这里我们选择AspectJExpressionPointcut切点和Advisor切面。

看如下案例：

package com.cys.spring.chapter08;

import org.aopalliance.intercept.MethodInterceptor;
import org.springframework.aop.aspectj.AspectJExpressionPointcut;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.DefaultPointcutAdvisor;


/**
 * @author Ethan
 * @date 2024/3/6
 * @description
 */
public class TestSpringProxy {

    public static void main(String[] args) {
        // 1.创建切点
        AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
        // 添加切点表达式
        pointcut.setExpression("execution(* foo())");

        // 2.创建通知
        MethodInterceptor advice = invocation -> {
            System.out.println("before...");
            Object res = invocation.proceed();  // 调用目标
            System.out.println("after...");
            return res;
        };

        // 3.创建切面
        DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice);

        // 创建代理，使用Spring提供的工厂方法
        Target1 target1 = new Target1();
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setTarget(target1);
        proxyFactory.addAdvisor(advisor);

        I1 proxy = (I1) proxyFactory.getProxy();
        System.out.println(proxy.getClass());
        proxy.foo();
        proxy.bar();

    }

    interface I1 {
        void foo();

        void bar();
    }

    static class Target1 implements I1 {
        @Override
        public void foo() {
            System.out.println("target1 foo");
        }

        @Override
        public void bar() {
            System.out.println("target1 bar");
        }
    }

    static class Target2 implements I1 {
        @Override
        public void foo() {
            System.out.println("target2 foo");
        }

        @Override
        public void bar() {
            System.out.println("target2 bar");
        }
    }

}

上面代码中，我们创建两个类，分别都实现了接口，然后我们在main方法中自己创建了切点、切面、通知，以及使用代理工厂创建了代理，然后分别调用foo方法和bar方法。

运行结果如下：

class com.cys.spring.chapter08.TestSpringProxy$Target1$$EnhancerBySpringCGLIB$$8416bf5d
before...
target1 foo
after...
target1 bar

注意，如果发生以下错误：
Caused by: java.lang.ClassNotFoundException: org.aspectj.weaver.tools.PointcutDesignatorHandler
则是缺少依赖包：

<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
</dependency>

通过上面结果发现以下两点：

  1. 我们的代理对象类型为$$EnhancerBySpringCGLIB$$8416bf5d，可以看到他使用了CGLIB代理
  2. foo方法符合切点表达式，被增强了，bar方法没有

下面再看下哪些情况会使用JDK代理。

Spring中的代理选择

在Spring中，也是选择代码来实现AOP功能，而且上面说的JDK代理和CGLIB代理他都会使用。

那在Spring中什么时候使用JDK代理和什么时候使用CGLIB代理呢？

先说结论：

  1. 如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现
  2. 如果目标对象实现了接口，可以强制使用CGLIB实现AOP（proxyTargetClass=true）
  3. 如果目标对象没有实现了接口，必须采用CGLIB库

在上面的案例中，我们的Target1已经实现了接口，为什么还是使用的CGLIB呢？那是因为Spring自己并不知道Target1到底实没实现接口，需要我们明确告诉他，代码如下：

proxyFactory.setInterfaces(target1.getClass().getInterfaces());

再次测试下：

package com.cys.spring.chapter08;

import org.aopalliance.intercept.MethodInterceptor;
import org.springframework.aop.aspectj.AspectJExpressionPointcut;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.DefaultPointcutAdvisor;


public class TestSpringProxy {

    public static void main(String[] args) {
        // 1.创建切点
        AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
        // 添加切点表达式
        pointcut.setExpression("execution(* foo())");

        // 2.创建通知
        MethodInterceptor advice = invocation -> {
            System.out.println("before...");
            Object res = invocation.proceed();  // 调用目标
            System.out.println("after...");
            return res;
        };

        // 3.创建切面
        DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice);

        // 创建代理，使用Spring提供的工厂方法
        Target1 target1 = new Target1();
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setTarget(target1);
        proxyFactory.addAdvisor(advisor);
        proxyFactory.setInterfaces(target1.getClass().getInterfaces());

        I1 proxy = (I1) proxyFactory.getProxy();
        System.out.println(proxy.getClass());
        proxy.foo();
        proxy.bar();

    }

    interface I1 {
        void foo();

        void bar();
    }

    static class Target1 implements I1 {
        @Override
        public void foo() {
            System.out.println("target1 foo");
        }

        @Override
        public void bar() {
            System.out.println("target1 bar");
        }
    }

    static class Target2 implements I1 {
        @Override
        public void foo() {
            System.out.println("target2 foo");
        }

        @Override
        public void bar() {
            System.out.println("target2 bar");
        }
    }

}

运行结果如下：

class com.cys.spring.chapter08.$Proxy0
before...
target1 foo
after...
target1 bar

可以看到，这时候代理类就变成JDK代理实现的了。

但是当我们设置proxyTargetClass=true时，总是使用CGLIB代理实现

package com.cys.spring.chapter08;

import org.aopalliance.intercept.MethodInterceptor;
import org.springframework.aop.aspectj.AspectJExpressionPointcut;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.DefaultPointcutAdvisor;


public class TestSpringProxy {

    public static void main(String[] args) {
        // 1.创建切点
        AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
        // 添加切点表达式
        pointcut.setExpression("execution(* foo())");

        // 2.创建通知
        MethodInterceptor advice = invocation -> {
            System.out.println("before...");
            Object res = invocation.proceed();  // 调用目标
            System.out.println("after...");
            return res;
        };

        // 3.创建切面
        DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice);

        // 创建代理，使用Spring提供的工厂方法
        Target1 target1 = new Target1();
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setTarget(target1);
        proxyFactory.addAdvisor(advisor);
        proxyFactory.setInterfaces(target1.getClass().getInterfaces());
        proxyFactory.setProxyTargetClass(true);

        I1 proxy = (I1) proxyFactory.getProxy();
        System.out.println(proxy.getClass());
        proxy.foo();
        proxy.bar();

    }

    interface I1 {
        void foo();

        void bar();
    }

    static class Target1 implements I1 {
        @Override
        public void foo() {
            System.out.println("target1 foo");
        }

        @Override
        public void bar() {
            System.out.println("target1 bar");
        }
    }

    static class Target2 implements I1 {
        @Override
        public void foo() {
            System.out.println("target2 foo");
        }

        @Override
        public void bar() {
            System.out.println("target2 bar");
        }
    }

}

运行后如下：

class com.cys.spring.chapter08.TestSpringProxy$Target1$$EnhancerBySpringCGLIB$$f9f7352c
before...
target1 foo
after...
target1 bar
Ethan-running
关注
  • 32
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring AOP 与 动态代理
Hao_C的专栏
04-24 419
    前端时间，去参加网易的实习生招聘，面试官问了一个Spring AOP相关的问题：如果有一个没被 aspect 织入的函数A去调用被 aspect 织入的函数B，那么函数A在执行时会有函数B的织入效果吗？    当时是这个问题没有回答上来，确实没有试过这种情况。现在就来试试这种情况，以及分析一下Spring AOP的相关原理。我们都知道Spring AOP中使用的是动态代理的技术，其中包括了...
Spring框架,AOP,Spring整合Mybatis
01-13
在Spring的AOP中，有两种代理方式：静态代理和动态代理。静态代理通常通过自定义接口实现，预先创建代理类，代理类和目标对象一起实现了相同的接口，通过调用代理类来间接调用目标对象的方法。然而，这种方式在处理...
关于AOP的@Aspect代理
lxw2018的专栏
09-16 390
@Aspect 代理：              package com.ml.test; public interface Manager            //接口 { public void addUser(String name, String pas
Spring AOP（动态代理）
Cheer_RIO的博客
08-16 505
使用注解：@Aspect使用注解 @PointcutAspectJ ⽀持三种通配符（ * ） ：匹配任意字符，只匹配⼀个元素（包，类，或⽅法，⽅法参数）（. .） ：匹配任意字符，可以匹配多个元素 ，在表示类时，必须和 * 联合使⽤。（+） ：表示按照类型匹配指定类的所有类，必须跟在类名后⾯，如 com.cad.Car+ ,表示继承该类的所有⼦类包括本身。
【Spring Boot实战与进阶】AOP的两种动态代理（JDK和Cglib）
2301_79055239的博客
04-19 1171
引领完成Docker的安装、部署、管理和扩展，让其经历从测试到生产的整个开发生命周期，深入了解Docker适用于什么场景。并且这本Docker的学习权威指南介绍了其组件的基础知识，然后用Docker构建容器和服务来完成各种任务：利用Docker为新项目建立测试环境，演示如何使用持续集成的工作流集成Docker，如何构建应用程序服务和平台，如何使用Docker的API，如何扩展Docker。
Spring AOP—深入动态代理 万字详解（通俗易懂）
Cyan_RA9的博客
12-28 2666
Spring 第四节 AOP——动态代理 万字详解！
【Spring04】Aop动态代理的使用和原理
qq_42247619的博客
08-30 1076
AOP动态代理的使用及其@EnableAspectJAutoProxy 开启AOP切面自动代理功能及其实现原理
面向切面编程：AOP
weixin_48977598的博客
04-06 176
面向切面编程：AOP 在程序设计中,我们需要满足低耦合高内聚,所以编程需满足六大原则,一个法则. AOP面向切面编程正是为了满足这些原则的一种编程思想. 一.注释: 用于注释:方法被执行之后,允许被执行的方法 @Target(value=ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface CustomAfter { String[] value(); } 用于注释:方法被执行之前,允许被执行的方法 @
通过注解将接口代理到具体实现类调用
笨字第1号
12-26 415
然后在初始化时我们需要通过注解扫描的方式将对应注解扫描到，并注入到Spring容器中，这样在业务方使用时就可以通过@Autowired注解将其声明的注解注入到对应的位置。但是我们不想业务在调用的时候去填写任务模版Template，而是希望其在接口上声明，我们通过注解扫描将其扫描进来并进行注册，然后帮助业务进行调用时动态加入模板信息。为此，我们定义了一个PublishService，希望业务方通过继承该接口，然后业务方只需要声明一个接口继承PublishService接口即可。
利用注解和反射实现动态代理
m0_75198698的博客
05-30 349
创建一个代理类，该类将实现`InvocationHandler`接口，并在其中编写代理逻辑。在代理逻辑中，根据注解的信息执行相应的操作。首先，创建一个自定义的注解，用于标记需要进行动态代理的方法。请注意，在使用动态代理时，原始对象必须实现一个接口，并且代理对象也必须实现相同的接口。在以上步骤中，需要根据实际情况替换相关代码部分，例如注解的属性定义、代理逻辑的实现、原始对象的实例化等。当调用被注解标记的方法时，代理处理器会执行相应的操作。在需要使用代理的地方，创建代理对象并传入原始对象和代理处理器。
Spring 入门AOP材料
02-13
1. **基于代理的AOP**：Spring默认使用JDK动态代理或CGLIB代理来创建目标对象的代理对象，代理对象在方法调用前后执行通知。 2. **基于注解的AOP**：通过在类或方法上添加注解来定义切面，更加简洁直观。 **AOP 的...
从JDK动态代理到spring AOP
04-17
本篇将详细探讨JDK动态代理和Spring AOP，以及它们在实际应用中的作用。 首先，JDK动态代理是Java提供的一种在运行时创建代理对象的技术。它允许我们在不修改原有类的基础上，为已有接口添加额外的功能。动态代理的...
Spring AOP源码深度解析：掌握Java高级编程核心技术
12-13
5. **启用AOP代理**：在Spring配置中启用AOP代理，可以选择JDK或CGLIB代理。 6. **运行应用**：Spring容器会根据配置自动创建并管理代理对象，当调用目标方法时，相应通知会被自动执行。 通过深入理解Spring AOP的...
JDK动态代理 spring aop 的原理
11-08
5. AOP代理的使用：当通过Spring的依赖注入（DI）获取到一个对象时，实际上得到的是一个代理对象。通过这个代理对象调用方法，Spring会自动插入预先定义好的通知逻辑。 总的来说，JDK动态代理是Spring AOP实现的...
SpringBootV12和mybatis全部知识点
近日终于有时间好好回顾下一些作品了，有帮助的好好看就行
07-09 1048
框架: 快速开发项目的一个架子sshssmspring --> applicationContext.xml配置文件(spring不是业务层,是管理其他框架的)springmvc --> springmvc.xml配置文件 (对应之前servlet)mybatis —> mybatis-config.xml配置文件(对应之前jdbc)—> springboot优化了之前的框架配置,思想是约定大于配置注意：根据网络状况，可能会提示无法连接。如果不能连接，使用http://start.springboot.io
Spring Security的Filter
weixin_44263023的博客
07-08 696
如果你需要实现一些 Spring Security 没有提供的特定安全功能，你可以通过实现 javax.servlet.Filter 接口来创建自定义的过滤器，并使用 Spring Security 的 FilterRegistrationBean 或通过 Spring Security 的配置类将其添加到过滤器链中。
Spring常见的自定义和扩展的方法
Casual_Lei的博客
07-12 129
通过类和@Bean方法，自定义Bean的创建过程。@Bean使用Spring AOP（Aspect-Oriented Programming）自定义注解和拦截方法调用。通过实现接口，在Bean的初始化前后添加自定义逻辑。@Component@Override@Override通过实现接口，可以在Bean定义加载后但在Bean实例化前修改Bean定义。@Component@Override通过实现接口，监听Spring应用上下文事件。
springboot的mybatis使用CONCAT模糊查询
最新发布
qq_61950936的博客
07-12 69
在mysql中like 可以直接使用字符串拼接，在xml中需要使用CONCAT来连接变量。
5.SpringBoot核心源码-启动类源码分析
流月up的博客
07-12 248
SpringBoot核心源码-启动类源码分析

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Ethan-running

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

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

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

打赏作者

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

抵扣说明：

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

余额充值