Spring技术原理之Spring AOP

最新推荐文章于 2024-06-17 18:28:19 发布
最新推荐文章于 2024-06-17 18:28:19 发布
阅读量3.2k 收藏
点赞数 1
分类专栏： java进阶部分笔记 文章标签： spring 代理模式 java aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1774381324/article/details/120873733
版权
静态代理:
  1. image-20210601103153495
  2. 问题：
    1. 每个RealSubject对应编写一个Proxy类，比较麻烦。
    2. 大量的Proxy类会导致类规模增大不易维护，影响编译
动态代理:

  1. image-20210601103246821

  2. 两个问题：

    1. 自动生成的Proxy类如何代理实体类？
    2. 运行时如何生成Proxy类？

  3. 自动生成的Proxy类如何代理实体类？

    1. 定义一个全局的公共代理类：Proxy

    2. Proxy类可以根据实体类RealSubject或者实体类的接口来生成一个功能增强的具体代理类（xxxProxy）。注：通过接口生成-JDK动态代理，通过继承生成-CgLib动态代理。

    3. 还有一个问题，这个功能增强的类需要我们在每一个被代理的方法上添加自己的业务逻辑，怎么实现？

    4. 聪明的你肯定可以想到：抽象出一个公共的业务处理接口类InvocationHandler，每个实体类实现这个接口类，定义自己的增强逻辑。

    5. 调用时直接调用生成的xxxProxy对象就好了，因为他和原始的RealSubject具有同样的功能。

    6. JDK动态代理的核心类

      public interface InvocationHandler {
    /**
    * 统一代理接口
    * @param proxy 动态代理生成的对象实例
    * @param method 被代理对象的方法，用于区分哪个对象
    * @param args 调用时传入的参数，用于调用时传入的参数
    * @return
    * @throws Throwable
    */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}
public class Proxy implements java.io.Serializable {
    @CallerSensitive
    public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
    throws IllegalArgumentException{
    //...
    }
}

    7. 例子

      /*** @Description 实体类*/
public class ProxyTest implements ProxyTestInterface{
    @Overridepublic 
    Integer add(Integer a, Integer b) {return a+b;}
}
//下面分别通过静态代理和动态代理来实现代理功能

//静态代理
/**
* @Description 静态代理类
*/
public class StaticProxyTest implements ProxyTestInterface {
    public StaticProxyTest(ProxyTest proxyTest){
    	this.proxyTest = proxyTest;
    }
    private ProxyTest proxyTest;
    @Override
    public Integer add(Integer a, Integer b) {
    	return proxyTest.add(a,b);
    }
    public void main(String[] args){
        ProxyTest proxyTest = new ProxyTest();
        StaticProxyTest staticProxyTest = new StaticProxyTest(proxyTest);
        Integer ret = staticProxyTest.add(1,2);
        System.out.println(ret);
    }
}

//动态代理
/**
* @Description 动态代理测试类
*/
public class DynamicProxyTest {
    public static void main(String[] args){
        ProxyTest proxyTest = new ProxyTest();
        InvocationHandler handler = new MyInvocationHandler(proxyTest);
        ProxyTestInterface proxyTestInterface =
        (ProxyTestInterface) Proxy.newProxyInstance(proxyTest.getClass().getClassLoader(),ProxyTest.class.getInterfaces(),handler);
        Integer ret = proxyTestInterface.add(1,2);
        System.out.println(ret);
        //将动态代理生成的类输出到硬盘上,便于查看
     	ProxyUtils.generateClassFile(proxyTest.getClass(),"test");
    }
    
    static class MyInvocationHandler implements InvocationHandler{
        public MyInvocationHandler(ProxyTest test){
        	proxyTest = test;
        }
        ProxyTest proxyTest;
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println(method.getName());
            Object obj = method.invoke(proxyTest,args);
            return obj;
        }
    }
}

    8. 动态代理源码分析

      public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException {
    Objects.requireNonNull(h);
    final Class<?>[] intfs = interfaces.clone();
    //此处省略一些代码
    /*
    * 此处是关键，生成代理类，是jdk按照class文件的格式，生成二级制数据流，然后再调用native方法生成运行时的Class的
    */
    Class<?> cl = getProxyClass0(loader, intfs);
    //Invoke its constructor with the designated invocation handler.
    try {
        if (sm != null) {
            checkNewProxyPermission(Reflection.getCallerClass(), cl);
        }
        final Constructor<?> cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        if (!Modifier.isPublic(cl.getModifiers())) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
                    cons.setAccessible(true);
                    return null;
                }
            });
        }
        //通过反射，调用有参构造函数完成实例化，此处的参数h就是我们自定义的MyInvocationHandler的实例，那这个构造函数是从哪里生成的？目前猜想肯定是生成的代理的.
        return cons.newInstance(new Object[]{h});
    } catch (IllegalAccessException|InstantiationException e) {
        throw new InternalError(e.toString(), e);
    }
    //...
}

    9. 生成代理类的class文件

      public class ProxyUtils {

    /**
     * 将根据类信息动态生成的二进制字节码保存到硬盘中，默认的是clazz目录下
     * @param clazz 需要生成动态代理类的类
     * @param proxyName 生成的代理类的名称
     */
    public static void generateClassFile(Class clazz,String proxyName)
    {
        //根据类信息和提供的代理类名称，生成字节码
        byte[] classFile = ProxyGenerator.generateProxyClass(proxyName, clazz.getInterfaces());
        String paths = clazz.getResource(".").getPath();
        System.out.println(paths);
        FileOutputStream out = null;

        try {
            //保留到硬盘中
            out = new FileOutputStream(paths+proxyName+".class");
            out.write(classFile);
            out.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

    10. 运行时生成的代理类

      public final class jdkProxyTest extends Proxy implements ProxyTestInterface {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;
    
	public jdkProxyTest(InvocationHandler var1) throws  {
        super(var1);
    }
    
     public final Integer add(Integer var1, Integer var2) throws  {
        try {
            return (Integer)super.h.invoke(this, m3, new Object[]{var1, var2});
        } catch (RuntimeException | Error var4) {
            throw var4;
        } catch (Throwable var5) {
            throw new UndeclaredThrowableException(var5);
        }
    }
    
    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("com.javhl.course.dynamicproxy.ProxyTestInterface").getMethod("add", Class.forName("java.lang.Integer"), Class.forName("java.lang.Integer"));
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }

}

    11. JDK动态代理为什么要求被代理类必须实现接口: Java只支持单继承，可以实现多接口.

  4. CGLIB动态代理:

    /**
 * @Description cglib代理测试类
 */
public class CGLibProxyTest{

    public static void main(String[] args){
        // 代理类class文件存入本地磁盘方便我们反编译查看源码
        			System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\code");
        MethodInterceptor methodInterceptor = new MyMethodInterceptor();
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(ProxyTest.class);
        enhancer.setCallback(methodInterceptor);

        ProxyTest proxyTest = (ProxyTest) enhancer.create();
        Integer ret = proxyTest.add(1,2);
        System.out.println(ret);
    }

    /**
     * 业务增强类，实现耗时时间统计的功能
     */
    static class MyMethodInterceptor implements MethodInterceptor{
        
		@Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            long curTime = System.nanoTime();
            //调用父类的方法
            Object ret = methodProxy.invokeSuper(o,objects);
            System.out.println(String.format("耗时:%s 纳秒",System.nanoTime()-curTime));
            return ret;
        }

    }
}

    1. CGLIB动态代理类源码

      public interface Factory {
    Object newInstance(Callback var1);
    Object newInstance(Callback[] var1);
    Object newInstance(Class[] var1, Object[] var2, Callback[] var3);
    Callback getCallback(int var1);
    void setCallback(int var1, Callback var2);
    void setCallbacks(Callback[] var1);
    Callback[] getCallbacks();
}


/**
 * Cglib运行时生成的动态代理源码
 */
public class ProxyTest$$EnhancerByCGLIB$$17e654b8 extends ProxyTest
  implements Factory{
     public final Integer add(Integer paramInteger1, Integer paramInteger2){
        MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
        if (tmp4_1 == null)
        {
          tmp4_1;
          CGLIB$BIND_CALLBACKS(this);
        }
        MethodInterceptor tmp17_14 = this.CGLIB$CALLBACK_0;
        //如果自己设置了MethodInterceptor那么就使用MethodInterceptor的intercepor方法，否则就使用父类的方法
        if (tmp17_14 != null)
          return (Integer)tmp17_14.intercept(this, CGLIB$add$0$Method, new Object[] { paramInteger1, paramInteger2 }, CGLIB$add$0$Proxy);
        //调用父类ProxyTest的方法，其实此时跟没应用代理是一样的
        return super.add(paramInteger1, paramInteger2);
    }
}

  5. JDK动态代理 VS CGLIB动态代理:

    1. JDK动态代理基于接口，动态代理类和被代理类实现同样的接口。
    2. CGLIB动态代理基于继承，动态代理类继承被代理类，是被代理类的子类。
    3. 两者都需要一个中间类来实现具体的代理逻辑，JDK动态代理的中间类必须实现InvocationHandler接口；CGLIB动态代理的中间类必须实现MethodInterceptor接口。
    4. 在InvocationHandler中JDK动态代理通过反射调用被代理类的接口，必须持有被代理类的实例引用；在MethodInterceptor中CGLIB动态代理通过继承显示调用被代理类的接口。
Spring AOP

  1. AOP相关概念

    1. **Aspect：**切面，一系列Pointcut和Advice的组合。可以想象成多个切点组成了一个切面。
    2. **Joinpoint ：**连接点，主要是指类的方法，一个方法就是一个连接点。
    3. **Advice：**当切点与joinpoint匹配时，对joinpoint所采取的行动。具体来说这个Advice就是一个方法，当joinpoint匹配时，就执行这个方法。在Spring AOP中可以用@Before,@After,@Around,@AfterReturn,@AfterThrow注解来定义一个Advice。
    4. **Pointcut：**与 joinpoint 匹配的正则表达式，用于判断连接点是否被命中的规则。主要通过包路径和注解等方式来定义配置规则。
    5. Weaving：将Advice植入到Joinpoint中，具体的方法是代理模式，在Spring中采用的是动态代理，具体有JDK动态代理和CGLib动态代理。

  2. 工作原理

    image-20210601171109562

  3. 面向切面编程机制

    image-20210601171212797

  4. 例子

    /**
 * @Description AOP测试类，统计接口运行时长
 */
@Component
@Aspect
public class MethodCallTimeAspect {

    @Pointcut("execution(* com.javhl..*.*(..))")
    private void myPointCut(){

    }

    @Around("myPointCut()")
    public Object advice (ProceedingJoinPoint joinPoint) throws Throwable{

        //方法调用开始时间
        long startTime = System.nanoTime();
        Object result = null;
        try {
            result = joinPoint.proceed();
        }finally {
            long timeUsed = System.nanoTime() - startTime;
            StringBuilder sb = new StringBuilder();
            sb.append("class name = [ ").append(joinPoint.getTarget().getClass().getName()).append(" ] ");
            sb.append("methd name = [ ").append(joinPoint.getSignature().getName()).append(" ]")
                    .append(" 耗时: ").append(timeUsed).append(" 纳秒");
            System.out.println(sb.toString());
        }
        return result;
    }
}

  5. Spring框架在创建bean的过程中，当bean完成了初始化后，会用AnnotationAwareAspectJAutoProxyCreator的后置处理器判断bean是否需要代理，如果需要代理（表明配置的Pointcut命中了bean）那么会根据切面中配置的advice为bean创建一个动态代理对象，并将这个对象放到Spring容器中，以后就用这个代理对象来代理具体的bean完成相关业务逻辑。

  6. AbstractAutoProxyCreator源码分析

    public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
    implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware{
    
    //BeanPostProcessor的前置处理，这里不做任何处理原样返回
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
      return bean;
    }

    /**
     * 在bean实例化完成之后，对bean进行包装，生成代理对象。
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
      if (bean != null) {
        //获取bean的缓存名称
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        //判断之前创建的代理引用对象中是否包含当前bean，若有：说明bean已经被包装过了直接返回；否则：调用wrapIfNecessary方法对bean进行包装
        //earlyProxyReferences主要是用来解决Spring中的bean循环依赖时（A依赖B，B依赖A），为需要代理的bean创建代理对象的
        if (!this.earlyProxyReferences.contains(cacheKey)) {
          return wrapIfNecessary(bean, beanName, cacheKey);
        }
      }
      return bean;
    }
    
    /*
    Spring容器启动创建循环依赖的bean的时候，会调用该方法给存在循环依赖的Bean一个创建AOP代理的机会，如果bean满足AOP的条件则创建，否则不创建。
    */
    @Override
    public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        //如果引用不存在则添加
        if (!this.earlyProxyReferences.contains(cacheKey)) {
          this.earlyProxyReferences.add(cacheKey);
        }
        //调用包装方法创建代理对象
        return wrapIfNecessary(bean, beanName, cacheKey);
      }
    
    /**
     * 判断bean是否需要被包装，如果需要返回代理后的对象，否则返回原对象
     */
    protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    if (beanName != null && this.targetSourcedBeans.contains(beanName)) {
      return bean;
    }
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
      return bean;
    }
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
      this.advisedBeans.put(cacheKey, Boolean.FALSE);
      return bean;
    }
    // 判断该bean是否有匹配的切点，如果有则根据pointcut和advise生成advisors
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    if (specificInterceptors != DO_NOT_PROXY) {
      this.advisedBeans.put(cacheKey, Boolean.TRUE);
      //真正的创建代理的方法,下文会重点分析该方法
      Object proxy = createProxy(
          bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
      this.proxyTypes.put(cacheKey, proxy.getClass());
      return proxy;
    }
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
   }
    
    protected Object createProxy(
      Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
     //...
        
    //此句代码是关键，获取具体的代理对象，下面我们继续分析该代码
    //DefaultAopProxyFactory ==>proxyFactory
    return proxyFactory.getProxy(getProxyClassLoader());
  }
 }

  7. DefaultAopProxyFactory源码分析

    public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {

  @Override
  public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
      Class<?> targetClass = config.getTargetClass();
      //判断目标对象是否为空，为空则抛出异常
      if (targetClass == null) {
        //...
      }
      //判断目标对象是否是接口或者JDK动态代理动态生成的对象，
      //若是则构造一个JDK动态代理对象返回，否则构造一个Cglib动态代理对象返回
      if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
        return new JdkDynamicAopProxy(config);
      }
      return new ObjenesisCglibAopProxy(config);
    }
    else {
      return new JdkDynamicAopProxy(config);
    }
  }


}

  8. JdkDynamicAopProxy 源码分析:

    //这个类实现了InvocationHandler接口
final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
  @Override
  public Object getProxy() {
    return getProxy(ClassUtils.getDefaultClassLoader());
  }

  @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);
  }
}
隐 风
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring AOP原理详解及实例
weixin_43611145的博客
10-24 2万+
Spring AOP原理详解及实例 1.Spring AOP简介 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻...
深入浅析Spring AOP的实现原理1
08-08
AOP技术利用一种称为“横切”的技术，解剖封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，这样就能减少系统的重复代码，降低模块间的耦合度，并
Spring——Spring AOP原理
庄小焱
03-30 1984
AOP即面向切面编程，是OOP编程的有效补充。使用AOP技术，可以将一些系统性相关的编程工作，独立提取出来，独立实现，然后通过切面切入进系统。从而避免了在业务逻辑的代码中混入很多的系统相关的逻辑.AOP是Spring提供的关键特性之一，本文深入剖析Spring AOP的原理。
Spring Aop原理全面详解汇总
weixin_43241706的博客
04-22 1143
springaop详情知识点
SpringAOP学习--SpringAOP简介及原理
热门推荐
u012098021的博客
05-15 6万+
前文对AOP做了介绍，实际项目中，一般不会直接上手手动实现aop，而是使用一些高级封装的aop实现，如SpringAOP。 Spring是一个广泛应用的框架，SpringAOP则是Spring提供的一个标准易用的aop框架，依托Spring的IOC容器，提供了极强的AOP扩展增强能力，对项目开发提供了极大地便利。 前文提到AOP的实现有AspectJ、JDK动态代理、CGLIB动态代理，SpringAOP不是一种新的AOP实现，其底层采用的是JDK/CGLIB动态代理。 JDK动态代理回顾 上一篇简单介绍了
spring aop原理
学Java，找哪吒
07-17 1万+
最近进行了一波面试，面试官问我项目中AOP的具体应用，面试的时候我只知道AOP是面向切面编程，动态代理方式实现的，可以用在登录验证、事务和日志上，但具体代码怎么写的，说的那真的是云里雾里，回家猛补了一下AOP。 一、AOP的基本概念 1、什么是AOP？ AOP（Aspect Oriented Programming）称为面向切面编程，在程序开发中主要用来解决一些系统层面上的问题，比如日志，事务，权限等等，Struts2的拦截器设计就是基于AOP的思想，是个比较经典的例子。 在不改变原有逻辑的基础
Spring AOP底层原理
qq_54876312的博客
05-21 2756
什么是AOP AOP：Aspect Oriented Programing(面向切面编程) 采用横向抽取机制，取代传统继承体系重复性代码（性能监视、事务管理、安全检查、缓存）即代理机制 使用纯JAVA实现，不需要专门的编写过程和类加载器，在运行期通过代理方式向目标织入增强代码 AOP相关术语 Joinpoint(连接点）：所谓连接点是指那些可以被拦截到的点。在Spring中，这些点指的是方法，因为spring只支持方法类型的连接点。 Pointcut(切入点）:所谓切入点是指我们要对哪些Joinpoi
SpringAOP原理分析
HelloWorld!
06-14 3万+
目录 Spring核心知识 SpringAOP原理 AOP编程技术 什么是AOP编程 AOP底层实现原理 AOP编程使用 Spring核心知识 Spring是一个开源框架，Spring是于2003年兴起的一个轻量级的Java开发框架，由Rod Johnson在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型...
Spring IOC和AOP原理
傍晚的猫和鱼的博客
10-21 1016
Spring IOC和AOP原理
Spring中AOP的实现原理
qq_44918331的博客
03-11 1万+
一、什么是 AOP ？ AOP（Aspect-Oriented Programming，面向方面编程），对 OOP（Object-Oriented Programming，面向对象编程） 【OOP与AOP】 概念 AOP（Aspect-Oriented Programming，面向方面编程） OOP（Object-Oriented Programming，面向对象编程） 方向 OOP 定义从上到下的关系 AOP 定义从左到右的关系 【两个部分】 核心关注点 业务处理的主要流程
Spring框架的AOP实现原理
qq_59510147的博客
11-20 1885
AOP：面向切面编程，是将那些与业务无关（比如有事务处理，日志管理，权限控制等），但要为业务模块共同调用的逻辑封装成一个可重用的模块，这个模块被称为切面，便于减少系统的重复代码，降低模块间的耦合度，有利于未来的可拓展性和可维护性。另一个为Proxy类，我们可以通过这个类的newProxyInstance（）方法，返回一个代理对象，生成的代理类实现了原来类的所有接口，然后对这些接口进行代理，通过代理对象调用这些方法，底层通过反射来调用我们实现的invoke()方法。此通知可以在方法调用前后完成自定义的行为。
SpringAOP学习笔记
01-27
,文章属于基础级文章，适合入门级的小伙伴，它的概念，应用场景，实现原理及Spring的AOP的开发。全称:面向切面编程(AspectOrientedProgramming),通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。...
spring aop简单示例.rar
12-13
aop的原理基于java动态代理模式，本资源是spring的aop运用简单示例，用于帮助初学者理解和运用aop技术
通过 Spring 技术实现的博客系统
02-12
以及 Spring 的两大特性 IoC（控制权反转） 和 AOP （统一功能处理）都有用到，并且该项目用到的所有技术都能够在作者的博客中找到 本项目是一个非常适合作为新手练习 Java 开发，使用 Spring 和 Mybatis 框架的...
Spring高级之注解驱动开发视频教程
11-05
Spring本身里面包含了两大核心IOC和AOP。IOC负责降低我们代码间的依赖关系，使我们的项目灵活度更高，可复用性更强。AOP是让方法间的各个部分更加独立，达到统一调用执行，使后期维护更加的方便。 SpringMVC本身是...
springboot相关的一些知识
最新发布
qq_44288171的博客
06-17 567
创建项目：首先创建一个普通的maven项目，并且在pom文件中引入spring-boot-autoconfigure依赖，此依赖为SpringBoot自动配置机制的核心。若是自定义的start涉及到属性的配置，也就是需要在YML中配置属性，则可以引入如下依赖-- 使用Spring Boot的最新稳定版 --> < relativePath />
graalvm编译springboot3 native应用
fengchengwu2012的博客
06-12 616
云原生时代容器先行，为了更好的拥抱云原生，spring boot3之后，推出了graalvm编译boot项目，利用jvm的AOT（ Ahead Of Time ）运行前编译技术，可以将javay源码直接构建成机器码二进制的文件，无需jdk静态编译为class字节码，运行时jre解释执行，这样就无需依赖java环境运行，部署到容器中可以直接启动运行。
SpringBoot3 整合 Mybatis 完整版
northcastle的博客
06-14 404
SpringBoot3 整合 MyBatis 的步骤详细记录
Spring IOC 控制反转（注解版）
Dreadnaught的博客
06-17 376
Spring 框架中的核心概念之一就是控制反转（Inversion of Control，IoC）。IOC就是一种思想，而依赖注入(Dependency Injection, DI)是控制反转的一种实现方式。Spring本身是一个容器，存的是对象。对象这个词，在 Spring的范围内，称之为 Bean。控制反转（Inversion of Control，IoC）是一种设计原则，它将对象的创建和依赖关系的管理从程序代码中解耦出来，交由框架或容器进行处理。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

隐 风

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

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

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

打赏作者

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

抵扣说明：

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

余额充值