springboot总结

最新推荐文章于 2023-11-09 11:30:45 发布
最新推荐文章于 2023-11-09 11:30:45 发布
阅读量211 收藏 2
点赞数 1
文章标签： spring boot mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44207915/article/details/105312641
版权

1.介绍

SpringBoot是一个微服务框架。
主要的实现了两大块功能：

  1. 将主流的框架的整合的代码提前都写好了，我们开发人员不需要配置整合代码了，仅仅写框架的参数就可以了。
  2. 直接可以将项目打包为jar，直接通过jar就可以运行，不需要再配置Web服务器。仅写web服务器参数就可以了。

just run（程序员仅仅只需要运行，，其他配置交给我，SpringBoot宗旨）

2.SpringBoot入门示例

1.配置步骤说明

第一步：生成SpringBoot项目（去Spring官方生成）
第二步：导入项目到开发空间
第三步：编写一个入门程序入门（默认整合MVC）

第一部分：生成SpringBoot项目

第一步：进入网站

进入网站：https://spring.io/projects/spring-boot，找到Spring构建入口，如图所示：
在这里插入图片描述

第二步：编写项目信息

在这里插入图片描述

第三步：选择最小模块

在这里插入图片描述

第四步：生成项目

在这里插入图片描述
出现下图，构建成功
在这里插入图片描述

第二部分：导入项目到IDEA

第一步：解压项目文件

将下载好的项目放在Idea的工作目录，解压就可以了。
在这里插入图片描述

第二步：使用Idea打开项目

在这里插入图片描述

第三部分：编写入门代码

第一步：修改入门类类名

注意事项： Idea的源代码文件夹、资源文件夹、测试文件夹都是类路径根目录（classpath:）
在这里插入图片描述

第二步：编写一个Controller
//IDEA代码提示快捷键 Ctrl+Alt+空格
@RestController  //等同@Controller+@ResponseBody
public class HelloController {

    @GetMapping(value="/say")
    //@ResponseBody
   public String say(){
      return "HelloWorld";
   }
}
第三步：启动测试

在这里插入图片描述
查看输出，出现如下则启动成功：
在这里插入图片描述
测试结果：
在这里插入图片描述

2.SpringBoot的POM依赖说明

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <!--继承SpringBoot的父Pom文件，SpringBoot框架的通用配置，主要锁定软件版本-->
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.2.1.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>
   <groupId>org.zhu.springboot</groupId>
   <artifactId>springboot-demo-01-start</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>springboot-demo-01-start</name>
   <description>Demo project for Spring Boot</description>

   <properties>
       <!--配置了JDK为1.8版本，必须要配置了SpringBoot父POM才有效-->
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <!--SpringBoot的Web模块，SpringMVC JSON支持-->
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

       <!--SpringBoot热部署依赖，在Eclipse有效-->
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-devtools</artifactId>
         <scope>runtime</scope>
         <optional>true</optional>
      </dependency>
      <!---SpringBoot测试模块依赖-->
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
         <exclusions>
            <exclusion>
               <groupId>org.junit.vintage</groupId>
               <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
         </exclusions>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <!--SpringBoot的Maven启动插件-->
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
</project>

3.SpringBoot配置文件

SpringBoot默认加载的配置文件是在classpath根目录的application.properties或者application.yml配置文件。

注意： SpringBoot支持properties和yml两个格式的配置文件。

3.1 配置Web服务器参数

1.properties格式配置

–Properties文件的属性，使用的平铺方式书写

##设置server参数
##端口
server.port=8081
##设置上下文路径
server.servlet.context-path=/springboot-demo-02-server-properties
Properties配置步骤

注意事项： 除了application.properties的其他的配置文件的文件名必须是application-xxxx.properties

第一步：编写三个配置文件

在这里插入图片描述

第二步：编写配置文件内容

–application.properties

##指定加载其他配置文件
spring.profiles.active=server1,server2

–application-server1.properties

##配置端口
server.port=8083

–application-server2.properties

##配置上下文路径
server.servlet.context-path=/springboot-demo-03-Properties
第三步：运行项目

在这里插入图片描述

2.yml格式配置
##设置server参数
##注意事项：
##1.冒号（:）和参数值直接必须要有一个空格，否则报错。
##2.必须根据属性的层级，设置好折叠级数
server:
  port: 8082
  servlet:
    context-path: /springboot-demo-02-server-yml
yml配置步骤
第一步：编写三个配置文件

在这里插入图片描述

第二步：分别编写配置信息

注意： SpringBoot启动的时候加载的是application.yml配置文件，再通过application.yml配置文件的spring.profiles.active属性指定加载的其他配置文件。

其他配置文件的文件名格式为：application-.yml

–application.yml

##配置加载多个文件,
##文件名为：application-<active-name>.yml
spring:
  profiles:
    active: server1,server2

–application-server1.yml

##配置服务器端口
server:
  port: 8082

–application-server2.yml

##配置上下文路径
server:
  servlet:
    context-path: /springboot-demo-03-yml
第三步：启动测试

成功结果在这里插入图片描述

3.自定义属性
1.配置步骤
第一步：pom.xml导入包
<!--支持自定义属性-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>
第二步：在入口类启动支持
@SpringBootApplication
@EnableConfigurationProperties({EgoManagerProperties.class}) //启动自定义配置
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(EgoManagerApplication.class, args);
    }
}
第三步：编写自定义属性类
//ftp.client.server,设置前缀，ignoreInvalidFields = true，属性是非必须的
@ConfigurationProperties(prefix = "ftp.client.server", ignoreInvalidFields = true)
public class EgoManagerProperties {

    private String hostname;
    private int port;
    //注意事项：驼峰命名法，在配置文件取该值时，需要使用- 如：base-path
    private String basePath;
    private String username;
    private String password;
//补全get、set
}
第四步：配置文件

applicaiton.yml调用

##Ftp参数,自定义属性的实现
ftp:
  client:
    server:
      ##ftp服务器IP
      hostname: 192.168.68.13
      ##ftp服务器端口
      port: 21
      ##ftp远程服务器基础路径
      base-path: /home/ftpuser/ego/images
      ##ftp远程用户名
      username: ftpuser
      ##ftp远程密码
      password: ftpuser

4.SpringBoot运行原理

在这里插入图片描述
如图所示：

  1. 首先，SpringBoot通过加载SpringApplication入口执行类，加载配置在当前类上面的@SpringBootApplication注解，来启动SpringBoot项目的。

  2. 然后根据@SpringBootApplication注解定义的三个注解@SpringBootConfiguraton、@EnableAutoConfiguration、@ComponentScan,我们清楚知道了入口类的功能：
    @SpringBootConfiguraton注解：意味着入口类本身就是一个配置类
    @EnableAutoConfiguration注解：表示SpringBoot启动的时候就自动加载已经导入jar的组件
    @ComponentScan：表示SpringBoot启动的时候就会扫描当前包和子包的组件类。

  3. 注意事项，SpringBoot内置支持的组件在spring-boot-autoconfigure-2.2.1.RELEASE.jar里面。根据分析，我们知道自动加载的配置类信息都在XxxxAutoConfiguration里面，配置的属性参数基本都在XxxxxProperties里面。
    在这里插入图片描述

5.SpringBoot整合Mybatis

1.配置步骤说明

第一步：创建一个SpringBoot项目
第二步：导入Mybatis的自动加载模块（Mybatis官方）
第三步：编写配置参数
第四步：编写一个测试代码测试
第五步：对日志的支持

2.配置步骤

第一步：创建一个SpringBoot项目

–项目文件
在这里插入图片描述
–pom.xml加入依赖

<?xml version="1.0" encoding="UTF-8"?>
<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>org.zhu.mybatis</groupId>
    <artifactId>springboot-demo-05-mybatis</artifactId>
    <version>1.0</version>

<!--    Ctrl+Shift+/ 表示注释和去掉注释-->
    <!--第一步：加入SpringBoot的父POM信息-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <!--第二步：配置JDK版本-->
    <properties>
        <java.version>1.8</java.version>
    </properties>

   <dependencies>

       <!--第三步：加入SpringBoot支持web的模块-->
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-web</artifactId>
           <version>2.2.1.RELEASE</version>
       </dependency>

       <!--第四步：加入单元测试模块-->
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-test</artifactId>
           <version>2.2.1.RELEASE</version>
           <scope>test</scope>
       </dependency>
   </dependencies>
</project>
第二步：pom.xml导入Mybatis整合SpringBoot的依赖
<!--第五步：加入Mybatis整合依赖-->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.1</version>
</dependency>

<!--第六步：数据源支持-->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-dbcp2</artifactId>
</dependency>

<!--第七步：驱动-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
第三步：编写配置参数

–编写配置文件

###配置数据源
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/users?serverTimezone=GMT
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.type=org.apache.commons.dbcp2.BasicDataSource

–编辑入口类，加入映射接口扫描路径

@SpringBootApplication
//指定扫描的映射接口
//basePackages属性：指定扫描的映射接口
//annotationClass属性：,指定限制扫描的注解，默认是@Mapper注解
@MapperScan(basePackages = "org.ranger.mybatis.mapper",annotationClass = Repository.class)
public class MybatisApplication {

    public static void main(String[] args) {
        SpringApplication.run(MybatisApplication.class, args);
    }

}
第四步：编写插入数据测试代码

–编写POJO

package org.zhu.mybatis.pojo;

//快捷键 ，查找替换：Ctrl+F
public class User {
    private Integer userId;//INT(11) NOT NULL AUTO_INCREMENT,
   private String userName;//VARCHAR(255) NULL DEFAULT NULL,
   private String userAccount;//VARCHAR(255) NULL DEFAULT NULL,
   private String userPassword;//VARCHAR(255) NULL DEFAULT NULL,
    public Integer getUserId() {
        return userId;
    }
    public void setUserId(Integer userId) {
        this.userId = userId;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getUserAccount() {
        return userAccount;
    }
    public void setUserAccount(String userAccount) {
        this.userAccount = userAccount;
    }
    public String getUserPassword() {
        return userPassword;
    }
    public void setUserPassword(String userPassword) {
        this.userPassword = userPassword;
    }
}

–编写Mapper

//注意事项，Mybatis整合SpringBoot的代码，默认强制使用了该注解。所以必须要加上
//需要查看代码在mybatis-spring-boot-autoconfigure-2.1.1.jar找MybatisAutoConfiguration类
@Mapper
public interface UserMapper {
    /**
     * 插入用户
     * @param user
     * @return
     */
    @Options(useGeneratedKeys = true,keyProperty ="userId")
    @Insert("INSERT INTO tb_user(user_name, user_account, user_password) VALUES (#{userName}, #{userAccount}, #{userPassword})")
    int insert(User user);
}

–测试代码
注意事项：

  1. 如果入口类，类名不是Application，必须要手工指定入口类名
  2. 需要加入@RunWith在启动之前，先在Spring配置类。
@SpringBootTest(classes = {MybatisApplication.class})
@RunWith(SpringRunner.class)
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;
    //智能提示快捷键，alt+回车键
    @Test
    public void insert(){
        User user=new User();
        user.setUserName("张三123");
        int insert = userMapper.insert(user);
        System.out.println(insert);
    }
}
第五步：对日志的支持

Mybatis可以直接配置控制台输出Sql语句，不需要任何的日志框架。
配置application.properties配置文件，追加以下配置代码。

##指定日志输出类
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

6.SpringBoot对Servlet组件支持

SpringBoot通过spring-boot-2.2.1.RELEASE.jar核心包下的

  • org.springframework.boot.web.servlet.FilterRegistrationBean
  • org.springframework.boot.web.servlet.ServletListenerRegistrationBean
  • org.springframework.boot.web.servlet.ServletRegistrationBean

三个类支持Servlet的三大组件的。

1.Servlet示例

Servlet代码


public class MyServlet extends HttpServlet {

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("===============Get请求===============");
    }
}

配置类代码

@Configuration
public class WebConfiguration {

    /**
     * 等同在web.xml配置servlet组件
     * @return
     */
    @Bean
    public ServletRegistrationBean<MyServlet> servletRegistrationBean(){
        ServletRegistrationBean<MyServlet> registrationBean=new ServletRegistrationBean<>();
        //指定加载的Servlet
        registrationBean.setServlet(new MyServlet());
        List<String> mappers=new ArrayList<>();
        mappers.add("/myServlet");
        registrationBean.setUrlMappings(mappers);
        return registrationBean;
    }

}

2.Filter过滤器示例

–Filter代码

public class MyFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("-这是一个过滤器-");
        chain.doFilter(request, response);
    }
}

–配置类代码

@Configuration
public class WebConfiguration {

 //配置过滤器
    @Bean
    public FilterRegistrationBean<MyFilter> filterRegistrationBean(){
        FilterRegistrationBean<MyFilter> registrationBean=new FilterRegistrationBean<>();
        registrationBean.setFilter(new MyFilter());
        List<String> mappers=new ArrayList<>();
        mappers.add("/*");
        registrationBean.setUrlPatterns(mappers);
        //指定拦截FORWARD类型的请求
        registrationBean.setDispatcherTypes(EnumSet.of(DispatcherType.REQUEST));
        return registrationBean;
    }
}

3.Listener监听器示例

–Listener代码

@WebListener
public class MyListener implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("容器启动啦");
    }
    
}

–配置类代码

@Configuration
public class WebConfiguration {
   //配置监听器
    @Bean
    public ServletListenerRegistrationBean<MyListener> servletListenerRegistrationBean(){
        ServletListenerRegistrationBean<MyListener> registrationBean=new ServletListenerRegistrationBean<>();
        registrationBean.setListener(new MyListener());
        return registrationBean;
    }

}

7.SpringBoot对war的支持

StringBoot默认不支持使用jar包打包有JSP页面项目，所以如果包含有JSP页面的项目，需要使用war打包

1.配置步骤说明

第一步：导入依赖的包

–pom.xml导入依赖包，并且修改打包为war包

<!--修改为war-->
<packaging>war</packaging>

<!--spring boot jsp页面解释器-->
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
     <scope>provided</scope>
</dependency>
第二步：编写Jsp页面

注意事项： 必须增加Web模块。webapp文件是web根目录。
在这里插入图片描述

第三步：修改入口类

增加对servlet的支持

@SpringBootApplication
public class SpringBootJspApplication extends SpringBootServletInitializer {

    public static void main(String[] args) {
        SpringApplication.run(SpringBootJspApplication.class, args);
    }

    //类似用于web.xml
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(SpringBootJspApplication.class);
    }
}
第四步：修改配置文件

修改SpringBoot配置文件application.properties配置视图解释器前后缀

spring.mvc.view.prefix=/WEB-INF/jsp/
spring.mvc.view.suffix=.jsp
第五步：打包war

使用install命令，打包安装，可以在Tomcat里面运行。
在这里插入图片描述

第六步：运行war包

注意事项： Eclipse可以直接运行入口类执行，IDEA是通过配置Tomcat服务器运行的。SpringBoot2.2.2使用的是Tomcat9

8.Slf4J日志支持

1.Slf4J介绍

Slf4J是一个日志的抽象层框架。它并没有实现日志输出的功能，只是为其他各种日志控件提供统一的入口。这样，只要我们使用Slf4J的规范编写代码，那么适配哪个输出日志框架都可以了。这样可以统一项目的日志框架的标准。在这里插入图片描述

2.SpringBoot对Slf4J的支持

第一步：编写日志代码

–使用Slf4J编写日志输入代码

@RestController
public class HelloController {
    private static  final Logger log= LoggerFactory.getLogger(HelloController.class);
    @GetMapping(value = "/say")
    public String say(){
        log.debug("这是一个HelloWorld程序");
        return "HelloWorld";
    }
}
第二步：配置日志输出级别

配置SpringBoot默认的输出日志框架级别，SpringBoot默认使用logback-classic-1.2.3.jar日志框架

##配置日志登记，标红是自定义包路径
logging.level.org.ranger=debug
第三步：执行程序

执行程序，调用对应的方法，查询输出结果。确认成功。
在这里插入图片描述
注意事项： SpringBoot默认以及加入Slf4J的实现包，所以不需要再导入jar包

9.Lombok框架

1.Lombok介绍

Lombok是一个JavaBean编写的辅助型框架。使用了Lombok，可以让我们IDE编写JavaBean不需要生成Get、Set方法、构造方法、ToString等。使用几个简单的注解就完成对应Get、Set方法生成以及对构造方法、ToString方法、equeal方法的重写。Lombok会根据我们配置的注解自动在内存构建中生成。

工作原理如下：在这里插入图片描述

2.IDEA下使用

第一步：安装Lombok插件
1.安装步骤说明：
  1. 进入到File > Settings > Plugins
  2. 点击 Browse repositories…
  3. 搜索 Lombok Plugin
  4. 点击 Install plugin
  5. 安装成功在这里插入图片描述
  6. 重启开发工具后核对是否安装成功在这里插入图片描述
第二步：编写测试代码

注意：安装插件成功，加入Lombok框架依赖，POJO就不用写get、set方法了。
–POJO

package org.zhu.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
//@Getter
//@Setter
@NoArgsConstructor
@AllArgsConstructor
public class User {
   private int id;
   private String username;
   private String password;

}

–测试代码

package org.zhu.test;

import org.zhu.pojo.User;

public class UserTest {
   public static void main(String[] args) {
      User user=new User();
   
      user.setUsername("zhangsan");
      user.setPassword("123456");
   
      System.out.println("用户名:"+user.getUsername()+",密码:"+user.getPassword());
      System.out.println(user.toString());

   }

}

3.Lombok对Slf4J框架

第一步：配置日志级别

–在applicaiton.properties配置日志级别，注意，标红的包名为我们项目的包名前缀。

##设置日志级别
logging.level.org.zhu=DEBUG
第二步：在类里面使用
package org.zhu.rest.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
import org.zhu.rest.pojo.User;
import java.util.Date;

@RestController
@Slf4j //该注解用于让当前类获得log对象,必须IDE要按安装Lombok插件
public class UserController {
    /**
     * 更新用户
     * @param user
     * @return
     */
    @PutMapping(value = "/edit")
    public User edit(User user){
        log.debug("用户信息"+user.toString());
        user.setPassword("222222");
        user.setCreateDate(new Date());
        return user;
    }
}
第三步：测试确认是否成功

在这里插入图片描述

点点星火
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring Boot全面总结（超详细，建议收藏）
weixin_70730532的博客
07-20 2313
前言：本文非常长，建议先mark后看，也许是最后一次写这么长的文章说明：前面有4个小节关于Spring的基础知识分别是：IOC容器、JavaConfig、事件监听、SpringFactoriesLoader详解它们占据了本文的大部分内容：虽然它们之间可能没有太多的联系，但这些知识对于理解Spring Boot的核心原理至关重要，如果你对Spring框架烂熟于心，完全可以跳过这4个小节。正是因为这个系列的文章是由这些看似不相关的知识点组成，因此取名知识清单。在过去两三年的Spring生态圈，最让人兴奋的莫过于
SpringBoot总结
12-29
SpringBoot是Java开发中的一个热门框架，由Pivotal团队创建，目的是简化Spring应用的初始搭建以及开发过程。它集成了大量常用的Java EE库，如数据访问、安全、消息等，使得开发者可以“零配置”地快速启动项目。本文...
SpringBoot学习总结
05-01
主要为SpringBoot框架内容，包含SpringBoot环境搭建、常用注解、与Mybatis整合创建多数据源的连接+Druid连接池配置、SpringBoot的热部署、SpringBoot整合Freemarker/Servlet组件/文件上传与下载、SpringBoot自定义拦截器以及将拦截器注册到容器中、SpringBoot静态资源加载总结以及统一异常处理方式、SpringBoot自动装配原理。demo可直接运行
Spring Boot 总结
Cristo_Li的博客
06-20 3754
Spring Boot框架详解
springboot总结，源码
11-05
所有springboot的示例，可以学到很多东西的。好好学习
SpringBoot总结升级版
05-01
包含SpringBoot环境搭建、常用注解、与Mybatis整合创建多数据源的连接+Druid连接池配置...SpringBoot静态资源加载总结以及统一异常处理方式、SpringBoot自动装配原理、SpringBoot集成PageHelper实现分页功能(完整demo)...
springboot总结.doc
07-31
SpringBoot 是快速开发框架，而 SpringCloud 是基于 SpringBoot 构建的微服务生态，提供了服务治理、服务注册、服务发现等一系列微服务相关的功能。SpringBoot 可以用于创建单个微服务应用，而 SpringCloud 则帮助...
Spring Boot框架知识总结笔记（超详细，一次性到位）狂神说SpringBoot笔记
热门推荐
博客
03-13 1万+
本篇文章是我基于狂神说Spring Boot课程所做的笔记，内容比较多，包含配置文件解释、Thymeleaf、Shiro、JDBC、Mybatis、Swagger、任务、分布式 Dubbo+Zooker等等，如果能耐心看完，想必会有不少收获。
最棒 Spring Boot 干货总结（超详细，建议收藏）
MrYang_Wei
07-14 816
前言：本文非常长，建议先mark后看，也许是最后一次写这么长的文章 说明：前面有4个小节关于Spring的基础知识 分别是：IOC容器、JavaConfig、事件监听、SpringFactoriesLoader详解 它们占据了本文的大部分内容： 虽然它们之间可能没有太多的联系，但这些知识对于理解Spring Boot的核心原理至关重要，如果你对Spring框架烂熟于心，完全可以跳过这4个小节。正是因为这个系列的文章是由这些看似不相关的知识点组成，因此取名知识清单。 在过去两三年的Spring生态圈
SpringBoot总结（简单）
Wangzc_1116的博客
05-20 250
SpringBoot 简单总结 ： 基础知识1
SpringBoot总结内容
最新发布
m0_74431616的博客
11-09 58
在Spring Boot中，YAML（YAML Ain't Markup Language）是一种用于配置应用程序属性的文件格式。与传统的.properties文件相比，YAML提供了更加简洁和易读的语法结构，使得配置文件更加清晰和可维护。在Spring Boot中，可以使用YAML格式的配置文件（application.yml）来配置应用程序的属性。这些属性可以包括数据库连接信息、服务器端口、日志级别、缓存配置等等。使用YAML格式的配置文件可以使配置更加结构化和易于理解。
Spring Boot框架的总结与介绍
weixin_53227089的博客
06-19 2011
本文介绍了我学习Spring Boot的全过程和总结的笔记，绝无私藏，希望可以帮到大家。
Springboot总结
xiaopang2020的博客
04-04 1865
springboot
springboot全套知识点详细整理
YiGeiGiaoGiao的博客
12-29 1039
springboot
"SpringBoot总结：快速开发微服务架构的基础框架
Spring Boot是一个快速开发框架，可以迅速搭建出一套基于Spring框架体系的应用，是Spring Cloud的基础。与传统的Spring应用相比，Spring Boot开启了各种自动装配，大大简化了代码的开发。它不需要编写各种繁琐的配置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值