Spring Aop & JDK 动态代理

最新推荐文章于 2024-07-12 09:16:51 发布
最新推荐文章于 2024-07-12 09:16:51 发布
阅读量141 收藏
点赞数
分类专栏： spring 文章标签： spring spring aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/skmhuanhuan/article/details/81347455
版权
知识回顾

在文章初识AOP中，了解到为什么要用代理，静态代理和动态代理的区别，在JDK的动态代理中讲到JDK的动态代理是如何实现的，有什么优缺点，CGLIB中动态代理中我们又说明了CGLIB如何实现动态代理，和JDK动态代理有什么区别，本篇将继续聊下Spring中的AOP是如何结合JDK的动态代理和CGLIB的动态代理来实现的

AOP术语

  1. 通知（Advice） 通知定义了切面是什么以及何时使用，描述了切面要完成的工作（比如权限、日志、事物），通知还解决了何时执行这个工作的问题，在方法前、后、还是抛出异常时，通知包含了5中类型，如下：
    Before：方法调用前调用通知
    After：在方法完成之后调用通知，不论方法执行是否成功
    After-returing： 在方法成功执行之后调用通知
    After-throwing：在方法抛出异常后调用通知
    Around：通知包裹了被通知的方法，在被通知的方法调用之前和调用之后执行自定义的行为

  2. 连接点（Joinpint）连接点是应用执行过程中能够插入切面的一个点，这个点可以使调用方法时、抛出异常时、甚至是修改一个自短时。切面代码可以利用这些点插入到应用的的正常流程之中，并添加新的行为

  3. 切点（Pointcut）通知定义了切面的 “什么”和“何时”，切点是定义了“何处”。切点的定义会匹配通知所要织入的一个或多个连接点。
  4. 切面（Aspect）切面是切点和通知的结合，定义了 什么、在何时、何处完成其功能
  5. 引入（Introduction）引入运行我们在不修改类的源码的情况下，向现有的类添加新的方法和属性
  6. 织入（Weaving）织入是吧切面应用到目标对象创建代理对象的过程，切面在指定的连接点被织入到目标对象中
Spring AOP 示例

前提：先引入spring-context的jar包

同样的例子 定义一个IHello的接口和一个Hello的实现类如下

package seven.com.seven.aop;

public interface IHello {

    void say();

}

package seven.com.seven.aop;

public class Hello implements IHello {

    @Override
    public void say() {
        System.out.println("hello word");
    }
}

定义一个前置通知，一个后置通知，一个环绕通知，如下

package seven.com.seven.aop;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class BeforeAdvice implements MethodBeforeAdvice {
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("------------------before------------------");
    }
}

package seven.com.seven.aop;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class AfterAdvice implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("------------------after------------------");
    }
}
package seven.com.seven.aop;


import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
public class SurroundAdvice implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
         System.out.println("------------------surround before---------------------");
         Object result = invocation.proceed();
         System.out.println("------------------surround after----------------------");
        return result;
    }
}

spring aop 实现动态代理

package seven.com.seven.aop;

import org.springframework.aop.framework.ProxyFactory;

public class DynamicSpringProxy {

    private Object target;

    public Object getProxy(Object target) {
        /**
         * 通过此语句可以把动态生成的class文件保存到磁盘，然后通过 反编译工具得到代码
         */
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        this.target = target;
        ProxyFactory factory = new ProxyFactory(target);
        factory.addAdvice(new BeforeAdvice());
        factory.addAdvice(new AfterAdvice());
        factory.addAdvice(new SurroundAdvice());
        return factory.getProxy();
    }
}

package seven.com;

import seven.com.seven.aop.*;

public class App {
    public static void main(String[] args) {
        Hello hello = new Hello();
        IHello proxy = (IHello) new DynamicSpringProxy().getProxy(hello);
        proxy.say();
    }
}

运行结果

------------------before------------------
------------------surround before------------------
hello word
------------------surround after------------------
------------------after------------------
分析

我们看到拦截已经生效，那Spring AOP是使用JDK的动态代理还是CGLib的动态代理呢？我们打开源码可以看下DefaultAopProxyFactory这个类，选择AopProxyFactory的过程如下

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {

        //默认是使用JDK的动态代理，如果想使用CGLib的动态代理，可以吧proxyTargetClass设置为True
    @Override
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
            Class<?> targetClass = config.getTargetClass();
            if (targetClass == null) {
                throw new AopConfigException("TargetSource cannot determine target class: " +
                        "Either an interface or a target is required for proxy creation.");
            }
            if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
                return new JdkDynamicAopProxy(config);
            }
            return new ObjenesisCglibAopProxy(config);
        }
        else {
            return new JdkDynamicAopProxy(config);
        }
    }
    private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
        Class<?>[] ifcs = config.getProxiedInterfaces();
        return (ifcs.length == 0 || (ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0])));
    }

}
JdkDynamicAopProxy

选择的JDK的动态代理，其实就是创建JdkDynamicAopProxy对象，JdkDynamicAopProxy实现了InvocationHandler接口（JDK动态代理要求的，前面文章提到过），最终会执行invoke方法，代码如下

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {

    public JdkDynamicAopProxy(AdvisedSupport config) throws AopConfigException {
        Assert.notNull(config, "AdvisedSupport must not be null");
        if (config.getAdvisors().length == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {
            throw new AopConfigException("No advisors and no TargetSource specified");
        }
        this.advised = config;
    }


    @Override
    public Object getProxy() {
        return getProxy(ClassUtils.getDefaultClassLoader());
    }
         /**
           * 这里其实就是我们之前文章中讲到的JDK的动态代理生成机制，调用了Proxy.newProxyInstance的静态方法
           * 最后一个参数传入的是this，所以这个类是继承自InvocationHandler的，最终执行方法时也是会执行到invoke方法
           */
    @Override
    public Object getProxy(ClassLoader classLoader) {
        if (logger.isDebugEnabled()) {
            logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
        }
        Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
        findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
        return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
    }

    /**
     * 最终方法会执行到这里，然后会创建ReflectiveMethodInvocation，使用责任链模式，开始执行拦截器链
     * 每个通知最终都会创建一个对应的拦截器，比如BeforeAdvice对应MethodBeforeAdviceInterceptor
         * AfterAdvice对应AfterReturningAdviceInterceptor
     * SurroundAdvice本身就是一个拦截器
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        MethodInvocation invocation;
        Object oldProxy = null;
        boolean setProxyContext = false;

        TargetSource targetSource = this.advised.targetSource;
        Class<?> targetClass = null;
        Object target = null;

        try {
            Object retVal;

            if (this.advised.exposeProxy) {
                oldProxy = AopContext.setCurrentProxy(proxy);
                setProxyContext = true;
            }
            target = targetSource.getTarget();
            if (target != null) {
                targetClass = target.getClass();
            }

            /** 这里是根据上面添加的通知，创建对应的拦截器，详细代码可以参考DefaultAdvisorChainFactory的getInterceptorsAndDynamicInterceptionAdvice方法
              * 每个通知（Advice）会对应一个AdvisorAdapter，根据AdvisorAdapter又可以获取一个MethodInterceptor，具体可以参考DefaultAdvisorAdapterRegistry类
*/
            List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

            if (chain.isEmpty()) {

                Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
                retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
            }
            else {
                invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                retVal = invocation.proceed();
            }
            Class<?> returnType = method.getReturnType();
            if (retVal != null && retVal == target &&
                    returnType != Object.class && returnType.isInstance(proxy) &&
                    !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {

                retVal = proxy;
            }
            else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
                throw new AopInvocationException(
                        "Null return value from advice does not match primitive return type for: " + method);
            }
            return retVal;
        }
        finally {
            if (target != null && !targetSource.isStatic()) {

                targetSource.releaseTarget(target);
            }
            if (setProxyContext) {
                AopContext.setCurrentProxy(oldProxy);
            }
        }
    }

}
ReflectiveMethodInvocation

ReflectiveMethodInvocation是用来实现责任链模式的，就是利用我们得到的拦截器列表创建ReflectiveMethodInvocation对象，然后执行ReflectiveMethodInvocation的proceed方法，其实就是遍历执行拦截器的invoke方法，同时把ReflectiveMethodInvocation对象本身传入到invoke中，这样执行完拦截器的内容后，又会回到这个ReflectiveMethodInvocation种执行proceed方法，反复如此，知道拦截器全部执行完成，已达到调用链的执行模式，这个责任链模式的调用过程中，不论如何使用拦截器，最终的被代理对象的方法肯定是只会执行一次的，这一点可以根据源码看到

public Object proceed() throws Throwable {
        if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
            return invokeJoinpoint();
        }

        Object interceptorOrInterceptionAdvice =
                this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
        if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
            InterceptorAndDynamicMethodMatcher dm =
                    (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
            if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
                return dm.interceptor.invoke(this);
            }
            else {
                return proceed();
            }
        }
        else {
            return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
        }
    }
Spring 生成的代理类

因为spring aop本就是根据jdk的动态代理来生成代理类的，所以自然和之前讲到的jdk的动态代理生成的模式是一样的，不同点是多实现了几个接口而已，根据上面例子生成的代理类如下

package com.sun.proxy;

public final class $Proxy0 extends Proxy implements IHello, SpringProxy, Advised, DecoratingProxy {
    private static Method m1;
    private static Method m14;
    private static Method m21;
    private static Method m25;
    private static Method m16;
    private static Method m22;
    private static Method m4;
    private static Method m10;
    private static Method m7;
    private static Method m8;
    private static Method m0;
    private static Method m23;
    private static Method m19;
    private static Method m20;
    private static Method m9;
    private static Method m2;
    private static Method m26;
    private static Method m15;
    private static Method m27;
    private static Method m17;
    private static Method m5;
    private static Method m6;
    private static Method m3;
    private static Method m18;
    private static Method m11;
    private static Method m24;
    private static Method m13;
    private static Method m12;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
    }

    public final void addAdvisor(Advisor var1) throws AopConfigException {
        super.h.invoke(this, m14, new Object[]{var1});
    }

    public final boolean isExposeProxy() throws  {
        return (Boolean)super.h.invoke(this, m21, (Object[])null);
    }

    public final boolean isProxyTargetClass() throws  {
        return (Boolean)super.h.invoke(this, m25, (Object[])null);
    }

    public final void removeAdvisor(int var1) throws AopConfigException {
       super.h.invoke(this, m16, new Object[]{var1});
    }

    public final Class[] getProxiedInterfaces() throws  {
        return (Class[])super.h.invoke(this, m22, (Object[])null);
    }

    public final int indexOf(Advisor var1) throws  {
       return (Integer)super.h.invoke(this, m4, new Object[]{var1});
    }

    public final TargetSource getTargetSource() throws  {
       return (TargetSource)super.h.invoke(this, m10, (Object[])null);
    }

    public final void addAdvice(int var1, Advice var2) throws AopConfigException {
       super.h.invoke(this, m7, new Object[]{var1, var2});
    }

    public final void addAdvice(Advice var1) throws AopConfigException {
         super.h.invoke(this, m8, new Object[]{var1});
    }

    public final int hashCode() throws  {
        return (Integer)super.h.invoke(this, m0, (Object[])null);
    }

    public final boolean isInterfaceProxied(Class var1) throws  {
        return (Boolean)super.h.invoke(this, m23, new Object[]{var1});
    }

    public final boolean removeAdvice(Advice var1) throws  {
         return (Boolean)super.h.invoke(this, m19, new Object[]{var1});
    }

    public final void setExposeProxy(boolean var1) throws  {
       super.h.invoke(this, m20, new Object[]{var1});
    }

    public final void setTargetSource(TargetSource var1) throws  {
         super.h.invoke(this, m9, new Object[]{var1});
    }

    public final String toString() throws  {
       return (String)super.h.invoke(this, m2, (Object[])null);
    }

    public final Class getTargetClass() throws  {
        return (Class)super.h.invoke(this, m26, (Object[])null);
    }

    public final void addAdvisor(int var1, Advisor var2) throws AopConfigException {
        super.h.invoke(this, m15, new Object[]{var1, var2});
    }

    public final Class getDecoratedClass() throws  {
       return (Class)super.h.invoke(this, m27, (Object[])null);
    }

    public final boolean removeAdvisor(Advisor var1) throws  {
       return (Boolean)super.h.invoke(this, m17, new Object[]{var1});
    }

    public final int indexOf(Advice var1) throws  {
        return (Integer)super.h.invoke(this, m5, new Object[]{var1});
    }

    public final boolean isFrozen() throws  {
       return (Boolean)super.h.invoke(this, m6, (Object[])null);
    }

    public final void say() throws  {
         super.h.invoke(this, m3, (Object[])null);
    }

    public final boolean replaceAdvisor(Advisor var1, Advisor var2) throws AopConfigException {
        return (Boolean)super.h.invoke(this, m18, new Object[]{var1, var2});
    }

    public final void setPreFiltered(boolean var1) throws  {
        super.h.invoke(this, m11, new Object[]{var1});
    }

    public final String toProxyConfigString() throws  {
        return (String)super.h.invoke(this, m24, (Object[])null);
    }

    public final Advisor[] getAdvisors() throws  {
         return (Advisor[])super.h.invoke(this, m13, (Object[])null);
    }

    public final boolean isPreFiltered() throws  {
         return (Boolean)super.h.invoke(this, m12, (Object[])null);
    }

    static {

            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m14 = Class.forName("org.springframework.aop.framework.Advised").getMethod("addAdvisor", Class.forName("org.springframework.aop.Advisor"));
            m21 = Class.forName("org.springframework.aop.framework.Advised").getMethod("isExposeProxy");
            m25 = Class.forName("org.springframework.aop.framework.Advised").getMethod("isProxyTargetClass");
            m16 = Class.forName("org.springframework.aop.framework.Advised").getMethod("removeAdvisor", Integer.TYPE);
            m22 = Class.forName("org.springframework.aop.framework.Advised").getMethod("getProxiedInterfaces");
            m4 = Class.forName("org.springframework.aop.framework.Advised").getMethod("indexOf", Class.forName("org.springframework.aop.Advisor"));
            m10 = Class.forName("org.springframework.aop.framework.Advised").getMethod("getTargetSource");
            m7 = Class.forName("org.springframework.aop.framework.Advised").getMethod("addAdvice", Integer.TYPE, Class.forName("org.aopalliance.aop.Advice"));
            m8 = Class.forName("org.springframework.aop.framework.Advised").getMethod("addAdvice", Class.forName("org.aopalliance.aop.Advice"));
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            m23 = Class.forName("org.springframework.aop.framework.Advised").getMethod("isInterfaceProxied", Class.forName("java.lang.Class"));
            m19 = Class.forName("org.springframework.aop.framework.Advised").getMethod("removeAdvice", Class.forName("org.aopalliance.aop.Advice"));
            m20 = Class.forName("org.springframework.aop.framework.Advised").getMethod("setExposeProxy", Boolean.TYPE);
            m9 = Class.forName("org.springframework.aop.framework.Advised").getMethod("setTargetSource", Class.forName("org.springframework.aop.TargetSource"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m26 = Class.forName("org.springframework.aop.framework.Advised").getMethod("getTargetClass");
            m15 = Class.forName("org.springframework.aop.framework.Advised").getMethod("addAdvisor", Integer.TYPE, Class.forName("org.springframework.aop.Advisor"));
            m27 = Class.forName("org.springframework.core.DecoratingProxy").getMethod("getDecoratedClass");
            m17 = Class.forName("org.springframework.aop.framework.Advised").getMethod("removeAdvisor", Class.forName("org.springframework.aop.Advisor"));
            m5 = Class.forName("org.springframework.aop.framework.Advised").getMethod("indexOf", Class.forName("org.aopalliance.aop.Advice"));
            m6 = Class.forName("org.springframework.aop.framework.Advised").getMethod("isFrozen");
            m3 = Class.forName("seven.com.seven.aop.IHello").getMethod("say");
            m18 = Class.forName("org.springframework.aop.framework.Advised").getMethod("replaceAdvisor", Class.forName("org.springframework.aop.Advisor"), Class.forName("org.springframework.aop.Advisor"));
            m11 = Class.forName("org.springframework.aop.framework.Advised").getMethod("setPreFiltered", Boolean.TYPE);
            m24 = Class.forName("org.springframework.aop.framework.Advised").getMethod("toProxyConfigString");
            m13 = Class.forName("org.springframework.aop.framework.Advised").getMethod("getAdvisors");
            m12 = Class.forName("org.springframework.aop.framework.Advised").getMethod("isPreFiltered");

    }
}
总结
  1. Spring AOP 是根据一些配置和代理类是否实现接口来选择使用JDK的动态代理还是使用CGLIB的动态代理的
  2. Spring 中的每个通知，前置通知、后置通知、环绕通知等都最终会根据AdvisorAdapter来获取一个MethodInterceptor，然后根据得到的MethodInterceptor集合，最终创建一个MethodInvocation（ReflectiveMethodInvocation），然后通过ReflectiveMethodInvocation来执行每个拦截器，其实是使用了责任链的模式来调用的，和Servet中的Filter是一样的
  3. Spring的AOP其实和容器是没有关系的，也就是是脱离IOC也是可以正常使用AOP的，只不过结合IOC更加完美方便

微信公众号：宋坤明
下面的是我的公众号二维码图片，欢迎关注。
图注:宋坤明公众号

skmhuanhuan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot源码解析（十七）ApringAOP的两种方式JdkDynamicAopProxy和Cglib2AopProxy源码解析
lz710117239的博客
12-17 4036
在springAOP中，创建动态代理有两种方式，jdk的动态代理与cglib。 jdk的动态代理在springAOP中使用的是JdkDynamicAopProxy而cglib在springAOP中使用的类是Cglib2AopProxy，而且创建代理使用的类加载器基本都是ContextClassLoader类加载器。 在springAOP中创建动态代理都是通过ProxyFactory的getPr
Spring AOP JDK动态代理
黄方 （舞动的心弦） 的专栏
09-19 514
Spring AOP JDK动态代理 在没有使用Spring之前，如果要对DAO层进行修改，比如说做数据安全性验证。那么，就需要对DAO层中的每一个方法都进行修改，项目小了好说，大了的话呢？不久后又要删掉这一功能呢？那岂不又是费神之事。 这一问题使用AOP（Aspect Oriented Programming 面向切面编程）就好解决的多了。面向切面编程，就像使用FilterServlet（过
spring-aop原理讲解 JDK动态代理和CGLIB动态代理
bingguang1993的博客
04-21 516
Spring的两大特性是IOC和AOP IOC负责将对象动态的注入到容器，从而达到一种需要谁就注入谁，什么时候需要就什么时候注入的效果。理解spring的ioc也很重要。 但是今天主要来和大家讲讲aop。 AOP 广泛应用于处理一些具有横切性质的系统级服务，AOP 的出现是对 OOP 的良好补充，用于处理系统中分布于各个模块的横切关注点，比如事务管理、日志、缓存等等。 AOP实现的关键在于A...
Spring学习总结（二）——静态代理、JDK与CGLIB动态代理、AOP+IoC
weixin_30485291的博客
07-18 264
AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 ...
Spring AOP中的JDK和CGLib动态代理哪个效率更高？
热门推荐
徐刘根的博客
09-07 5万+
一、背景 今天有小伙伴面试的时候被问到：Spring AOP中JDK 和 CGLib动态代理哪个效率更高？ 二、基本概念 首先，我们知道Spring AOP的底层实现有两种方式：一种是JDK动态代理，另一种是CGLib的方式。 自Java 1.3以后，Java提供了动态代理技术，允许开发者在运行期创建接口的代理实例，后来这项技术被用到了Spring的很多地方。 JDK动态代理主要涉及...
SpringAOP私有方法导致注入失败原理
jy00733505的博客
07-22 7502
SpringAOP私有方法导致注入失败原理 最近开发项目的过程中，项目组成员遇到一个注入失败导致空指针的问题。原因是因为对这个方法进行了SpringAOP切面拦截，且方法是private的。 最后改为public解决问题。但是对于具体导致的原因并没有掌握，于是时候查看源码终于解惑，特此记录。 jar包版本 spring-boot-starter-web 2.1.3.RELEASE spring-aop 5.1.5.RELEASE 问题代码 @RestController @RequestMappi
SpringAOP之JDK动态代理
weixin_43541255的博客
04-15 390
一.什么是AOP？ AOP简介 AOP的全称是Aspect-Oriented Programming，即面向切面编程（也称面向方面编程）。它是面向对象编程（OOP）的一种补充，目前已成为一种比较成熟的编程方式。 AOP采取横向抽取机制，将分散在各个方法中的重复代码提取出来，然后在程序编译或运行时，再将这些提取出来的代码应用到需要执行的地方。这种采用横向抽取机制的方式，采用传统的OOP思想显然...
Spring-AOP-JDK动态代理
05-12
本篇将详细讲解Spring中的AOP实现，特别是JDK动态代理的应用。 首先，我们要了解什么是AOP（Aspect Oriented Programming，面向切面编程）。AOP是一种编程范式，旨在解决应用程序中分散的、横切关注点的问题，如...
Spring框架+SpringAOP动态代理
03-22
SpringAOP动态代理 Spring AOP 使用的动态代理主要有两种方式：JDK 动态代理和 CGLIB 代理。 JDK 动态代理：用于代理实现了接口的类。Spring 会使用 java.lang.reflect.Proxy 类来创建代理对象。 CGLIB 代理：用于...
spring之AOP（动态代理）
09-06
在Spring中，AOP主要通过两种动态代理技术实现：JDK动态代理和CGLIB动态代理。 首先，让我们详细了解一下JDK动态代理。JDK动态代理基于Java的接口实现，它适用于目标对象实现了至少一个接口的情况。在运行时，JDK...
动态代理，JDK实现动态代理，springAOP初学理解动态代理。代码实现
12-20
在Spring AOP中，当目标对象实现了接口时，Spring默认使用JDK动态代理；如果没有实现接口，则使用CGLIB。通过动态代理，Spring可以在方法调用前后添加额外的行为，如切面（Aspect）中的前置通知（Before Advice）、...
springAOP配置动态代理实现
03-28
动态代理则是Spring AOP实现的核心技术之一，它允许我们在运行时创建具有额外行为的对象。下面将详细阐述Spring AOP的配置以及动态代理的实现。 一、Spring AOP基础知识 1. **什么是AOP**：AOP是一种编程范式，...
Spring源码(三) Spring IoC之BeanFactory创建bean和获取bean
一生编程，快乐编程
07-11 922
bean 对象主要放在 map 里面，map 作为缓存。map 的key 是 bean对象的名称， value 是 bean 对象或者对象工厂。代码详情见： https://blog.csdn.net/sinat_32502451/article/details/140155044。详情见： https://blog.csdn.net/sinat_32502451/article/details/140247662。根据 bean 名称，返回已经注册的单例对象，如果没有注册，则创建并注册一个新对象。
5.SpringBoot核心源码-启动类源码分析
最新发布
流月up的博客
07-12 358
SpringBoot核心源码-启动类源码分析
elk部署springboot
Chihirozy的博客
07-11 313
elk部署springboot。
基于SpringBoot构造超简易QQ邮件服务发送 第二版
键盘爱好者
07-09 267
第二版的更新点是追加了 邮箱附件功能 ( 后期追加定时任务 )
SpringSecurity中文文档（Domain Object Security (ACLs)）
znjy111的博客
07-09 769
本节描述 SpringSecurity 如何使用访问控制列表(ACL)提供域对象安全性。复杂的应用程序通常需要定义超出 Web 请求或方法调用级别的访问权限。相反，安全决策需要包括 who (Authentication)、 where (MethodInvation)和 what (Some DomainObject)。换句话说，授权决策还需要考虑方法调用的实际域对象实例主题。假设您正在为宠物诊所设计一个应用程序。基于 Spring 的应用程序的用户主要有两类: 宠物诊所的工作人员和宠物诊所的客户。
Spring AOP - 自定义注解实现共性需求
weixin_43732943的博客
07-09 315
Spring AOP - 自定义注解实现共性需求
SpringSecurity（Authorization Events）
znjy111的博客
07-09 326
对于每个被拒绝的授权，都会激发一个 AuthorizationDeniedEvent。此外，还可以为授予的授权激发 AuthorizationGrantedEvent。若要侦听这些事件，必须首先发布 AuthorizationEventPublisher。Spring Security 的 SpringAuthorizationEventPublisher 可能会做得很好。
spring aop中 JDK动态代理详解
04-21
好的，关于Spring AOP中JDK动态代理的详解，请听我慢慢道来。 在Spring AOP中，JDK动态代理是一种常用的代理方式。它通过反射机制在运行时创建一个实现指定接口的代理类，并将方法的调用委托给实际的对象，同时还...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值