【spring boot starter的自定义和学习笔记】

于 2024-07-14 12:41:41 发布
阅读量831 收藏 8
点赞数 9
分类专栏： springboot 文章标签： spring boot 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shengfuqiang/article/details/140415256
版权

spring boot starter的自定义和理解

author:shengfq
date:2024-07-14
version:1.0
title:spring boot starter的自定义和理解

1.基本概念

Starter是Spring Boot的四大核心功能特性之一，除此之外，Spring Boot还有自动装配、Actuator监控等特性。
Spring Boot Starter是Spring Boot项目中的一个重要概念，它是一组方便的依赖描述符，可以简化项目配置和依赖管理。通过引入特定的Starter，开发者可以快速地将相关的依赖项添加到项目中，而无需手动配置每个依赖项。
此外，Spring Boot Starter还遵循“约定优于配置”的原则，通过自动配置来减少手动配置的工作量。这意味着，只要项目中存在特定的类、资源或依赖项，Spring Boot就会自动应用相关的配置。

2.Spring Boot Starter的主要特点

简化依赖管理：通过引入Starter，开发者无需手动添加和管理大量的依赖项，降低了配置错误的概率。
约定优于配置：Starter遵循“约定优于配置”的原则，通过默认的配置满足大多数场景的需求，减少了手动配置的工作量。调用者可以最简化配置本地属性.
自动配置：Spring Boot会根据classpath下的类、资源文件和META-INF/spring.factories配置文件自动配置项目所需的各种组件和服务。
易于扩展,快速集成：开发者可以通过自定义Starter来扩展Spring Boot的功能，满足特定项目的需求。提供组件或插件/客户端服务.

3.Spring Boot Starter的应用场景

1.Web应用开发： 通过引入spring-boot-starter-web，开发者可以快速搭建基于Spring MVC的Web应用程序。
2.数据访问层开发： 使用spring-boot-starter-data-jpa或spring-boot-starter-jdbc等Starter，可以简化与关系型数据库的交互。
3.消息队列集成： 通过spring-boot-starter-amqp等Starter，可以方便地集成RabbitMQ等消息队列中间件。
4.安全性控制： 引入spring-boot-starter-security，可以为应用程序添加身份验证、授权等安全功能。
5.微服务架构： 在构建微服务时，可以利用Spring Cloud提供的各种Starter来实现服务发现、配置管理、熔断降级等功能。

4.Spring Boot Starter的实现原理

Spring Boot Starter的原理主要涉及两个方面：起步依赖（起步依赖其实就是将具备某种功能的坐标打包到一起，从而可以简化依赖导入的过程）和自动配置（通过自动配置来减少手动配置的工作量）。

起步依赖：每个Starter都定义了一组相关的依赖项，这些依赖项被打包在一起形成一个独立的模块。当开发者在项目中引入某个Starter时，构建工具会自动解析并下载该模块及其依赖项。
自动配置机制：Spring Boot在启动时会自动扫描classpath下的类、资源文件和META-INF/spring.factories配置文件。这些文件中定义了各种自动配置类，每个自动配置类都包含了一些条件和注解，用于判断是否需要自动配置相应的组件和服务。如果满足条件，Spring Boot就会自动创建并配置这些组件和服务。
配置文件的加载：Spring Boot会默认加载classpath下的application.properties或application.yml配置文件，开发者可以在这些文件中提供自定义的配置属性来覆盖默认配置。此外，Spring Boot还支持通过命令行参数、环境变量等方式提供配置属性。
扩展性支持：开发者可以通过创建自定义的Starter来扩展Spring Boot的功能。自定义Starter需要包含相应的依赖项和自动配置类，并遵循Spring Boot的命名规范和文件结构。然后，将自定义Starter发布到Maven中央仓库或其他仓库中，供其他项目使用。
具体来说，当项目中存在某个Starter时，Spring Boot会读取该Starter中的META-INF/spring.factories文件，该文件定义了该Starter所提供的自动配置类。然后，Spring Boot会根据这些自动配置类中的条件和注解来自动配置相关的组件和服务。例如，如果项目中存在spring-boot-starter-web这个Starter，那么Spring Boot就会自动配置Spring MVC和嵌入式Tomcat等Web相关的组件和服务。

此外，Spring Boot的自动配置还遵循“约定优于配置”的原则，即尽可能使用默认的配置来满足大多数情况的需求，从而进一步减少了手动配置的工作量。如果开发者需要自定义某些配置，可以通过在application.properties或application.yml文件中提供相应的属性值来实现。

总的来说，Spring Boot Starter的原理是通过定义起步依赖和自动配置来简化项目的构建和配置过程。这使得开发者能够更专注于业务逻辑的实现，而无需花费大量时间在繁琐的配置和依赖管理上。

5.生产实践

5.1 自定义starter的步骤
5.1.1 为什么要创建自定义Starter？
虽然Spring Boot提供了许多开箱即用的Starter，但在某些情况下，你可能希望创建自己的Starter来封装你的库、服务或特定的配置逻辑。自定义Starter可以：
将模块功能代码从服务中拆出来作为组件,其他服务可以复用组件功能,无需关注组件具体实现过程,也是
封装思想的提现.

5.1.2 创建自定义Spring Boot Starter的步骤

设置Maven或Gradle项目：
首先，你需要创建一个新的Maven或Gradle项目来构建你的Starter。在项目的pom.xml（对于Maven）或build.gradle（对于Gradle）文件中，添加必要的Spring Boot依赖项和插件。

定义自动配置类：
创建一个带有@Configuration注解的Java类，该类将包含你的Starter提供的所有bean定义和默认配置。你可以使用@Bean注解来定义bean，并使用@ConditionalOn…注解来指定bean的创建条件（例如，当某个类在类路径中可用时）。

打包和发布：
将你的Starter打包为一个JAR文件，并将其发布到Maven中央仓库或其他可用的Maven仓库中。这样，其他项目就可以通过添加对你的Starter的依赖来使用它了。
创建spring.factories文件：在src/main/resources/META-INF目录下创建一个名为spring.factories的文件，并指定你的自动配置类的全限定名。这个文件是Spring Boot在启动时查找自动配置类的地方。

测试你的Starter：
创建一个简单的Spring Boot应用程序来测试你的Starter。通过注入你的Starter提供的bean来验证它们是否按预期工作。你还可以编写单元测试和集成测试来确保你的Starter在各种条件下都能正常工作。

文档和支持：
为你的Starter提供清晰的文档和示例代码，以帮助其他开发者了解如何使用它。
使用自定义Spring Boot Starter
一旦你的自定义Starter被打包并发布到Maven仓库中，其他项目就可以通过在其pom.xml或build.gradle文件中添加对你的Starter的依赖来使用它了。然后，这些项目将能够自动获得你的Starter提供的所有依赖项和默认配置。如果需要的话，它们还可以通过提供自己的配置来覆盖你的Starter的默认配置。

5.1.3 自定义Spring Boot Starter案例
下面是一个创建自定义Spring Boot Starter的案例。我们创建一个名为ftp-spring-boot-starter的Starter(官方推荐命名:spring-boot-starter-xxx)，该Starter将提供一个简单的服务来记录和管理应用程序中的事件。

首先，我们需要创建一个新的Maven项目，并在pom.xml文件中定义必要的依赖项和构建配置。

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>ftp-spring-boot-starter</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>

    <name>ftp-spring-boot-starter</name>
    <description>ftp-spring-boot-starter</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-boot.version>2.6.13</spring-boot.version> 
    </properties>

    <dependencies>
        <!-- Spring Boot Dependencies -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
            <version>${spring-boot.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <version>${spring-boot.version}</version>
        </dependency>

        <!-- Other Dependencies -->
        <!-- Add any other dependencies your starter might need -->
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring-boot.version}</version>
            </plugin>
        </plugins>
    </build>
</project>

接下来，我们创建自动配置类FtpAutoConfiguration，该类将包含我们的服务的默认配置和bean定义。


@Configuration
@EnableConfigurationProperties(FtpClientProperties.class)
@ConditionalOnClass(FtpClientTemplate.class)
@ConditionalOnProperty(prefix = "ftp.client", value = "enabled", matchIfMissing = true)
public class FtpAutoConfiguration {
  private final FtpClientProperties properties;

  public FtpAutoConfiguration(FtpClientProperties properties) {
    this.properties = properties;
  }

  @Bean
  @ConditionalOnMissingBean
  public FtpClientFactory ftpClientFactory() {
    return new FtpClientFactory(properties);
  }

  @Bean
  @ConditionalOnMissingBean
  public FtpClientTemplate ftpClientTemplate(FtpClientFactory ftpClientFactory) {
    return new FtpClientTemplate(ftpClientFactory);
  }
}

然后，我们定义FtpClientTemplate(操作API接口)和FtpClientFactory(连接池化)


package com.coctrl.ftp.service;

import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;

import javax.annotation.PreDestroy;

import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
import org.apache.commons.net.ftp.FTPReply;
import org.apache.commons.net.ftp.FTPSClient;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.springframework.util.ObjectUtils;

import com.coctrl.ftp.CommonException;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class FtpClientTemplate {
  public final String ROOT_PATH = File.separator + "domestic2" + File.separator + "xxx";
  private final GenericObjectPool<FTPSClient> ftpClientPool;

  private FtpClientFactory ftpClientFactory;

  public FtpClientTemplate(FtpClientFactory ftpClientFactory) {
    this.ftpClientPool = new GenericObjectPool<>(ftpClientFactory);
    this.ftpClientPool.setTestOnBorrow(true);
    this.ftpClientFactory = ftpClientFactory;
  }

  @PreDestroy
  public void destroy() {
    this.ftpClientPool.close();
  }

  /***
   * 上传Ftp文件
   *
   * @param localFile 当地文件内容
   * @param remotePath 上传服务器路径 - 应该以/结束
   * @return true or false
   */
  public boolean uploadFile(byte[] localFile, String remotePath, String fileName) {
    if (localFile == null) {
      log.error("上传文件字节为空");
      return false;
    }
    FTPSClient ftpClient = null;
    BufferedInputStream inStream = null;
    boolean upload = false;
    try {
      // 从池中获取对象
      ftpClient = ftpClientFactory.create();
      // 验证FTP服务器是否登录成功
      int replyCode = ftpClient.getReplyCode();
      if (!FTPReply.isPositiveCompletion(replyCode)) {
        log.warn("ftpServer refused connection, replyCode:{}", replyCode);
        throw new CommonException("登录FTP服务器失败");
      }
      // 改变工作路径
      // ftpClient.changeWorkingDirectory(remotePath);
      boolean makeDirectory = ftpClient.makeDirectory(remotePath);
      if (makeDirectory) {
        log.info("路径创建成功 {}", remotePath);
      } else {
        log.info("路径已存在，直接使用 {}", remotePath);
      }
      ftpClient.changeWorkingDirectory(remotePath);
      inStream = new BufferedInputStream(new ByteArrayInputStream(localFile));
      log.info("start upload... {}", fileName);
      upload = ftpClient.storeFile(fileName, inStream);
      log.info("upload file success! {}", fileName);
    } catch (Exception e) {
      log.error("upload file failure!", e);
      throw new CommonException("上传文件失败");
    } finally {
      if (inStream != null) {
        try {
          inStream.close();
        } catch (IOException e) {
          log.error("输入流关闭失败", e);
        }
      }
      // 将对象放回池中
      destroy(ftpClient);
    }
    return upload;
  }

  /**
   * 下载文件
   *
   * @param remotePath FTP服务器文件目录
   * @param fileName 需要下载的文件名称
   * @return true or false
   */
  public byte[] downloadFile(String remotePath, String fileName) {
    FTPSClient ftpClient = null;
    byte[] fileByte = null;
    try {
      ftpClient = ftpClientFactory.create();
      // 切换FTP目录
      FTPFile[] ftpFiles = ftpClient.listFiles(remotePath);
      for (FTPFile file : ftpFiles) {
        if (fileName.equals(file.getName())) {
          /*
           * fileByte = IOUtils.toByteArray(ftpClient.retrieveFileStream(remotePath + "/" +
           * file.getName()));
           */
          break;
        }
      }
      if (ObjectUtils.isEmpty(fileByte)) {
        throw new CommonException("未找到对应的文件,请联系管理员");
      }
      return fileByte;
    } catch (Exception e) {
      log.error("download file failure!", e);
      throw new CommonException(e);
    } finally {
      destroy(ftpClient);
    }
  }

  /**
   * 获取文件大小
   *
   * @param remotePath FTP服务器文件目录
   * @param fileName 需要下载的文件名称
   * @return true or false
   */
  public Long getFileSize(String remotePath, String fileName) {
    FTPSClient ftpClient = null;
    try {
      ftpClient = ftpClientFactory.create();
      // 切换FTP目录
      FTPFile[] ftpFiles = ftpClient.listFiles(remotePath);
      for (FTPFile file : ftpFiles) {
        if (fileName.equals(file.getName())) {
          return file.getSize();
        }
      }
      return 0L;
    } catch (Exception e) {
      log.error("download file failure!", e);
      throw new CommonException(e);
    } finally {
      destroy(ftpClient);
    }
  }

  private void destroy(FTPClient ftpClient) {
    if (ftpClient == null) {
      return;
    }
    try {
      ftpClient.logout();
    } catch (IOException io) {
      log.error("ftp client logout failed...{}", io);
    } finally {
      try {
        if (ftpClient.isConnected()) {
          ftpClient.disconnect();
        }
      } catch (IOException io) {
        log.error("close ftp client failed...{}", io);
      }
    }
  }

  public String getRemotePath(String remotePath) {
    remotePath = ROOT_PATH + File.separator + remotePath;
    return remotePath;
  }

}

package com.coctrl.ftp.service;

import java.io.IOException;

import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPReply;
import org.apache.commons.net.ftp.FTPSClient;
import org.apache.commons.net.util.TrustManagerUtils;
import org.apache.commons.pool2.BasePooledObjectFactory;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.impl.DefaultPooledObject;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;

import com.coctrl.ftp.configuration.FtpClientProperties;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@ConditionalOnProperty(prefix = "ftp.client", value = "enabled", matchIfMissing = true)
public class FtpClientFactory extends BasePooledObjectFactory<FTPSClient> {

  private FtpClientProperties config;

  public FtpClientFactory(FtpClientProperties config) {
    this.config = config;
  }

  /**
   * 创建FtpClient对象
   */
  @Override
  public FTPSClient create() {
    FTPSClient ftpClient = new FTPSClient();
    ftpClient.setControlEncoding(config.getEncoding());
    // ftpClient.setDataTimeout(config.getDataTimeout());
    // ftpClient.setConnectTimeout(config.getConnectTimeout());
    // ftpClient.setControlKeepAliveTimeout(config.getKeepAliveTimeout());
    ftpClient.setTrustManager(TrustManagerUtils.getAcceptAllTrustManager());// 必须设置此属性,通过TSL加密连接
    try {
      ftpClient.connect(config.getHost(), config.getPort());
      int replyCode = ftpClient.getReplyCode();
      if (!FTPReply.isPositiveCompletion(replyCode)) {
        ftpClient.disconnect();
        log.warn("ftpServer refused connection,replyCode:{}", replyCode);
        return null;
      }

      if (!ftpClient.login(config.getUsername(), config.getPassword())) {
        log.warn("ftpClient login failed... username is {}; password: {}", config.getUsername(),
            config.getPassword());
      }
      ftpClient.changeWorkingDirectory(config.getPath());
      ftpClient.setBufferSize(config.getBufferSize());
      ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
      if (config.isPassiveMode()) {
        ftpClient.enterLocalPassiveMode();
      }
      ftpClient.setFileTransferMode(FTP.STREAM_TRANSFER_MODE);
      ftpClient.execPROT("P");
    } catch (IOException e) {
      log.error("create ftp connection failed...", e);
    }
    return ftpClient;
  }

  /**
   * 用PooledObject封装对象放入池中
   */
  @Override
  public PooledObject<FTPSClient> wrap(FTPSClient ftpClient) {
    return new DefaultPooledObject<>(ftpClient);
  }

  /**
   * 销毁FtpClient对象
   */
  @Override
  public void destroyObject(PooledObject<FTPSClient> ftpPooled) {
    if (ftpPooled == null) {
      return;
    }
    FTPClient ftpClient = ftpPooled.getObject();
    try {
      ftpClient.logout();
    } catch (IOException io) {
      log.error("ftp client logout failed...{}", io);
    } finally {
      try {
        if (ftpClient.isConnected()) {
          ftpClient.disconnect();
        }
      } catch (IOException io) {
        log.error("close ftp client failed...{}", io);
      }
    }
  }

  /**
   * 验证FtpClient对象
   */
  @Override
  public boolean validateObject(PooledObject<FTPSClient> ftpPooled) {
    try {
      FTPClient ftpClient = ftpPooled.getObject();
      if (!ftpClient.sendNoOp()) {
        return false;
      }
      // 验证FTP服务器是否登录成功
      int replyCode = ftpClient.getReplyCode();
      if (!FTPReply.isPositiveCompletion(replyCode)) {
        log.warn("ftpServer refused connection, replyCode:{}", replyCode);
        return false;
      }
      return true;
    } catch (IOException e) {
      log.error("failed to validate client: {}", e);
    }
    return false;
  }
}

为了使我们的Starter能够被Spring Boot的自动配置机制识别，我们需要在src/main/resources/META-INF目录下创建一个spring.factories文件，并添加以下配置：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.coctrl.ftp.configuration.FtpAutoConfiguration

这告诉Spring Boot在启动时查找FtpAutoConfiguration类，并根据其中的条件自动配置beans。

现在，我们已经创建了一个简单的自定义Spring Boot Starter。要将其打包并安装到本地Maven仓库中，请在项目根目录下运行以下命令：

mvn clean install

一旦安装完成，其他项目就可以通过在其pom.xml文件中添加以下依赖来使用这个Starter了：


<dependency>
   <groupId>com.coctrl</groupId>
    <artifactId>ftp-spring-boot-starter</artifactId>
    <version>1.0.0.RELEASE</version>
</dependency>

在使用此Starter的项目中，开发者可以通过注入FtpClientTemplate来访问FTP客户端方法，而无需关心如何配置或实现该服务。这就是Spring Boot Starter的强大之处——它提供了可插拔的组件和预配置的默认值，从而加速了开发过程。

5.2.相关注解说明

类注解
@Configuration注解
@ConditionalOnClass
@EnableConfigurationProperties

方法注解
@Bean注解 将组件或插件的实例在容器启动时,声明加入到容器Context中,例如声明一个Exchange,Bing,Queue.
@ConditionalOnMissingBean注解 条件加载注解,只有满足实例bean未被加载时才加载.

spring.factories
Spring的SPI机制介绍
其实是SpringBoot提供的SPI机制，底层实现是基于SpringFactoriesLoader检索ClassLoader中所有jar（包括ClassPath下的所有模块）引入的META-INF/spring.factories文件，基于文件中的接口（或者注解）加载对应的实现类并且注册到IOC容器。这种方式对于@ComponentScan不能扫描到的并且想自动注册到IOC容器的使用场景十分合适，基本上绝大多数第三方组件甚至部分spring-projects中编写的组件都是使用这种方案

6.我的理解

1.starter的2个基本特性,启动自动化配置(预配置)和依赖自动化(预配置),适合于服务客户端组件和插件做自动化集成,用户无需关心依赖的组件配置.
2.软件产品:组件/插件/框架/工程/系统.spring-boot-starter是软件组件制作的框架.mybatis是ORM框架,spring-boot-starter-mybatis是官方提供的快速集成组件,mybatis-plus是基于mybatis实现的更接近应用层的插件.
3.starter的实现原理,还是依赖springboot官方提供的SPI机制,开发者感兴趣可以深究,这是实现组件化的基本原理.

7.常用的官方提供的starter

一些常用的Spring Boot Starter包括：
spring-boot-starter：这是Spring Boot的核心启动器，包含了自动配置、日志和YAML等基础设施。
spring-boot-starter-web：用于构建Web应用程序，提供了Spring MVC和嵌入式Tomcat等Web技术。
spring-boot-starter-data-jpa：用于简化Spring Data JPA的配置和使用，提供了与关系型数据库交互的能力。
spring-boot-starter-test：用于单元测试和集成测试，包含了JUnit、Mockito等测试框架和库。
spring-boot-starter-security：用于提供应用程序的安全性，包括身份验证、授权等功能。
企业级的starter:
spring-boot-starter-amqp 用于支持AMQP协议的消息队列
spring-boot-starter-mail 用于发送电子邮件

二. spring-boot-plugin 插件的引入

<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring-boot.version}</version>
            </plugin>
        </plugins>
    </build>

附录.spring-boot-starter-parent

spring-boot-starter-parent 是 Spring Boot 提供的一个父 POM（Project Object Model），它简化了 Maven 或 Gradle 构建配置，为开发者提供了默认的依赖管理、插件配置以及一些最佳实践设置。当你创建一个新的 Spring Boot 项目时，通常会继承这个父 POM。

在官方文档中，有一个章节介绍了如何管理依赖项，其中就包含了对 spring-boot-starter-parent 的介绍。
相关章节标题：《Managing dependencies with the starter parent POM》
该章节详细解释了为什么使用 spring-boot-starter-parent，以及它如何帮助管理你的项目依赖和版本。尽管 spring-boot-starter-parent 主要关注 依赖管理和构建配置 ，但文档中也有一些章节提到了如何定制自动配置，这可能间接与父 POM 的使用相关联。

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.6.RELEASE</version>
</parent>
<groupId>org.hzero</groupId>
<artifactId>hzero-parent</artifactId>
<version>1.5.0.RELEASE</version>
<packaging>pom</packaging>

mvn dependency:tree
maven工程继承结构
spring-boot-starter-parent
    hzero-parent
        hzero-boot-parent

三.参考文档

深入理解Spring Boot Starter：概念、特点、场景、原理及自定义starter

Spring Boot Maven plugin 官方文档

SpringBoot 自动化配置官方文档

shengfq
关注
  • 9
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Boot学习笔记（超详细）
uuuyy_的博客
12-12 7913
一，spring boot 入门 1、Spring Boot 简介 简化Spring应用开发的一个框架； 整个Spring技术栈的一个大整合； J2EE开发的一站式解决方案； 2、微服务 2014，martin fowler 微服务：架构风格（服务微化） 一个应用应该是一组小型服务；可以通过HTTP的方式进行互通； 单体应用：ALL IN ONE 微服务：每一个功能元素最终都是一个可独立替换和独立升级的软件单元； 3、环境准备 环境约束 –jdk1.8：Spring Boot 推荐
Spring Boot学习笔记
03-21
总结，Spring Boot学习笔记涵盖了Thymeleaf模板引擎的使用，如何实现国际化，以及如何将MyBatis和JDBC整合到Spring Boot应用中，这些都是在构建现代Java后端应用时不可或缺的技术。通过深入理解并掌握这些知识点，...
【SpringBoot学习笔记 五】Spring Boot自定义starter场景启动器
MaoLin Tian's Blog
10-08 873
上篇Blog我们学习了SpringBoot是如何实现自动配置的，通过@Configuration的全注解配置方式和Spring Factories 发现机制自动将组件注入到容器，然后依据配置绑定，确定组件的属性值该是多少，实现了全自动的实现方式，不用我们再操心。在第一篇Blog中我们就提到过场景启动器，那么本篇Blog结合SpringBoot自动配置以及前面学的yaml配置文件等知识来自己实现一个自定义的场景启动器。 starter基本概念 我们再回顾下starter的概念：starter 是 Spring
Spring Boot中 自定义starter逐级抽取过程
2301_79737596的博客
05-29 1307
当我们在写代码过程中,发现一个包里的代码内容可以在多个方面使用,也许我们会选择cv大法,但是这样的做法不利于后期维护,如果想要修改一个细节的功能,就得把每一个粘贴的地方都做一个修改,于是乎我们可以自定义starter,任何项目导入此starter都会具有里面的功能,如若需要修改参数内容,只需在中修改即可..
企业级spring-boot案例-自定义Spring Boot Starter
2401_84048832的博客
04-19 535
在自定义 starter 项目根目录执行进行打包安装fastjsonfastjsoncom:jourwon:config:就写到这了，也算是给这段时间的面试做一个总结，查漏补缺，祝自己好运吧，也希望正在求职或者打算跳槽的 程序员看到这个文章能有一点点帮助或收获，我就心满意足了。多思考，多问为什么。希望小伙伴们早点收到满意的offer!越努力越幸运！
spring boot(学习笔记第三课)
sealaugh32的专栏
06-06 1048
但是原来的classpath:/static/river.png已经失效了，因为Java的配置覆盖了默认的设置。之后访问,https://localhost:8080/river.png。由此可以看出，默认的情况下，静态资源的pattern是。4. 同样可以通过Java代码的方式进行配置。日期格式按照重新定义的表示出来了，但是价格。，所以下面的路径都是静态资源的路径。，但是本来默认路径还是都会变得无效。，是能够继续访问这个静态资源的。的情况下，必须按照修改后来访问。静态资源的路径也可以添加。
手把手教你手写一个最简单的 Spring Boot Starter
2401_84046635的博客
04-21 817
笔者已经把面试题和答案整理成了面试专题文档《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！” />笔者已经把面试题和答案整理成了面试专题文档[外链图片转存中…(img-Eu88gREZ-1713694764288)][外链图片转存中…(img-c92KnDhm-1713694764289)][外链图片转存中…(img-Q62AXatQ-1713694764289)][外链图片转存中…(img-So7MhA5h-1713694764290)]
spring boot(学习笔记第七课)
最新发布
sealaugh32的专栏
06-15 1214
如果想要在一些既存系统上对系统进行分析，监视，但是又不想改修原有的代码，可以通过。注解中的returning="result"和注解对应的方法的参数名必须一致。进行简单的数据库操作。在这里，使用postgresql作为DB服务器。注意，首先学习单一数据库连接，之后练习多数据库。数据库名称: springboot。数据库用户: finlay。数据库密码: 123456。
Spring Boot 2 基础篇学习笔记
闲时不练功，忙时一场空
11-08 1万+
Spring与SpringMVC 知道Spring是用来管理bean，能够基于Restful实现页面请求交互功能 Mybatis与Mybatis-Plus 基于Mybatis和MybatisPlus能够开发出包含基础CRUD功能的标准Dao模块 数据库MySQL 能够读懂基础CRUD功能的SQL语句 服务器 知道服务器与web工程的关系，熟悉web服务器的基础配置 maven 知道maven的依赖关系，知道什么是依赖范围，依赖传递，排除依赖，可选依赖，继承 web技术（含vue，ElementUI
Spring Boot 2 学习笔记（2 / 2）
热门推荐
KISS
02-05 4万+
- - - 45、web实验-抽取公共页面 46、web实验-遍历数据与页面bug修改 47、视图解析-【源码分析】-视图解析器与视图 48、拦截器-登录检查与静态资源放行 49、拦截器-【源码分析】-拦截器的执行时机和原理 50、文件上传-单文件与多文件上传的使用 51、文件上传-【源码流程】文件上传参数解析器 52、错误处理-SpringBoot默认错误处理机制 53、错误处理-【源码分析】底层组件功能分析 54、错误处理-【源码流程】异常处理流程 55、错误处理-【源码流程....
超详细的Spring Boot入门笔记（总结）
08-28
在使用Spring Boot时，需要了解Spring Boot的特性和pom.xml文件的结构，例如了解spring-boot-starter-web依赖项的作用和spring-boot-maven-plugin插件的配置方式。 Spring Boot是一个功能强大且易用的框架，能够...
Spring 学习笔记《Spring Boot》源码
01-22
在《Spring Boot》源码学习笔记中，我们可以深入理解其内部工作机制，包括自动配置、起步依赖、命令行接口（CLI）以及如何集成各种组件如JSP等。JSP（JavaServer Pages）是一种用于动态创建网页的技术，Spring Boot ...
Spring Boot 笔记1
08-08
在本篇Spring Boot笔记中，我们将探讨Spring Boot的核心特性、如何创建一个简单的Spring Boot应用以及相关的Maven配置。Spring Boot是Spring框架的一个扩展，旨在简化Spring应用的初始搭建以及开发过程，提供了一种...
Spring Boot核心技术-笔记1
08-03
【Spring Boot核心技术笔记1】 Spring Boot是Spring框架的延伸，旨在简化Spring应用的...随着对Spring Boot的深入学习，可以进一步探索自动配置、Actuator监控、健康检查、外部化配置、测试支持等更多高级特性和实践。
Spring Boot核心技术-笔记
12-05
这个"Spring Boot核心技术-笔记"很可能包含了关于如何利用Spring Boot进行高效开发的关键概念和实践。下面，我们将深入探讨Spring Boot的一些核心特性、概念以及它们在实际应用中的作用。 1. **自动配置**：Spring ...
Spring学习笔记.zip
03-18
Spring Boot预设了许多默认配置，同时也支持“起步依赖”（Starter POMs），使添加常用功能如数据库连接、Web服务等变得简单。 **Spring Data** Spring Data是Spring框架的一部分，它旨在简化数据访问层的开发。...
Spring Boot核心技术 - 笔记.rar
04-26
例如，`spring-boot-starter-web`提供了开发Web应用程序所需的基本依赖，包括Spring MVC和Tomcat内嵌服务器。只需在`pom.xml`或`build.gradle`文件中引入相应起步依赖，无需手动管理其他依赖。 **三、内嵌Web服务器...
SpringBoot 学习笔记完整教程.pdf
12-12
Spring Boot 是一个用于快速开发的 Java 框架，它简化了基于 Spring 的应用程序的开发。Spring Boot 提供自动配置和约定优于配置的原则，使得开发者能够更加专注于业务逻辑而不是配置文件。使用 Spring Boot 可以快速构建独立的、生产级别的应用程序，同时也提供了丰富的插件和扩展机制。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值