AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Spring AOP使用

2023-01-11 67
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Spring AOP使用

@[toc]

一、简介

AOP全程是Aspect—Oriented—Programming，面向切面编程。AOP采用横向抽取机制，将分散在各个方法中的重复代码抽取出来，然后在程序编译或运行时，再将这些提取出来的代码应用到需要执行的地方。

  使用AOP编程，可以使开发人员专心于核心业务，而不用过多的关注于其他业务逻辑的是实现，不但提高了开发效率，而且增强了代码的可维护性。

  目前最流行的AOP框架有两个，分别是Spring AOP和AspectJ。其中：Spring AOP采用纯Java实现，不需要专门的编译过程和类加载器，在运行期间通过代理方式向目标类织入增强的代码。AspectJ是一个基于Java语言的AOP框架，从Spring 2.0开始，AspectJ扩展了Java语言，扩展了一个专门的编译器，在编译时提供横向代码的织入。

二、重点解析

1、代理分类

  • Pointcut：全局切入点
  • Before：前置通知
  • After-returning：后置通知
  • Around：环绕通知
  • After-throwing：异常通知
  • After：最终通知
  • Declare-parents：引介通知

2、切入点位置配置(expression)

    // 定义切入点表达式
    @Pointcut("execution(* com.lydms.jdk.*.*(..))")
private void myPointCut(){}
  • 第1个：表示返回类型，表示任意返回类型。
  • com.lydms.jdk：表示需要拦截的包名。
  • 第2个：表示类名，表示所有类。
  • 第3个：表示方法名，表示所有方法。
  • (..)：表示方法的参数，”..“表示任意参数。
  • 第一个*与包名之间有空格。

3、配置通知

属性名称 描述
pointcut 该属性用于指定一个切入点表达式，Spring将在匹配表达式的连接点时织入该通知。
pointcut-ref 该属性指定一个已经存在的切入点名称。通常pointcut和pointcut-ref两个属性只需要其中之一。
method 该属性指定一个方法名。指定将切面Bean中的该方法转换为增强处理。
throwing 该属性只对<after-throwing>元素有效，它用于指定一个形参名，异常通知方法可以通过该形参访问目标方法所抛出的异常。
returning 该属性只对<after-returning>元素有效。它用于指定一个形参名，后置通知方法可以通过该形参访问目标方法的返回值。

案例一：表示任意方法的任意类任意参数都走切面。

    @Pointcut("execution(* com.lydms.jdk.*.*(..))")
    private void myPointCut(){
  }

案例二：public修饰符，在upload类下的。方法走切面。

    @Pointcut("execution(public * com.lydms.controller.upload.*(..))")
    public void webLog() {
    }

二、动态代理

  • Sring AOP中的代理。可以是JDK动态代理，也可以是CGLIB代理。
  • JDK动态代理实现很简单，但是有一定局限性—使用动态代理的对象必须实现一个或多个接口。假如没有实现的，则使用CGLIB代理。

1、JDK动态代理

JDK动态代理通过java.lang.reflect.proxy来实现。可以调用Proxy类的newProxyInstance( )方法来创建代理对象。对于使用业务接口的类，Spring 默认使用JDK动态代理来实现AOP。

1)、UserDao接口

public interface UserDao {
    public void addUser();
    public void deleteUser();
}

2)、UserDaoImpl实现类

import org.springframework.stereotype.Repository;

// 目标类
@Repository("userDao")
public class UserDaoImpl implements UserDao {
    public void addUser() {
//        int i = 10/0;
        System.out.println("添加用户");
    }
    public void deleteUser() {
        System.out.println("删除用户");
    }
}

3)、代理实现类

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import com.lydms.aspect.MyAspect;
/**
 * JDK代理类
 */
public class JdkProxy implements InvocationHandler{
    // 声明目标类接口
    private UserDao userDao;
    // 创建代理方法
    public  Object createProxy(UserDao userDao) {
        this.userDao = userDao;
        // 1.类加载器
        ClassLoader classLoader = JdkProxy.class.getClassLoader();
        // 2.被代理对象实现的所有接口
        Class[] clazz = userDao.getClass().getInterfaces();
        // 3.使用代理类，进行增强，返回的是代理后的对象
        return  Proxy.newProxyInstance(classLoader,clazz,this);
    }
    /*
     * 所有动态代理类的方法调用，都会交由invoke()方法去处理
     * proxy 被代理后的对象 
     * method 将要被执行的方法信息（反射） 
     * args 执行方法时需要的参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 声明切面
        MyAspect myAspect = new MyAspect();
        // 前增强
        myAspect.check_Permissions();
        // 在目标类上调用方法，并传入参数
        Object obj = method.invoke(userDao, args);
        // 后增强
        myAspect.log();
        return obj;
    }
}

4)、测试类

public class JdkTest{
    public static void main(String[] args) {
        // 创建代理对象
        JdkProxy jdkProxy = new JdkProxy();
         // 创建目标对象
        UserDao userDao= new UserDaoImpl();
        // 从代理对象中获取增强后的目标对象
        UserDao userDao1 = (UserDao) jdkProxy.createProxy(userDao);
        // 执行方法
        userDao1.addUser();
        userDao1.deleteUser();
    }
}

执行结果：

在这里插入图片描述

2、CGLIB代理

是一个高性能的开源的代码生成包，采用非常底层字节码技术，对指定的目标类生成子类，并对子类进行加强。

1)、UserDao.java

//目标类
public class UserDao {
    public void addUser() {
        System.out.println("添加用户");
    }
    public void deleteUser() {
        System.out.println("删除用户");
    }
}

2)、代理类

import java.lang.reflect.Method;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import com.lydms.aspect.MyAspect;
// 代理类
public class CglibProxy implements MethodInterceptor{
    // 代理方法
    public  Object createProxy(Object target) {
        // 创建一个动态类对象
        Enhancer enhancer = new Enhancer();
        // 确定需要增强的类，设置其父类
        enhancer.setSuperclass(target.getClass());
        // 添加回调函数
        enhancer.setCallback(this);
        // 返回创建的代理类
        return enhancer.create();
    }
    /**
     * proxy CGlib根据指定父类生成的代理对象
     * method 拦截的方法
     * args 拦截方法的参数数组
     * methodProxy 方法的代理对象，用于执行父类的方法 
     */
    @Override
    public Object intercept(Object proxy, Method method, Object[] args, 
                                 MethodProxy methodProxy) throws Throwable {
         // 创建切面类对象
        MyAspect myAspect = new MyAspect();
        // 前增强
        myAspect.check_Permissions();
        // 目标方法执行
        Object obj = methodProxy.invokeSuper(proxy, args);
        // 后增强
        myAspect.log();    
        return obj;
    }
}

3)、测试类

// 测试类
public class CglibTest {
    public static void main(String[] args) {
        // 创建代理对象
        CglibProxy cglibProxy = new CglibProxy();
             // 创建目标对象
        UserDao userDao = new UserDao();
         // 获取增强后的目标对象
        UserDao userDao1 = (UserDao)cglibProxy.createProxy(userDao);
        // 执行方法
        userDao1.addUser();
        userDao1.deleteUser();
    }
}

执行结果:
在这里插入图片描述

四、AspectJ开发

1、基于XML的声明式AspectJ

1) 简介

2) 切面类

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
/**
 *切面类，在此类中编写通知
 */
public class MyAspect {
    // 前置通知
    public void myBefore(JoinPoint joinPoint) {
        System.out.print("前置通知 ：模拟执行权限检查...,");
        System.out.print("目标类是："+joinPoint.getTarget() );
        System.out.println(",被织入增强处理的目标方法为："
                            +joinPoint.getSignature().getName());
    }
    // 后置通知
    public void myAfterReturning(JoinPoint joinPoint) {
        System.out.print("后置通知：模拟记录日志...," );
        System.out.println("被织入增强处理的目标方法为："
                          + joinPoint.getSignature().getName());
    }
    /**
     * 环绕通知
     * ProceedingJoinPoint 是JoinPoint子接口，表示可以执行目标方法
     * 1.必须是Object类型的返回值
     * 2.必须接收一个参数，类型为ProceedingJoinPoint
     * 3.必须throws Throwable
     */
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) 
             throws Throwable {
        // 开始
        System.out.println("环绕开始：执行目标方法之前，模拟开启事务...");
        // 执行当前目标方法
        Object obj = proceedingJoinPoint.proceed();
        // 结束
        System.out.println("环绕结束：执行目标方法之后，模拟关闭事务...");
        return obj;
    }
    // 异常通知
    public void myAfterThrowing(JoinPoint joinPoint, Throwable e) {
        System.out.println("异常通知：" + "出错了" + e.getMessage());
    }
    // 最终通知
    public void myAfter() {
        System.out.println("最终通知：模拟方法结束后的释放资源...");
    }
}

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:aop="http://www.springframework.org/schema/aop"
        xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
    <!-- 1 目标类 -->
    <bean id="userDao" class="com.lydms.jdk.UserDaoImpl" />
    <!-- 2 切面 -->
    <bean id="myAspect" class="com.lydms.aspectj.xml.MyAspect" />
    <!-- 3 aop编程 -->
    <aop:config>
        <!-- 配置切面 -->
        <aop:aspect ref="myAspect">
          <!-- 3.1 配置切入点，通知最后增强哪些方法 -->
          <aop:pointcut expression="execution(* com.lydms.jdk.*.*(..))"
                                                      id="myPointCut" />
            <!-- 3.2 关联通知Advice和切入点pointCut -->
            <!-- 3.2.1 前置通知 -->
            <aop:before method="myBefore" pointcut-ref="myPointCut" />
            <!-- 3.2.2 后置通知,在方法返回之后执行，就可以获得返回值
             returning属性：用于设置后置通知的第二个参数的名称,类型是Object -->
            <aop:after-returning method="myAfterReturning"
                pointcut-ref="myPointCut" returning="returnVal" />
            <!-- 3.2.3 环绕通知 -->
            <aop:around method="myAround" pointcut-ref="myPointCut" />
            <!-- 3.2.4 抛出通知：用于处理程序发生异常-->
            <!-- * 注意：如果程序没有异常，将不会执行增强 -->
            <!-- * throwing属性：用于设置通知第二个参数的名称，类型Throwable -->
            <aop:after-throwing method="myAfterThrowing"
                pointcut-ref="myPointCut" throwing="e" />
            <!-- 3.2.5 最终通知：无论程序发生任何事情，都将执行 -->
            <aop:after method="myAfter" pointcut-ref="myPointCut" />
        </aop:aspect>
    </aop:config>
</beans>

4) 测试类

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.lydms.jdk.UserDao;
// 测试类
public class TestXmlAspectj {
    public static void main(String args[]) {
        String xmlPath = 
                         "com/lydms/aspectj/xml/applicationContext.xml";
        ApplicationContext applicationContext = 
                          new ClassPathXmlApplicationContext(xmlPath);
        // 1 从spring容器获得内容
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        // 2 执行方法
        userDao.addUser();
    }
}

2、基于注解的声明式AspectJ

1）注解及其描述：

注解名称 描述
@Aspect 用于定义一个切面。
@Pointcut 用于定义切入点表达式。在使用时，还需要定义方法签名(包含名字和任意参数)，来表示切入点名称。
@Before 用于定义前置通知。相当于BeforeAdvice。通常指定一个value值，用来指定切入点表达式。
@AfterReturning 用于定义后置通知。相当于AfterReturningAdvice。
@Around 用于定义环绕通知。相当于MethodInterceptor。
@AfterThrowing 用于定义异常通知来处理程序中未处理的异常。相当于ThrowAdvice。
@After 用于定义最终final通知。无论是否异常，都会执行。
@DeclareParents 用于定义引介通知，相当于IntroductionInterceptor。

2）切面类：

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
/**
 * 切面类，在此类中编写通知
 */
@Aspect
@Component
public class MyAspect {
    // 定义切入点表达式
    @Pointcut("execution(* com.lydms.jdk.*.*(..))")
    // 使用一个返回值为void、方法体为空的方法来命名切入点
    private void myPointCut(){}
    // 前置通知
    @Before("myPointCut()")
    public void myBefore(JoinPoint joinPoint) {
        System.out.print("前置通知 ：模拟执行权限检查...,");
        System.out.print("目标类是："+joinPoint.getTarget() );
        System.out.println(",被织入增强处理的目标方法为："
                       +joinPoint.getSignature().getName());
    }
    // 后置通知
    @AfterReturning(value="myPointCut()")
    public void myAfterReturning(JoinPoint joinPoint) {
        System.out.print("后置通知：模拟记录日志...," );
        System.out.println("被织入增强处理的目标方法为："
                      + joinPoint.getSignature().getName());
    }
    // 环绕通知    
    @Around("myPointCut()")
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) 
            throws Throwable {
        // 开始
        System.out.println("环绕开始：执行目标方法之前，模拟开启事务...");
        // 执行当前目标方法
        Object obj = proceedingJoinPoint.proceed();
        // 结束
        System.out.println("环绕结束：执行目标方法之后，模拟关闭事务...");
        return obj;
    }
    // 异常通知
    @AfterThrowing(value="myPointCut()",throwing="e")
    public void myAfterThrowing(JoinPoint joinPoint, Throwable e) {
        System.out.println("异常通知：" + "出错了" + e.getMessage());
    }
    // 最终通知
    @After("myPointCut()")
    public void myAfter() {
        System.out.println("最终通知：模拟方法结束后的释放资源...");
    }
}

3）注解配置要扫描的包：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:aop="http://www.springframework.org/schema/aop"
  http://www.springframework.org/schema/context/spring-context-4.3.xsd">
      <!-- 指定需要扫描的包，使注解生效 -->
      <context:component-scan base-package="com.lydms" />
      <!-- 启动基于注解的声明式AspectJ支持 -->
      <aop:aspectj-autoproxy />
</beans>

4）测试类：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.lydms.jdk.UserDao;
// 测试类
public class TestAnnotationAspectj {
    public static void main(String args[]) {
        String xmlPath = 
                  "com/lydms/aspectj/annotation/applicationContext.xml";
        ApplicationContext applicationContext = 
                 new ClassPathXmlApplicationContext(xmlPath);
        // 1 从spring容器获得内容
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        // 2 执行方法
        userDao.addUser();
    }
}

五、Spring boot集成AspectJ开发

1、Pom.xml

<!--不指定版本的原因,如不指定版本,会默认下载springboot对应版本的jar -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

2、Controller.java

import com.lydms.common.Result;
import com.lydms.pojo.English;
import com.lydms.service.WordAddService;
import org.apache.commons.lang.StringUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;

@RestController
@RequestMapping("/add")
public class WordAddController {
    private static final Logger logger = LogManager.getLogger(WordAddController.class);

    @Autowired
    private WordAddService wordAddService;

    /**
     * 添加英语
     * @throws Exception
     */
    @RequestMapping(value = "/english", method = {RequestMethod.POST})
    public ApiResult addEnglish(@RequestBody English en) {

//        1、将单词存入数据库
        English result = wordAddService.addEnglish(en);
        return ApiResult.succ(result);
    }
}

3、切面类(Aspect.java)

import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Enumeration;

@Aspect
@Order(5)
@Component
public class ControllerAspect {

    private static final Logger logger = LogManager.getLogger(ControllerAspect.class);

    private ThreadLocal<Long> startTime = new ThreadLocal<Long>();

    @Autowired
    private ObjectMapper mapper;
    
    public ControllerAspect() {
    }

    @Pointcut("execution(public * com.ldyms.controller.*.*(..))")
    public void webLog() {
    }

    @Before("webLog()")
    public void doBefore(JoinPoint joinPoint) throws Throwable {
        startTime.set(System.currentTimeMillis());
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();

        Enumeration<String> enums = request.getParameterNames();
        ArrayList params = new ArrayList();

        while (enums.hasMoreElements()) {
            String paraName = enums.nextElement();
            String param = paraName + ":" + request.getParameter(paraName);
            params.add(param);
        }

        logger.info("request Url:{},Params:{}",(request.getRequestURL().toString()),params);
        logger.info("request Methods:{}", Arrays.toString(joinPoint.getArgs()));
    }

    @AfterReturning(returning = "ret", pointcut = "webLog()")
    public void doAfterReturning(Object ret) throws Throwable {
        logger.info("RESPONSE: {} ", this.mapper.writeValueAsString(ret));
        logger.info("SPEND TIME: {} ms", System.currentTimeMillis() - startTime.get());
    }
}
文章标签：
Java
Spring
数据格式
XML
编译器
关键词：
Spring AOP
ha_lydms
目录
相关文章
运营研究坊
|
21天前
|
XML Java 开发者
Spring Boot中的AOP实现
Spring AOP（面向切面编程）允许开发者在不修改原有业务逻辑的情况下增强功能，基于代理模式拦截和增强方法调用。Spring Boot通过集成Spring AOP和AspectJ简化了AOP的使用，只需添加依赖并定义切面类。关键概念包括切面、通知和切点。切面类使用`@Aspect`和`@Component`注解标注，通知定义切面行为，切点定义应用位置。Spring Boot自动检测并创建代理对象，支持JDK动态代理和CGLIB代理。通过源码分析可深入了解其实现细节，优化应用功能。
运营研究坊
62 6
Cyan_RA9
|
4天前
|
XML Java 测试技术
Spring AOP—通知类型 和 切入点表达式 万字详解（通俗易懂）
Spring 第五节 AOP——切入点表达式 万字详解！
Cyan_RA9
49 25
Cyan_RA9
|
4天前
|
XML 安全 Java
Spring AOP—深入动态代理 万字详解（通俗易懂）
Spring 第四节 AOP——动态代理 万字详解！
Cyan_RA9
49 24
Harry技术
|
30天前
|
存储 安全 Java
Spring Boot 3 集成Spring AOP实现系统日志记录
本文介绍了如何在Spring Boot 3中集成Spring AOP实现系统日志记录功能。通过定义`SysLog`注解和配置相应的AOP切面，可以在方法执行前后自动记录日志信息，包括操作的开始时间、结束时间、请求参数、返回结果、异常信息等，并将这些信息保存到数据库中。此外，还使用了`ThreadLocal`变量来存储每个线程独立的日志数据，确保线程安全。文中还展示了项目实战中的部分代码片段，以及基于Spring Boot 3 + Vue 3构建的快速开发框架的简介与内置功能列表。此框架结合了当前主流技术栈，提供了用户管理、权限控制、接口文档自动生成等多项实用特性。
Harry技术
72 8
互联网课堂
|
3月前
|
XML Java 数据安全/隐私保护
Spring Aop该如何使用
本文介绍了AOP（面向切面编程）的基本概念和术语，并通过具体业务场景演示了如何在Spring框架中使用Spring AOP。文章详细解释了切面、连接点、通知、切点等关键术语，并提供了完整的示例代码，帮助读者轻松理解和应用Spring AOP。
互联网课堂
78 2
Spring Aop该如何使用
一位隐者
|
3月前
|
监控 安全 Java
什么是AOP？如何与Spring Boot一起使用？
什么是AOP？如何与Spring Boot一起使用？
一位隐者
105 5
潇洒洒
|
3月前
|
Java 开发者 Spring
深入解析：Spring AOP的底层实现机制
在现代软件开发中，Spring框架的AOP（面向切面编程）功能因其能够有效分离横切关注点（如日志记录、事务管理等）而备受青睐。本文将深入探讨Spring AOP的底层原理，揭示其如何通过动态代理技术实现方法的增强。
潇洒洒
95 8
游客fmoyiwnvddywe
|
3月前
|
Java 开发者 Spring
Spring AOP 底层原理技术分享
Spring AOP（面向切面编程）是Spring框架中一个强大的功能，它允许开发者在不修改业务逻辑代码的情况下，增加额外的功能，如日志记录、事务管理等。本文将深入探讨Spring AOP的底层原理，包括其核心概念、实现方式以及如何与Spring框架协同工作。
游客fmoyiwnvddywe
82 6
张志凌
|
3月前
|
XML 监控 安全
深入调查研究Spring AOP
【11月更文挑战第15天】
张志凌
59 5
最好zzz
|
3月前
|
Java 开发者 Spring
Spring AOP深度解析：探秘动态代理与增强逻辑
Spring框架中的AOP（Aspect-Oriented Programming，面向切面编程）功能为开发者提供了一种强大的工具，用以将横切关注点（如日志、事务管理等）与业务逻辑分离。本文将深入探讨Spring AOP的底层原理，包括动态代理机制和增强逻辑的实现。
最好zzz
64 4

热门文章

最新文章

  • 1
    Spring Cloud Alibaba AI 入门与实践
  • 2
    Spring Boot 3 集成 Spring Security + JWT
  • 3
    Spring Boot 3 整合 Minio 实现文件存储
  • 4
    Spring Boot 3 整合 Mybatis-Plus 实现数据权限控制
  • 5
    SpringBoot缓存注解使用
  • 6
    使用Spring Boot集成Nacos
  • 7
    Spring Boot 两种部署到服务器的方式
  • 8
    2025春招，Spring 面试题汇总
  • 9
    Spring AI 智能体通过 MCP 集成本地文件数据
  • 10
    Spring之定时任务基本使用篇
  • 1
    Spring Boot微服务部署与监控的实战指南
    338
  • 2
    Spring c3p0配置详解
    159
  • 3
    实时计算 Flink版产品使用问题之Spring Boot集成Flink可以通过什么方式实现通过接口启动和关闭Flink程序
    225
  • 4
    实时计算 Flink版产品使用问题之使用Spring Boot启动Flink处理任务时，使用Spring Boot的@Scheduled注解进行定时任务调度，出现内存占用过高，该怎么办
    158
  • 5
    2024最新首发，全网最全 Spring Boot 学习宝典(附思维导图)
    475
  • 6
    《滚雪球学Spring Boot》教程导航帖（更新于2024.07.16）
    110
  • 7
    如何优化Spring Boot应用性能？
    103
  • 8
    Spring Boot 2.x新特性有哪些？
    116
  • 9
    如何实现Springboot+camunda+mysql的集成
    479
  • 10
    Spring Boot框架在java领域的优势
    115

    • 相关课程

    更多
  • 全面讲解Spring Cloud Alibaba技术栈（知识精讲+项目实战）第三阶段
  • 精通Spring Cloud Alibaba
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库

    • 相关实验场景

    更多
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    DeepSeek-V2.5-1210 在线开放使用！支持联网搜索，在各大领域的表现得到全面提升