SpringBoot快速入门

最新推荐文章于 2024-09-09 00:23:25 发布
置顶 最新推荐文章于 2024-09-09 00:23:25 发布
阅读量822 收藏 3
点赞数 1
分类专栏： spring 文章标签： 入门案例 yml 自动配置类原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yutao_Struggle/article/details/80475824
版权

1. SpringBoot简介

Spring Boot来简化Spring应用开发，约定大于配置，去繁从简，just run就能创建一个独立的、产品级别的应用。
背景：
J2EE笨重的开发、繁多的配置、低下的开发效率、复杂的部署流程、第三方技术集成难度大。
解决：
Spring Boot ——> J2EE一站式解决方案
Spring Cloud ——> 分布式整体解决方案
优点：

  • 快速创建独立的Spring应用程序以及与主流框架集成
  • 直接嵌入Tomcat，Jetty或Undertow（无需部署WAR文件）
  • 提供自己的’入门’POM来简化你的Maven配置（starters自动依赖与版本控制）
  • 尽可能自动配置Spring，简化开发，也可修改默认值
  • 提供生产就绪功能，如指标，运行状况检查和外部配置
  • 绝对不会生成代码，并且不需要XML配置
  • 与云计算的天然集成

学习SpringBoot之前需要熟悉Spring Framework框架，最好熟悉Spring的注解驱动开发

2. 快速入门

2.1 入门案例

1.maven配置（Spring Boot 2.0.2.RELEASE需要Java 8或9以及 Spring Framework 5.0.6.RELEASE或更高版本。为Maven 3.2+和Gradle 4提供了明确的构建支持）

<!-- Inherit defaults from Spring Boot -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.2.RELEASE</version>
</parent>
<!-- Add typical dependencies for a web application -->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>
<!-- Package as an executable jar -->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

2.SpringBoot启动程序

/**
 * SpringBootApplication标注一个主程序类（主配置类），说明这是一个SpringBoot应用，SpringBoot运行
 * 这个类的main方法来启动SpringBoot应用
 */
@SpringBootApplication
public class HelloWorldMainApplication {
    public static void main(String[] args) {
        //spring应用启动
        SpringApplication.run(HelloWorldMainApplication.class,args);
    }
}

3.编写相关的Controller、Service等

/**
 * @Controller
 * @ResponseBody
 * spring4.2
 */
@RestController
public class HelloController {
    @RequestMapping(value = "/hello")
    public String execute() {
        return "hello world quick";
    }
}

2.2 案例解析

2.2.1 pom文件

父项目

maven配置中继承父项目spring-boot-starter-parent的依赖，而spring-boot-starter-parent继承了spring-boot-dependencies，spring-boot-dependencies它来真正管理Spring Boot应用里面的所有依赖版本，因此以后我们导入依赖默认是不需要写版本（没有在dependencies里面管理的依赖自然需要声明版本号）。

starter

spring-boot-starter-*：spring-boot场景启动器，Spring Boot将所有的功能场景都抽取出来，做成一个个的starters（启动器），只需要在项目里面引入这些starter相关场景的所有依赖都会导入进来。SpringBoot的starter见官方文档

2.2.2 主程序

应用程序通过main方法启动。这只是一个遵循Java约定的应用程序入口点的标准方法。我们的main方法通过调用委托给Spring Boot的类SpringApplication的run。 SpringApplication引导我们的应用程序，我们需要将HelloWorldMainApplication.class作为run方法的参数，以确定SpringApplication哪些是主要的Spring组件，args数组也作为命令行参数传入。

@SpringBootApplication

@SpringBootApplication：标注在某个类上，表示这是一个Spring Boot的配置类。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
        @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
}

@SpringBootConfiguration是@Configuration的组合注解，@Configuration标注类表示是配置类，在注解开发中已提及。

@EnableAutoConfiguration：开启自动配置功能，@EnableAutoConfiguration的组合注解时@AutoConfigurationPackage和@Import(AutoConfigurationImportSelector.class)。
1.@AutoConfigurationPackage注解的spring底层注解是@Import(AutoConfigurationPackages.Registrar.class)：

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {
        register(registry, new PackageImport(metadata).getPackageName());
    }
}

new PackageImport(metadata).getPackageName()计算的结果是@SpringBootApplication注解的类的包名，意为将主配置类的所在包及下面所有子包里面的所有组件扫描到Spring容器中。

2.AutoConfigurationImportSelector类实现了DeferredImportSelector接口重写了selectImports方法，该方法返回的是configurations的数组
Configuration
表示给容器中导入了非常多的自动配置类（*AutoConfiguration）。自动配置类是由SpringFactoriesLoader类从META-INF/spring.factories中读取。

2.3 快速创建SpringBoot项目

IDEA：使用 Spring Initializer快速创建项目

  • 主程序已经生成好了，我们只需要我们自己的逻辑
  • resources
    • static：保存所有的静态资源 js css images
    • templates：保存所有的模板页面（Spring Boot默认jar包使用嵌入式的Tomcat，默认不支持JSP页面），可以使用模板引擎（freemarker、thymeleaf）
    • application.properties：Spring Boot应用的配置文件，可以修改一些默认设置

STS：使用 Spring Starter Project快速创建项目

3. 配置文件

SpringBoot使用二种全局的配置文件，配置文件名是固定的：

  • application.properties
  • application.yml

配置文件的作用：修改SpringBoot自动配置的默认值

<!--导入配置文件处理器，配置文件进行绑定就会有提示-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

3.1 application.properties

person.last-name=张三
person.age=18
person.birth=2018/01/01
person.boss=false
person.maps.k1=v1
person.maps.k2=v2
person.lists=a,b,c
person.dog.name=小狗
person.dog.age=2

3.2 application.yml

*.yml是YAML语法编写的配置文件

3.2.1 YAML简介及语法

YAML（YAML Ain’t Markup Language）

YAML  A Markup Language：是一个标记语言

YAML   isn't Markup Language：不是一个标记语言；

标记语言：

以前的配置文件；大多都使用的是  *.xml文件

YAML：以数据为中心，比json、xml等更适合做配置文件
YAML语法

key: value：表示一对键值对（：后必须有空格）
YAML以空格的缩进来控制层级关系，只要左对齐的一列数据都是同一层级，同时对大小写敏感

server:
  port: 8090
  error:
    path: /error
spring:
  aop:
    auto: true

值的写法：

  • 字面量：默认不需要使用单引号或双引号，双引号不会转义字符串内的特殊字符，单引号会转义特殊字符

  • 对象、Map：

    person:
  lastName: hello
  age: 18
或
person: {lastName: hello,age: 18}

  • 数组（List、Set）：

    lists:
    - lisi
    - zhaoliu
或
lists: [lisi,zhaoliu]

  • 多文档：使用[- - -]隔开

    server:
    port: 8090

---
person:
    lastName: hello

3.2.2 配置文件值注入

@Value与@ConfigurationProperties比较

功能@ConfigurationProperties@Value
注入方式批量注入配置文件中的属性一个个指定
松散绑定（松散语法）支持不支持
SpEL不支持支持
JSR303数据校验(@Validated)支持不支持
复杂类型封装支持不支持

应用场景：
配置文件yml还是properties它们都能获取到值
若只是在某个业务逻辑中需要获取一下配置文件中的某项值，使用@Value
若专门编写了一个javaBean来和配置文件进行映射，我们就直接使用@ConfigurationProperties

@ConfigurationProperties

该注解可以将配置文件中配置的每一个属性的值，通过set方法映射到被注释的组件中（因此不可以缺少setter方法）

/**
 * 批量注入、松散绑定、数据校验、复杂类型封装
 */
@Component
@ConfigurationProperties(prefix = "person1")    //批量注入
@Validated  //数据校验
public class Person {
    @Email
    private String lastName;
    private Integer age;
    private Boolean boss;
    private Date birth;
    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;//复杂类型封装

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    ......
}
public class Dog {
    private String name;
    private Integer age;
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
}

applicaton.yml

person1:
  lastName: 888888@qq.com
  #以下二种写法与上述等同（松散绑定）：
  #last-name: 88888@qq.com
  #last_name: 88888@qq.com
  age: 18
  boss: false
  birth: 2018/04/04
  maps: {k1: v1,k2: v2}
  lists:
      - lisi
      - zhaoliu
  dog:
      name: 小狗
      age: 12
@Value
@Component
@Validated
public class Person {
    @Email//数据校验无效
    @Value("${person1.lastName}")//从环境变量、配置文件中获取值
    private String lastName;
    @Value("#{11*2}")//使用SpEL表达式
    private Integer age;
    @Value("true")//直接赋值
    private Boolean boss;
    private Date birth;
    @Value("${person1.maps}")//不支持复杂类型，报错
    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;
    ......
}
@PropertySource、@ImportResource、@Bean
//指明当前类为配置类，替代之前的Spring配置文件
@Configuration
//加载指定的配置文件
@PropertySource(value = {"classpath:person.properties"})
//SpringBoot项目没有Spring的配置文件，若要想自己编写Spring配置文件加载并生效，需要使用@ImportResoure注解标注在一个配置类上
@ImportResource(locations = {"classpath:application.xml"})
public class MyAppConfig {

    @Bean       //注册bean，默认是方法名作为id
    public Person person() {
         return new Person();
    }
}

SpringBoot给容器中添加组件的方式（推荐使用全注解的方式）：

  1. 配置类@Configuration标注@ImportResoure加载Spring配置文件
  2. 使用@Bean给容器中添加组件

3.3 配置文件属性

3.3.1 随机数

RandomValuePropertySource：配置文件中可以使用随机数

  • ${random.value}：随机数字与字母组合的字符串
  • ${random.uuid}：随机uuid
  • ${random.long}：随机long值
  • ${random.int}：随机int值
  • ${random.int(value)}：0~value之间的随机数
  • ${random.int(value,max)}：value~max之间的随机数

这些随机数可以使用在配置文件或@Value注解中

person1:
  lastName: ${random.value}
  age: ${random.int(0,100)}
  #如果birthday不存在使用默认值2014/1/1
  birth: ${birthday:2014/1/1}

3.3.2 profile

Profile是Spring对不同环境提供不同配置功能的支持，可以通过激活、指定参数等方式快速切换环境，多环境有以下二种方式：

  1. 多个profile文件：格式是application-{profile}.properties/yml，例如application-dev.properties，SpringBoot默认加载application.propeties/yml配置文件，可以在该文件中激活不同的profile：spring.profiles.active=dev

  2. 多个profile文档块模式application.yml：

    
#激活指定环境

spring:
  profiles:
    active: dev

---

#开发环境

spring:
  profiles: dev
server:
  port: 8090

---

#生产环境

spring:
  profiles: product
server:
  port: 9090

---

#默认环境

spring:
  profiles: default
server:
  port: 8080

    配置环境也可以在外部文件、命令行或jvm参数中指定，如使用命令行（- -spring.profiles.active=dev）或jvm参数（-Dspring.profiles.active=dev）来激活指定的profile。

3.3.3 配置文件加载顺序

springboot 启动会扫描以下位置的application.properties或者application.yml文件作为Spring boot的默认配置文件

  • file:./config/
  • file:./
  • classpath:/config/
  • classpath:/

上述优先级由高到低，高优先级的配置会覆盖低优先级的配置，同时配置互补。项目打包好以后，我们可以使用命令行参数的形式，启动项目的时候来可以使用spring.config.location指定外部的配置文件位置：

java -jar spring-boot-0.0.1-SNAPSHOT.jar --spring.config.location=D:/application.properties

springboot的所有配置都可以在命令行上指定，多个配置使用空格分开，spring配置的优先级由高到低：

  1. 命令行参数
  2. 来自java:comp/env的JNDI属性
  3. Java系统属性（System.getProperties()）
  4. 操作系统环境变量
  5. RandomValuePropertySource配置的random.*属性值
  6. jar包外部的application-{profile}.properties或application.yml(带spring.profile)配置文件
  7. jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件
  8. jar包外部的application.properties或application.yml(不带spring.profile)配置文件
  9. jar包内部的application.properties或application.yml(不带spring.profile)配置文件
  10. @Configuration注解类上的@PropertySource
  11. 通过SpringApplication.setDefaultProperties指定的默认属性

4. 自动配置原理

  1. SpringBoot启动的时候加载主配置类（@SpringBootApplication），开启了自动配置功能@EnableAutoConfiguration
  2. @EnableAutoConfiguration的组合注解@AutoConfigurationPackage将该配置类包及子包路径下的所有组件扫描进Spring容器中
  3. @EnableAutoConfiguration的组合注解 @Import(AutoConfigurationImportSelector.class)注解导入AutoConfigurationImportSelector类，AutoConfigurationImportSelector类实现了DeferredImportSelector接口重写了selectImports方法，SpringFactoriesLoader.loadFactoryNames()扫描所有jar包类路径下 META-INF/spring.factories把扫描到的这些文件的内容包装成List对象，selectImports将这些自动配置类注册到容器中

4.1 自动配置类案例分析

以HttpEncodingAutoConfiguration 这个自动配置类为例：

@Configuration      //标注该类为配置类
@EnableConfigurationProperties(HttpEncodingProperties.class)     //启动指定类的ConfigurationProperties功能，将配置文件中对应的值和HttpEncodingProperties绑定起来，并把HttpEncodingProperties加入到ioc容器中
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)   //只有基于Servlet的web环境配置类才会生效
@ConditionalOnClass(CharacterEncodingFilter.class)  //判断当前项目有没有CharacterEncodingFilter这个类，CharacterEncodingFilter是SpringMVC中进行乱码解决的过滤器
@ConditionalOnProperty(prefix = "spring.http.encoding", value = "enabled", matchIfMissing = true)//判断配置文件中是否存在spring.http.encoding.enabled这个配置，如果缺失则默认为true
public class HttpEncodingAutoConfiguration {

    private final HttpEncodingProperties properties;
    //将与SpringBoot配置文件映射过的HttpEncodingProperties注入
    public HttpEncodingAutoConfiguration(HttpEncodingProperties properties) {
        this.properties = properties;
    }
    //若容器中没有CharacterEncodingFilter这个组件就注入该bean
    @Bean
    @ConditionalOnMissingBean(CharacterEncodingFilter.class)
    public CharacterEncodingFilter characterEncodingFilter() {
        CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
        filter.setEncoding(this.properties.getCharset().name());
        filter.setForceRequestEncoding(this.properties.shouldForce(HttpEncodingProperties.Type.REQUEST));
        filter.setForceResponseEncoding(this.properties.shouldForce(HttpEncodingProperties.Type.RESPONSE));
        return filter;
    }

    @Bean
    public LocaleCharsetMappingsCustomizer localeCharsetMappingsCustomizer() {
        return new LocaleCharsetMappingsCustomizer(this.properties);
    }

    private static class LocaleCharsetMappingsCustomizer implements
            WebServerFactoryCustomizer<ConfigurableServletWebServerFactory>, Ordered {

        private final HttpEncodingProperties properties;

        LocaleCharsetMappingsCustomizer(HttpEncodingProperties properties) {
            this.properties = properties;
        }

        @Override
        public void customize(ConfigurableServletWebServerFactory factory) {
            if (this.properties.getMapping() != null) {
                factory.setLocaleCharsetMappings(this.properties.getMapping());
            }
        }

        @Override
        public int getOrder() {
            return 0;
        }
    }
}

HttpEncodingProperties类映射配置文件中以spring.http.encoding为前缀的配置

@ConfigurationProperties(
    prefix = "spring.http.encoding"
)
public class HttpEncodingProperties {
   public static final Charset DEFAULT_CHARSET = StandardCharsets.UTF_8;

    /**
     * Charset of HTTP requests and responses. Added to the "Content-Type" header if not
     * set explicitly.
     */
    private Charset charset = DEFAULT_CHARSET;

    /**
     * Whether to force the encoding to the configured charset on HTTP requests and
     * responses.
     */
    private Boolean force;

    /**
     * Whether to force the encoding to the configured charset on HTTP requests. Defaults
     * to true when "force" has not been specified.
     */
    private Boolean forceRequest;

    /**
     * Whether to force the encoding to the configured charset on HTTP responses.
     */
    private Boolean forceResponse;

    /**
     * Locale in which to encode mapping.
     */
    private Map<Locale, Charset> mapping;
    .......
}

application.yml

#yml中可配置的属性也都是根据这些类中的属性来指定
spring:
  http:
    encoding:
      enabled: true
      charset: utf-8
      force: true
      force-request: true
      force-response: true
      mapping: UTF-8

以以上案例可以推论出：每一个自动配置类都会使用@EnableConfigurationProperties(*Properties.class)将对应的*Properties类与配置文件映射后注册到Spring容器中，在通过对应的*Properties类获取相应的属性值给容器添加各种组件。

4.2 @Conditional派生注解

@Conditional*的底层实现都是Spring原生注解@Conditional，只是针对不同的情况作了封装处理

@Conditional扩展注解作用（判断是否满足当前指定条件）
@ConditionalOnJava系统的java版本是否符合要求
@ConditionalOnBean容器中存在指定Bean
@ConditionalOnMissingBean容器中不存在指定Bean
@ConditionalOnExpression满足SpEL表达式指定
@ConditionalOnClass系统中有指定的类
@ConditionalOnMissingClass系统中没有指定的类
@ConditionalOnSingleCandidate容器中只有一个指定的Bean，或者这个Bean是首选Bean
@ConditionalOnProperty系统中指定的属性是否有指定的值
@ConditionalOnResource类路径下是否存在指定资源文件
@ConditionalOnWebApplication当前是web环境
@ConditionalOnNotWebApplication当前不是web环境
@ConditionalOnJndiJNDI存在指定项

自动配置类必须在标注了这些@Conditional*条件成立时才能生效。由于SpringBoot的日志默认使用了INFO级别，我们可以通过配置debug=true属性来查看哪些自动配置类生效了。

yutao_Struggle
关注
专栏目录
SpringBoot（一、快速入门）
m0_56069948的博客
08-11 261
Spring Boot 是由 Pivotal 团队提供的全新框架，其设计目的是用来简化新 Spring 应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。Spring Boot 可以轻松创建可以“直接运行”的独立的、生产级的基于 Spring 的应用程序。Spring Boot 基于Spring开发,Spring Boot 本身并不提供Spring 框架的核心特性以及扩展功能,只是用于快速.敏捷的开发新一代基于Spring 框架的应用程序。...
springboot快速入门
02-20
### Spring Boot 快速入门详解 #### 一、Spring Boot 概述与核心特性 Spring Boot 是基于 Spring 框架开发的一个简化版框架，它极大地简化了开发过程中的配置工作，让开发者能够更快地搭建应用程序。Spring Boot ...
springboot入门
weixin_33766805的博客
11-27 285
springboot入门 Authro:SimpleWu springboot官方 springboot2.1.0参考文档 springboot配置properties大全 SpringBoot是什么? springboot是spring家族中微型框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。 Spring Boot可以轻松创建独立的，生产级的基于Spring的应用...
SpringBoot
最新发布
qq_69907434的博客
09-09 5035
​ Spring Boot是为了简化Spring应用的创建、运行、调试、部署等而出现的，使用它可以做到专注于Spring应用的开发，而无需过多关注XML的配置。学习框架就是学习配置​ 简单来说，它提供了一堆依赖打包Starter，并已经按照使用习惯解决了依赖问题—习惯大于约定。Spring Boot默认使用tomcat作为服务器，使用logback提供日志记录。无需多言，直接进入节奏.​ spring boot 致力于简洁，让开发者写更少的配置，程序能够更快的运行和启动。
Spring Boot 快速入门
lihbj的博客
07-26 640
Spring Boot 优点 1.自动化配置，快速开发，轻松部署； 2.很好的融入docker，支持嵌入式的tomcat、jetty等容器 3.不需要打成war包，只需打成jar包直接运行即可 构建项目 1.通过官方Spring Initializr工具来生成，地址：http://start.spring.io/ 2.点击Generate Project按钮，将代码下载到本地 3...
SpringBoot入门系列：第一篇 Hello World
叼哥的博客
07-22 4219
出于对作者的尊重和感谢，原文地址为 http://blog.csdn.net/lxhjh/article/details/51711148    跟随SpringBoot的文档（http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#boot-documentation）学习，前后
Springboot入门
water_java的博客
12-27 299
Springboot入门SpringBoot是什么？使用Idea配置SpringBoot项目 SpringBoot是什么？ Spring Boot它本身并不提供Spring框架的核心特性以及扩展功能，只是用于快速、敏捷地开发新一代基于Spring框架的应用程序。也就是说，它并不是用来替代Spring的解决方案，而是和Spring框架紧密结合用于提升Spring开发者体验的工具。 同时它集成了大量常...
SpringBoot快速入门.zip
10-29
SpringBoot快速入门.zip是一个针对Java开发者的压缩包，旨在帮助初学者快速掌握SpringBoot框架的基础应用。SpringBoot是由Pivotal团队开发的，它简化了Spring应用的初始搭建以及开发过程，通过内置的默认配置，使得...
【SpringBoot】快速入门
你不来，再美的天地，都狼藉 ~
01-17 875
通过这篇文章，我们可以快速编写SpringBoot项目，体会这门技术带来的简化开发。
spring boot快速入门
随便写写
05-14 4864
springboot快速入门，主要讲解springweb基础，控制器基础，常用注解，RESTful API，swagger文档创建，主要是为了之前讲mybatis进行基础知识补充，以及为下面快速入门mybatisplus做铺垫
Spring-boot快速入门
qq_44098792的博客
07-19 283
Spring Boot -01- 快速入门篇（图文教程） 今天开始不断整理 Spring Boot 2.0 版本学习笔记，大家...
SpringBoot 快速入门
业精于勤-行成于思
01-19 6362
使用SpringBoot编写HelloWorld入门程序
Springboot快速入门
weixin_43859696的博客
11-02 460
Springboot 快速入门Springboot介绍Spring的发展史Springboot的诞生环境准备创建第一个Springboot项目部署第一个Springboot项目 Springboot介绍 Spring的发展史 Spring是2003年兴起的一个轻量级的Java开源框架，这个框架最初是为了解决企业级开发笨重臃肿的问题，宗旨就是为了简化开发。 Springboot的诞生 随着spring越来越火，spring也慢慢的从一个小的框架变成了一个覆盖面广大又全面的框架，随之而来的就是大量的配置文件和第
springboot默认配置原理
Honmaple的博客
05-07 487
3.默认配置原理springboot的默认配置方式和我们之前玩的配置方式不太一样，没有任何的xml。那么如果自己要新增配置该怎么办？比如我们要配置一个数据库连接池，以前会这么玩： 1234567<!-- 配置连接池 --><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-m...
SpringBoot快速入门与实践
1. **SpringBoot快速入门** - 使用Idea创建SpringBoot项目时，可以选择Spring Initializr来初始化项目，设置工程名称和选择需要的模块。 - 创建一个简单的Controller，例如`UserController`，编写一个返回...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值