SpringBoot快速入门攻略

其他 2021-03-26 08:03:59 阅读次数: 0

SpringBoot的概念：Spring Boot 是所有基于 Spring 开发的项目的起点。Spring Boot 基于“习惯优于配置”的设计理念，让你尽可能快的跑起来 Spring 应用程序并且尽可能减少你的配置文件。它并不是什么新的框架，而是默认配置了很多框架的使用方式，就像 Maven 整合了所有的 jar 包一样，Spring Boot 整合了所有框架。

 

一、SpringBoot的概述

1、原有Spring框架的优缺点

1.1、 Spring的优点分析

Spring是Java企业版（Java Enterprise Edition，JEE，也称J2EE）的轻量级代替品。无需开发重量级的Enterprise JavaBean（EJB），Spring为企业级Java开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单的Java对象（Plain Old Java Object，POJO）实现了EJB的功能。

1.2 、Spring的缺点分析

虽然Spring的组件代码是轻量级的，但它的配置却是重量级的。一开始，Spring用XML配置，而且是很多XML配置。Spring 2.5引入了基于注解的组件扫描，这消除了大量针对应用程序自身组件的显式XML配置。Spring 3.0引入了基于Java的配置，这是一种类型安全的可重构配置方式，可以代替XML。

所有这些配置都代表了开发时的损耗。因为在思考Spring特性配置和解决业务问题之间需要进行思维切换，所以编写配置挤占了编写应用程序逻辑的时间。和所有框架一样，Spring实用，但与此同时它要求的回报也不少。

除此之外，项目的依赖管理也是一件耗时耗力的事情。在环境搭建时，需要分析要导入哪些库的坐标，而且还需要分析导入与之有依赖关系的其他库的坐标，一旦选错了依赖的版本，随之而来的不兼容问题就会严重阻碍项目的开发进度。

2、 SpringBoot解决上述Spring的缺点

SpringBoot对上述Spring的缺点进行的改善和优化，基于约定优于配置的思想，可以让开发人员不必在配置与逻辑业务之间进行思维的切换，全身心的投入到逻辑业务的代码编写中，从而大大提高了开发的效率，一定程度上缩短了项目周期。

SpringBoot的特点:

  • 为基于Spring的开发提供更快的入门体验

  • 开箱即用，没有代码生成，也无需XML配置。同时也可以修改默认值来满足特定的需求

  • 提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等

  • SpringBoot不是对Spring功能上的增强，而是提供了一种快速使用Spring的方式

3 、SpringBoot的核心功能

  • 起步依赖

spring-boot-starter-xxx就是SpringBoot的起步依赖。SpringBoot通过提供众多起步依赖降低项目依赖的复杂度。起步依赖本质上是一个Maven项目对象模型，定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。很多起步依赖的命名都暗示了他们提供的某种或某类功能。

  简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。

  • 自动配置

  Spring Boot的自动配置是一个运行时（更准确地说，是应用程序启动时）的过程，考虑了众多因素，才决定Spring配置应该用哪个，不该用哪个。该过程是Spring自动完成的。

4、使用 Spring Boot 有什么好处

回顾我们之前的 SSM 项目，搭建过程还是比较繁琐的，需要各种复杂配置：

  • 1）配置 web.xml，加载 spring 和 spring mvc的配置文件的位置，定义DispatcherServlet

  • 2）配置SpringMVC、Spring和Mybatis的配置文件：spring-mvc.xml、spring-mybatis.xml

  • 3）配置数据库连接、配置日志文件

  • 4）配置mapper文件

  • .....

而SpringBoot基于“习惯优于配置”的设计理念,默认配置了很多框架的使用方式。所以我们使用 Spring Boot 来开发项目则只需要一个利用 IDEA 自动生成的application.properties配置文件，然后在里面添加非常少的几个配置项就可以搭建起来一个 Web 项目，这简直是太爽了...

SpringBoot划重点：简单、快速、方便地搭建Spring项目；对主流开发框架的无配置集成；极大提高了开发、部署效率。

二、Spring Boot 项目快速搭建

SpringBoot版本：2.2.0.RELEASE

第一步：新建项目

选择 Spring Initializr ，然后选择默认的 url 点击【Next】：

然后修改一下项目的信息：

勾选上 Web 模板：

选择好项目的位置，点击【Finish】：

如果是第一次创建Spring Boot 项目的话可能需要等待一会儿 IDEA 下载相应的依赖包，默认创建好的项目结构如下：

项目结构还是看上去挺清爽的，少了很多配置文件，我们来了解一下默认生成的有什么：

  • SpringbootdemoApplication： 一个带有 main() 方法的类，用于启动SpringBoot应用程序

  • application.properties：一个空的 properties 文件，可以根据需要添加配置属性

  • pom.xml： Maven 构建说明文件

第二步：编写HelloController

在【com.hs.springbootdemo.controller】包下新建一个【HelloController】

package com.hs.springbootdemo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;


@RestController//该注解是 @Controller 和 @ResponseBody 注解的合体版
public class HelloController {

    @RequestMapping(value = "/hello")
    public String hello()
    {
        return "Hello Spring Boot!";
    }

    @RequestMapping(value="/json",produces={"application/json; charset=UTF-8"})
    public Map jsonTest()
    {
        Map< String , Object > jsonMap = new HashMap< String , Object>();
        jsonMap.put("a",1);
        jsonMap.put("b","");
        jsonMap.put("c",null);
        jsonMap.put("d","hs");

        return jsonMap;
    }
}

第三步：利用 IDEA 启动 Spring Boot

我们回到 SpringbootdemoApplication 这个类中，然后右键点击运行：

注意：我们之所以在上面的项目中没有手动的去配置 Tomcat 服务器，是因为 Spring Boot 内置了 Tomcat

等待一会儿就会看到下方的成功运行的提示信息：

可以看到我们的 Tomcat 运行在 8080 端口，我们来访问 “/hello” 地址试一下：

可以看到页面成功显示出我们返回的信息。除了写一个HelloController类以外，什么配置文件（比如web.xml、spring-mvc.xml）也没写就能Spring快速运行起来。

三、SpringBoot配置文件和应用入口类的解析

1、解析 pom.xml 文件

让我们来看看默认生成的 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>com.hs</groupId>
    <artifactId>springbootdemo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>springboot</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

     <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <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>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

我们可以看到一个比较陌生一些的标签 <parent> ，这个标签是在配置 Spring Boot 的父级依赖：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.1.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

有了这个，当前的项目才是 Spring Boot 项目，spring-boot-starter-parent 是一个特殊的 starter ，它用来提供相关的 Maven 默认依赖，使用它之后，常用的包依赖就可以省去 version 标签。

关于具体 Spring Boot 提供了哪些 jar 包的依赖，我们可以查看本地 Maven 仓库下：\repository\org\springframework\boot\spring-boot-dependencies\2.0.1.RELEASE\spring-boot-dependencies-2.0.1.RELEASE.pom 文件来查看，挺长的...

另外还添加两个起步依赖spring-boot-starter-web和spring-boot-starter-test，分别用于支持SpringMVC和Tomcat，还有Junit单元测试。

2、应用入口类SpringbootdemoApplication.java

Spring Boot 项目通常有一个名为 *Application 的入口类，入口类里有一个 main 方法， 这个 main 方法其实就是一个标准的 Java 应用的入口方法。

package com.hs.springbootdemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringbootdemoApplication {

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

@SpringBootApplication 是 Spring Boot 项目的核心注解，主要目的是开启自动配置。

它是一个组合注解，该注解组合了：@Configuration、@EnableAutoConfiguration、@ComponentScan； 若不是用 @SpringBootApplication 注解也可以使用这三个注解代替。

  • 从Spring3.0，@Configuration用于声明当前类是个配置类,相当于一个Spring配置的xml文件。被注解的类内部包含有一个或多个被@Bean注解的方法，声明当前方法的返回值为一个Bean。AnnotationConfigApplicationContext或 AnnotationConfigWebApplicationContext类会进行扫描，用于构建bean定义，初始 化Spring容器。

  • 其中，@EnableAutoConfiguration 让 Spring Boot 根据类路径中的 jar 包依赖为当前项目进行自动配置，例如，添加了 spring-boot-starter-web 依赖，会自动添加 Tomcat 和 Spring MVC 的依赖，那么 Spring Boot 会对 Tomcat 和 Spring MVC 进行自动配置。（这也是我们上面为啥不用配置spring-mvc.xml的原因，因为已经SpringBoot已经帮我们自动配置好了）

  • @ComponentScan (cn.test.demo): 自动扫描包名下所有使用 @Component @Service  @Repository @Controller 的类,并注册为Bean。于是 Spring Boot 还会自动扫描 @SpringBootApplication 所在类的同级包以及下级包里的 Bean ，所以入口类建议就配置在grounpID + arctifactID 组合的包名下（这里为 com.hs.springboot demo包）

3、Spring Boot 的配置文件application.properties

  • Spring Boot 使用一个全局的配置文件 application.properties 或 application.yml，放置在【src/main/resources】目录或者类路径的 /config 下。

  • Spring Boot 不仅支持常规的 properties 配置文件，还支持 yaml 语言的配置文件。yaml 是以数据为中心的语言，在配置数据的时候具有面向对象的特征。

  • Spring Boot 的全局配置文件的作用是对一些默认配置的配置值进行修改。

我们同样的将 Tomcat 默认端口设置为 8080 ，并将默认的访问路径从 “/” 修改为 “/hello” 时，使用 properties 文件和 yml 文件的区别如下图。

注意： yml 需要在 “:” 后加一个空格，幸好 IDEA 很好地支持了 yml 文件的格式有良好的代码提示。

可以看出yaml语言的配置文件描述语义更简单且更直观，所以我们直接把 .properties 后缀的文件删掉，使用 .yml 文件来进行简单的配置。

四、Spring Boot 使用

上面已经完成了 Spring Boot 项目的简单搭建，我们仅仅需要进行一些简单的配置甚至上面Demo根本没有添加配置，写一个 HelloController 就能够直接运行了，不要太简单...接下来我们再深入了解一下 Spring Boot 的使用。

1、Spring Boot 支持 JSP

在我们使用SpringBoot来搭建项目时，会发现它不支持JSP。Spring Boot 的默认视图支持是 Thymeleaf 模板引擎，但是这个我们不熟悉啊，我们还是想要使用 JSP 怎么办呢？

第一步：修改 pom.xml 增加对 JSP 文件的支持

   <!--1、SpringBoot默认不支持JSP，需要在项目中添加相关的依赖-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <scope>provided</scope>
        </dependency>
        <!--JavaServer Pages Standard Tag Library，JSP标准标签库-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
        </dependency>
        <!--内置tomcat对Jsp支持的依赖，用于编译Jsp-->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
            <scope>provided</scope>
        </dependency>

第二步：配置视图解析器 JSP 文件的位置

修改 application.properties 文件，将我们的 JSP 文件重定向到 /WEB-INF/views/ 目录下：

#让springmvc支持jsp视图的跳转目录指向为/WEB-INF/views/
spring.mvc.view.prefix=/WEB-INF/views/
spring.mvc.view.suffix=.jsp

第三步：创建JspController

修改 @RestController 注解为 @Controller ，也就是不使用@ResposeBody注解走视图解析器流程，然后将 hello 方法修改为：

package com.hs.springbootdemo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class JspController {

    @RequestMapping("/jsp")
    public String hello(Model model)
    {
        model.addAttribute("message","Hi,jsp!");
        return "hello";
    }
}

第四步：新建 hello.jsp 文件


<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<body>

<h2>${message}</h2>

</body>
</html>

第五步：运行应用入口类SpringbootdemoApplication.java

2、SpringBoot集成 MyBatis

第一步：修改 pom.xml 增加对 MySql和 MyBatis 的支持

    <!-- mybatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.1.1</version>
        </dependency>
        <!-- mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.33</version>
        </dependency>

第二步：application.properties 文件新增数据库链接参数

这里我们就直接使用之前创建好的user 表如下：

#DB Configuration:
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/mengtu?useUnicode=true&characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password= your password

第三步：创建 User实体类和 UserMapper 映射类

在【com.hs.springbootdemo.dao】下新建一个【entity】包，然后在其下创建一个UserEntity 类：

package com.hs.springbootdemo.dao.entity;

/**
*   用户实体类
 */

public class UserEntity {

    //属性名必须与数据库表的字段名一致，以便Mybatis直接把实体类映射成数据库记录
    private Integer uid; //用户id
    private String username;//用户名
    private String password;//用户密码

    public Integer getUid() {
        return uid;
    }

    public void setId(Integer uid) {
        this.uid = uid;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

在【com.hs.springbootdemo.dao】下新建一个新建【mapper】包，然后在其下创建一个UserMapper 映射类：

package com.hs.springbootdemo.dao.mapper;

import com.hs.springbootdemo.dao.entity.UserEntity;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.util.List;

/**
 * Spring通过@Mapper注解实现动态代理，mybatis会自动创建Dao接口的实现类代理对象注入IOC容器进行管理，这样就不用编写Dao层的实现类
 *
 */

@Mapper
public interface UserMapper {

    @Select("SELECT * FROM user")  //使用@Select、@Insert等注解方式来实现对应的持久化操作，使得我们可以不配置XML格式的Mapper文件
    List<UserEntity> findAll();
}

第四步：编写 UserController

package com.hs.springbootdemo.controller;

import com.hs.springbootdemo.dao.entity.UserEntity;
import com.hs.springbootdemo.dao.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;

@Controller
public class UserController
{
    @Autowired
    UserMapper userMapper;

    @RequestMapping("/listUser")
    public String listStudent(Model model) {
            List<UserEntity> users = userMapper.findAll();
            model.addAttribute("users", users);
            return "listUser";
    }

}

第五步：新建 listStudent.jsp 文件

<%@ page language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8"%>

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>

<table align='center' border='1' cellspacing='0'>
    <tr>
        <th>uid</th>
        <th>name</th>
        <th>password</th>
    </tr>

    <c:forEach items="${users}" var="s" varStatus="st">
        <tr>
            <td>${s.uid}</td>
            <td>${s.username}</td>
            <td>${s.password}</td>
        </tr>
    </c:forEach>
</table>

第六步：重启服务器运行

浏览器地址栏输入：localhost:8080/listStudent 查看效果：

3、SpringBoot使用Juint

a、pom.xml

一般使用idea新建一个SpringBoot web项目时，pom.xml里面一般都会自动引入此起步依赖，可以不用管

  <dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-test</artifactId>
        <!--声明只能在test测试路径包里用，如果要在main包下用那么可以注释掉-->
	<scope>test</scope>
  </dependency>

b、待测试的Dao层UserMapper类里面使用快捷键CTRL+SHIFT+T快速创建测试类，并修改代码如下：

package com.hs.springbootdemo.dao.mapper;

import com.hs.springbootdemo.SpringbootdemoApplication;
import com.hs.springbootdemo.dao.entity.UserEntity;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.context.web.WebAppConfiguration;

import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringbootdemoApplication.class)
public class UserMapperTest
{

    @Autowired
    private UserMapper userMapper;

   //SpringBoot内部集成了LogBack日志依赖，SpringBoot默认使用LogBack记录日志信息
    private Logger logger = LoggerFactory.getLogger(UserMapperTest.class);
  
    @Test
    public void test() {
        List<UserEntity> users = userMapper.findAll();
        logger.warn(users.toString());
    }

}

  •     Test注解有两个包,这里应该要导入的是org.junit.Test包。别导错了，不然会报Java.lang.Exception: No runnable methods

  •     SpringBoot内部集成了LogBack日志依赖，SpringBoot默认使用LogBack记录日志信息。

运行结果：

c、建立一个已经添加三个注解的基础JunitTestParent类

由于一个项目中我们会写很多很多测试类，而测试类上面是需要以下几个注解的，每建一个类都去补注解，太麻烦，我们就在这个类中加上注解，其他测试类直接继承这个类就好了：

package com.alibaba;
 
import org.junit.After;
import org.junit.Before;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.context.web.WebAppConfiguration;
 
@RunWith(SpringRunner.class)
@SpringBootTest
@WebAppConfiguration

public class JuntitTestParent
{
 
    @Before
    public void init() {
        System.out.println("开始测试-----------------");
    }
 
    @After
    public void after() {
        System.out.println("测试结束-----------------");
    }
}

4、SpringBoot使用Logback日志系统工具

SpringBoot内部集成了LogBack日志依赖，SpringBoot默认使用LogBack记录日志信息。logback是Java的日志开源组件，是log4j创始人写的，性能比log4j要好.

既然SpringBoot默认使用性能更好的logback,那么我们就用它吧，同一个创始人写的，那么用法也相差无几：

实际开发中我们不需要往pom.xml里添加该依赖，你会发现spring-boot-starter其中包含了 spring-boot-starter-logging，Spring Boot为我们提供了很多默认的日志配置，所以，只要将spring-boot-starter-logging作为依赖加入到当前应用的classpath，则“开箱即用”。

a、写一个测试logback的Controller

package com.hs.springbootdemo.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class LogBackTestController
{
    // logback是通过LoggerFactory.getLogger()实例化对象，而Log4j是通过Logger.getLogger()实例化对象
    private final static Logger logger = LoggerFactory.getLogger(LogBackTestController.class);

    /**
     * 测试logback日志系统
     * @return
     */
    @RequestMapping("/logbackTest")
    public String logback()
    {
        logger.debug("记录debug日志");
        logger.info("访问了index方法");
        logger.error("记录了error错误日志");
        return "index";
    }
}

我们访问地址后，控制台就对应的输出了info级别的测试日志内容了，上面我们说了这是logback的默认配置base.xml搞的鬼，那么我们该如何修改默认配置呢？

b、修改LogBack配置

LogBack读取配置文件的步骤
（1）尝试classpath下查找文件logback-test.xml
（2）如果文件不存在，尝试查找logback.xml
（3）如果两个文件都不存在，LogBack用BasicConfiguration自动对自己进行最小化配置，这样既实现了上面我们不需要添加任何配置就可以输出到控制台日志信息。

resources目录下新建logback.xml：

<?xml version="1.0" encoding="UTF-8"?>

<!--logback配置文件：当debug属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。-->
<configuration debug="false">

    <!--定义日志文件的存储地址 勿在 LogBack 的配置中使用相对路径-->
    <property name="LOG_HOME" value="./logs" />

    <!-- 控制台输出 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度,%msg：日志消息，%n是换行符-->
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg  %n</pattern>
        </encoder>
    </appender>

    <!-- 按照每天生成日志文件 -->
    <appender name="FILE"  class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!--日志文件输出的文件名-->
            <FileNamePattern>${LOG_HOME}/runtime.log.%d{yyyy-MM-dd}.log</FileNamePattern>
            <!--日志文件保留天数-->
            <MaxHistory>30</MaxHistory>
        </rollingPolicy>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </encoder>
        <!--日志文件最大的大小-->
        <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
            <MaxFileSize>10MB</MaxFileSize>
        </triggeringPolicy>
    </appender>

    <!-- 日志输出级别 -->
    <root level="INFO">
        <appender-ref ref="STDOUT" />
        <appender-ref ref="FILE" />
    </root>

</configuration>

logback.xml配置文件配置了根输出等级是INFO，所以如果logback.xml生效，那么控制台以及文件内将不会存在Debug级别的日志输出。只会输出INFO以上级别(包括本身)的日志信息，而且会把ERROR基本的日志信息写到项目根目录下的logs文件中，每天都会生成日志文件，文件保留有效期为30天。

c、重启下项目，访问之前的地址/logbackTest

查看控制台以及/logs/runtime.xxxx.log配置文件内容,如下图：

可以看到Debug级别的日志没有输出，只有INFO以及ERROR级别日志打印并输出到文件中。配置的./logs作为日志的输出根目录，所以LogBack自动在项目根目录下创建名叫做logs的文件夹，并且项目启动时第一次记录日志时会自动创建根据我们的命名方式的文件。

d、如果我们在项目中需要屏蔽某个或者多个包下不输出日志也不记录日志到文件内

在logback.xml中加上该配置，包名如：com.xxx

<logger name="packageName" level="OFF"> </logger>

e、SpringBoot中如何使用Log4j

如果非要在SpringBoot中使用前面我们所学的Lo4j，那么就得修改pom.xml，移除Spring Boot中默认的logback依赖。添加log4j依赖，然后配置log4j.properties属性文件，最后在代码中使用即可.......SpringBoot中使用Log4j

<!-- 移除logback依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.2.0.RELEASE</version>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>

然后不熟悉Log4j的可以看看我的另外一篇博客：Log4j日志系统工具使用总结

非常感谢简书博主@我没有三颗心脏 的Spring系列教程，受益匪浅,致以崇高敬意:Spring Boot【快速入门】

参考链接：

SpringBoot教程

Spring @Configuration 注解介绍

SpringBoot使用LogBack日志组件

猜你喜欢

转载自blog.csdn.net/CSDN2497242041/article/details/102645576
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
让自己的头脑极度开放
CentOS 6.5(x64) 和Redhat6.5操作系误删libc
高可用注册中心
【日记】12.28/【题解】AtCoder AGC041
XML（5）_XML 约束_DTD
Java集合Map（四）
树梅派安装桌面环境教程
pipenv 的 使用和安装
小程序白屏问题和内存研究
C语言简单选择排序
每日归档
更多
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022