SpringBoot 基础

最新推荐文章于 2024-06-08 14:56:49 发布
最新推荐文章于 2024-06-08 14:56:49 发布
阅读量488 收藏
点赞数 1
文章标签： spring boot intellij-idea java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/whowho_s/article/details/122682801
版权

1、初始 Spring Boot

1、Spring Boot 的优点

  • 简化配置
    • 减少配置
    • 优化配置 — 在 Spring Boot 项目中没有任何 XML 配置，大部分的配置信息都可以写入 一个单独的配置文件
      • 配置信息更加集中，方便了对配置信息的管理
      • 编写方便，可以使用代码提示的方式进行配置进行的编写
  • 简化部署
    • Spring Boot 有内置的 Web 容器。
  • 简化监测
  • 与主流框架的无缝集成

2、使用 Spring Boot 搭建一个 Web 项目

  1. 新建 Spring Boot 项目、

    1. 启动开发工具 IDEA，先创建 project，命名为 “ Spring Boot ”，然后创建 Module，依次单击菜单栏中 “File - New - Module”

    2. 在这里插入图片描述

    3. 在创建 Module 的窗口中，选择左侧菜单中的 “Spring Initializr”，选择Module SDK 为 JDK 1.8

    4. 在这里插入图片描述

    5. 傻瓜式操作，next

  2. 编写 Java 代码

    1. 创建一个 controller 包，里面创建一个控制器

    2. @Controller
public class HelloController {

    @RequestMapping(value = "/login", method = RequestMethod.GET)
    public String index(Map<String , Object> map){
        map.put("name", "Steven");
        return "index";
    }
}

  3. 启动并测试
    2. 在这里插入图片描述

    1. 在这里插入图片描述

    2. 打开网页

3、三个核心文件

  1. pom 文件

    1. <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.5.4</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <artifactId>spring-boot-starter-web</artifactId>
    <groupId>org.springframework.boot</groupId>
</dependency>
      1. 父依赖 spring-boot-starter-parent
        1. 限定 Java 的版本：Spring Boot xxx 版本所依赖的 JDK 版本为xx 以上
        2. 限定源码的文件编码方式，默认为 UTF-8
        3. 管理依赖：在父依赖中设置了一些公共依赖的版本号
        4. 打包支持：设置一些使用 Maven 对项目进行打包的规则
        5. 动态识别资源：可以识别一些特定名称的资源文件，比如 application.yml 文件
        6. 识别插件配置：比如 exec plugin、Git commit ID、shade 等
      2. 依赖 spring-boot-starter-web
      3. 依赖 spring-boot-starter-test

  2. 启动类

    1. main() 方法 ---- 作用就是启动项目
    2. @SpringBootApplication 注解 ---- 是一个组合注解，它是由多个注解组合而成的注解
      1. 介绍3个注解
        1. @SpringBootConfiguration：可替换 Spring 的 applicationContext.xml 配置文件，被注解的类内部可以包含有一个或第一个被 @Bean 注解标注的方法，这些方法会被 Spring 的系统类扫描，并用于构建 Bean 定义，初始化 Spring 容器
        2. @EnableAutoConfiguration：可以启动 Spring Boot 的自动配置
        3. @ComponentScan：扫描启动同目录及子目录下的所有注解，是这些注解生效

  3. application.properties 文件

    1. 关于 Spring Boot 项目的大部分配置信息可以在此文件中进行编写，是 Spring Boot 项目的配置文件

4、application.properties 文件

#启动的端口号
server.port=8080
#配置项目的访问根路径
server.servlet.context-path=/firstsb/
#配置日志的输出路径
logging.path=D:\\logs
#配置日志的输出格式
logging.pattern.file=%d-%msg%n
#也可以只写文件名或写相对路径。当只写文件名时，系统会以当前项目所在的盘符根路径作为起始目录，创建同名日志文件。
#写相对路径时，系统会以当前项目所在的盘符根路径作为起始目录，创建指定目录下的日志文件。

还可以使用application.yml 文件

server:
  port: 8080
  servlet:
    context-path: /firstsb/
logging:
  path: D:\\loogs
  pattern:
    file: %d-%msg-%n

在 YAML 文件编写配置信息需要注意以下几点

  • 大小写敏感
  • 缩进时不能使用 Tab 键，只允许使用空格
  • 属性值和属性名之间要有空格隔开

5、Spring Boot 项目启动方式

支持3中内置容器：Tomcat、Jett、Undertow，默认的内置 Web 容器是 Tomcat

修改容器的步骤：

  1. 修改 pom.xml 文件

    1. <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>

  2. 添加与 Web 容器 Jetty 相关的依赖

    1. <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

  3. 启动项目查看启动日志
    在这里插入图片描述

1、Spring Boot 项目还有其他多种启动方式

  1. 本地 Web 容器中启动

  2. 使用 Maven 启动项目，如果想停止项目，可以使用 Ctrl + C 快捷键
    2. 在这里插入图片描述

  3. 使用 Java 命令启动项目

    1. 在当前目录下输入命令 java -jar xxxx.jar，即可启动项目，如果想停止项目，可以使用 Ctrl + C 快捷键

6、多模块项目

在企业级开发中，代码量大，项目庞大，即使使用三层架构的方式，搭建出来的项目也是比较复杂的，主要存在以下问题

  1. 结构不够清晰，开发人员不能从庞大的项目中快速定位自己负责的模块
  2. 项目庞大导致启动费时
  3. 部署时，无法分模块扩展项目，造成资源的浪费

为了解决这些问题，Maven 提出了一套多模块项目的方案。

步骤

  1. 创建 Maven 父模块 — 可以把 src 目录删除
  2. 创建子模块
    1. beans ：存放实体类
    2. common：存放工具类，枚举类等项目中的核心类
    3. dao：存放数据访问层代码
    4. service：存放业务层代码
    5. controller：存放控制器层代码
  3. 配置模块之间的依赖

在多模块项目中，子模块继承父项目，所以可以在父项目中统一管理通用的依赖

那怎么管理依赖的版本号？

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>
</dependencyManagement>

使用聚合时，父项目的 pom 文件中 packaging 都是 pom

2、Spring Boot 实战技能

1、整合 JUnit 测试

代码测试是开发工作中一个非常重要的环节

实现步骤：

  1. 使用 IDEA 创建 Spring Boot 项目
  2. 创建工具类实现两个数相加
  3. 创建测试类并编写测试方法
  4. 为测试类添加 @RunWith 和 @SpringBootTest 注解
    1. @RunWith：使 @SpringBootTest 注解生效
    2. @SpringBootTest：创建 Spring 的 ApplicationContext，并将注入到测试类中
  5. 运行 测试类的方法对工具类进行测试

2、读取配置文件

可以通过 @PropertySource 和 @Value 注解实现该功能

实现步骤

  1. 创建 Spring Boot 项目
  2. 编写实体类 User，并为 User 类创建两个属性 userName 和 password
  3. 在 application.yml 文件中指定 userName 和 password 的值
  4. 通过 @Value 注解将 userName 和 password 的值注入给 User 实体类的对象
  5. 测试

User 实体类

@Component 
public class User {
    @Value("${user.userName}") 
    private String userName;
    @Value("${user.password}") 
    private String password;

    @Override
    public String toString() {
        return "User{" +
                "userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                '}';
    } 
}

application.yml 配置文件

user:
  userName: zhangsan
  password: 123456

在真实的企业项目开发中，项目所需的配置的信息往往较多，开发者需要不断使用 @Value 注解读取配置，这就造成使用 @Value 注解读取配置文件有诸多不便。

另一种读取配置文件的方式----使用注解 @ConfigurationProperties

主要注意：

  1. 指定 prefix：由于实际开发中要读取的属性很多，不同实体类之间经常会存在属性相同的情况，所以在 application.yml 文件中配置属性时，需要添加前缀来标识对应的实体类，避免属性同名的问题
  2. 创建 setter 方法：@ConfigurationProperties 注解实际上通过属性的 setter 方法来进行注入

通过 @ConfigurationProperties 注解将 application.yml 文件中的属性值注入到 Java 实体类对应的属性

实现步骤

  1. 创建 Spring Boot 项目
  2. 编写实体类 User，并为 User 类创建两个属性 userName 和 password
  3. 在 application.yml 文件中指定 userName 和 password 的值
  4. 通过 @ConfigurationProperties 注解将 userName 和 password 的值注入给 User 实体类的对象。
  5. 测试

User 实体类

@Component
@ConfigurationProperties(prefix = "user")
public class User { 
    private String userName; 
    private String password;

    @Override
    public String toString() {
        return "User{" +
                "userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

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

application.yml 配置文件

user:
  userName: zhangsna 
  password: 123456

3、多环境配置

在实际的项目开发中，往往会有多套运行环境，比如开发环境、测试环境和生成环境。

实现多环境配置有 properties 文件和 yml 文件两种方式

  1. 使用 properties 文件

    1. 使用 properties 文件实现多环境配置时，每个环境都需要有单独的 properties 文件。

    2. 注意点：

      1. 文件的命名方式，必须为 “application-环境名称.properties” 的形式，环境名称由开发者自行指定
      2. 由于两个配置文件只能有一个生效，所以需要指定当前环境启用的是哪个配置文件。
      3. 在 application.properties 文件中使用 spring.profiles.active 来进行此项配置
      4. 该属性的值须指定为配置文件名称 “application-环境名称.properties” 中的环境名称

  2. 使用 YAML 文件

    1. 使用 YAML 文件实现多环境配置只需要一个配置文件即可。所有的配置信息均可以放置在 application.yml 文件中

    2. 两套配置信息之间用 “—” 隔开，并通过 spring.profiles.active 配置了当前启用的 环境

    3. spring:
  profiles:
    active: dev
---
spring:
  profiles: dev
  autoconfigure:
    exclude: org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
  mvc:
    view:
      prefix: /WEB-INF/jsp/
      suffix: .jsp
server:
  port: 8011
logging:
  config: classpath:logback-spring.xml
---
spring:
  profiles: test
server:
  port: 8082

4、Spring Boot 的自动配置

使用 Spring Boot 开发项目时，很多配置都是 Spring Boot 默认配置好的，然而在真实的项目开发中，项目需求是灵活多变的，为了实现某些需求，经常需要去调整这些默认配置。

当 Spring Boot 项目中引入了 spring-boot-starter-web 和 spring-boot-starter-test 这两个依赖之后，会在项目中添加两个与自动配置相关的 jar 包。展开这两个 Jar 包，会发现这个两个 Jar 下面都包含名为 “spring.factories” 的文件
在这里插入图片描述

打开 spring.factories 文件，会看到很多自动配置的类
在这里插入图片描述

4.1、自动配置类就是 Spring Boot 项目会自动配置的类

那么这些类是怎么被 Spring Boot 读取到的呢？

Spring Boot 项目的启动类上需要添加 @SpringBootApplication 注解，是复合注解，由多个注解组合而成，其中包含一个 @EnableAutoConfiguration 的注解

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    Class<?>[] exclude() default {};

    String[] excludeName() default {};
}
  1. 在@EnableAutoConfiguration 源码中通过 @Import 注解引入了 AutoConfigurationImportSelector 类。
  2. 在 AutoConfigurationImportSelector 类中，通过分析可以发现程序会去所有的自动配置包中查找 spring.factories 文件
  3. 从 spring.factories 文件中加载所有的自动配置类
@Configuration 
@ConditionalOnClass({DataSource.class, EmbeddedDatabaseType.class})
@EnableConfigurationProperties({DataSourceProperties.class})
@Import({DataSourcePoolMetadataProvidersConfiguration.class, InitializationSpecificCredentialsDataSourceInitializationConfiguration.class, SharedCredentialsDataSourceInitializationConfiguration.class})
public class DataSourceAutoConfiguration {
    public DataSourceAutoConfiguration() {
    }
    …………
4.2、DataSourceAutoConfiguration 类上添加了4个注解：
  1. @Configuration ：让一个类变成一个配置类，拥有与 Spring 的配置文件相同的功能
  2. @ConditionalOnClass ： 条件注解，是 @Conditional 的扩展注解。可以判断当某些类存在时进行后续代码的操作
  3. @EnableConfigurationProperties ： 为某个类中的属性赋值
  4. @Import ：将某个类的实例引入 Spring 的 IoC 容器。
@Conditional 的扩展注解作用
@ConditionalOnClass某个class位于类路径上，才会实例化一个Bean。
@ConditionalOnMissingClass某个class类路径上不存在的时候，才会实例化一个Bean。
@ConditionalOnBean当容器中有指定Bean的条件下进行实例化。
@ConditionalOnMissingBean当容器里没有指定Bean的条件下进行实例化。
@ConditionalOnProperty当指定的属性有指定的值时进行实例化。
@ConditionalOnResource当类路径下有指定的资源时触发实例化。
@ConditionalOnNotWebApplication不是web应用，才会实例化一个Bean。
@ConditionalOnWebApplication当项目是一个Web项目时进行实例化。
@ConditionalOnExpression基于SpEL表达式的条件判断，当表达式为true的时候，才会实例化一个Bean。
@ConditionalOnJava当JVM版本为指定的版本范围时触发实例化。
@ConditionalOnJndi在JNDI存在的条件下触发实例化。
@ConditionalOnSingleCandidate当指定的Bean在容器中只有一个，或者有多个但是指定了首选的Bean时触发实例化。

理解：

  • 当项目中没有添加 spring-boot-starter-jdbc 依赖时，项目中只有 DataSource.class，没有 EmbeddedDatabaseType.class
  • 所以此时不满足执行 @EnableConfigurationProperties 的操作条件。
  • 反之当项目中引入 spring-boot-starter-jdbc 依赖之后，由于此依赖中包含 EmbeddedDatabaseType.class，满足 @EnableConfigurationProperties 的操作条件，项目则执行 @EnableConfigurationProperties 注解的操作
  • 就是给 DataSourceProperties 的属性进行赋值
  • 在 DataSourceProperties 类的源码中可以发现其包含 url 属性。
  • 由于并没有给 url 属性设置默认值，所以此时项目会去 application.yml 文件中寻找此属性的值。
4.3、关闭 Spring Boot 的自动配置有两种方式

  1. 注解的方式：比如要关闭 DataSourceAutoConfiguration 自动配置，可以在启动类的 @SpringBootApplication 注解上通过配置 exclude 属性来进行指定。如果需要关闭多个类的自动配置，可以在大括号中写多个类，并用逗号隔开。

    1. @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})

  2. 配置文件的方式：开发者也可以在配置文件中关闭自动配置

    1. spring: 
  autoconfigure:
    exclude: org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration

5、Spring Boot 整合 JSP

在 Web 开发中，前端数据展示是项目的重要组成部分。JSP 技术是常用的数据展示的模板引擎技术之一。

Spring Boot 默认支持的模板引擎有4种，分别为

  • FreeMarker
  • Groovy
  • Thymeleaf
  • Mustache

默认并不支持 JSP 模板引擎，但可以通过引入相关依赖来整合 JSP 模板引擎

具体的接入步骤：

  1. 添加依赖

    1. <dependency>
    <artifactId>javax.servlet-api</artifactId>
    <groupId>javax.servlet</groupId>
    <scope>provided</scope>
</dependency>
<dependency>
    <artifactId>jstl</artifactId>
    <groupId>jstl</groupId>
</dependency>
<!-- tomcat 支持-->
<dependency>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <groupId>org.springframework.boot</groupId>
</dependency>
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
</dependency>

    2. 配置视图解析器：在 application.yml 文件中添加

      1. spring:
  mvc:
    view:
      prefix: /WEB-INF/jsp/
      suffix: .jsp

    3. 编写控制器：在 Controller 类中

      1. @Controller
public class HelloController {
    @RequestMapping(value = "/login", method = RequestMethod.GET)
    public String index(Map<String , Object> map){
        map.put("name", "Steven");
        return "index";
    }
}

    4. 编写 JSP 页面，在项目 src/main 目录中添加 webapp/WEB-INF/jsp 目录，并在此目录下创建 index.jsp

      1. <body>
    Message: ${name}
</body>

    5. 启动项目测试

6、使用 XML 的配置

XML 配置是一种主流的配置方式，在 Spring Boot 项目中，可以使用 @ImportResource 注解读取 XML 配置文件

步骤：

  1. 将 @ImportResource 注解标注到启动类上，或者某个配置类
  2. 指定要引入的 XML 配置文件的位置。如：在资源目录下存在 applicationContext.xml 配置文件则可以通过 @ImportResource(value=“classpath:applicationContext.xml”) 读取
    1. 语法： @ImportResource(value=“配置文件的位置”)

7、LogBack 日志

日志是项目运行的监控和故障排查手段。在开发和调试阶段，日志可以帮助开发者更高效、便捷地定位问题。

在 Java 开发领域，常用的日志记录框架主要有三种：

  1. Log4j
  2. Log4j2
  3. LogBack
    1. 在性能上比 Log4j 更加高效。Spring Boot 官方把 LogBack 作为日志记录框架的首选。

Log4j2 和 LogBack 都是 Log4j 的升级版。

7.1、LogBack 日志配置

默认情况下，使用 IDEA 创建基于 Spring Boot 的 Web 项目时，默认集成了 LogBack。
在这里插入图片描述

分析输出的日志内容：

  • 日志时间：精确到毫秒
  • 日志级别：共有6种日志级别，日志级别从低到高依次为TRACE<DEBUG<INFO<WARN<ERROR<FATAL。默认为INFO
  • 进程 ID：日志所属进程 ID，INFO 后的数字即为进程
  • 分隔符："----" 作为分隔符
  • 线程名：使用中括号括起来的内容
  • 日志名：默认使用源代码的类名
  • 日志内容：冒号右侧的内容

​ 日志配置项

属性作用
logging.config加载指定位置的日志配置文件
logging.file.max-history要保留的存档日志文件的最大数目
logging.file.max-size日志文件的最大占用空间，单位为MB
logging.level.*设置某个范围下的日志级别，比如 logging.level.org.springframework=DEBUG
logging.pattern.console设置在控制台输出的日志的格式
logging.pattern.dateformat设置在控制台输出的日志的日期格式
logging.pattern.file定义输出到日志文件的日志格式
logging.pattern.level定义日志的输出级别

在默认情况下，Spring Boot 项目可以读取 resources 资源目录中特定名字的日志配置文件，比如 logback-spring.xml、logback.xml。application.yml 文件可以通过 logging.config 属性，找到自定义日志配置文件的位置

语法：logging.config = 日志配置文件的位置和名称

注意：

Spring Boot 官方推荐使用带有-spring 的文件名作为日志配置，即使用 logback-spring.xml，而不是 logback.xml。

<configuration>
    <appender name="consoleLog" class="ch.qos.logback.core.ConsoleAppender">
        <layout>
            <pattern>
                [%-5level]%d %thread - %msg%n
            </pattern>
        </layout> 
    </appender>

    <!--输出日志到文件-->
    <appender name="fileLog" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>INFO</level>
            <onMatch>DENY</onMatch>
        </filter>
        <encoder>
            <pattern>
                [%-5level]%d %thread - %msg%n
            </pattern>
        </encoder>
        <!--指定文件的输出位置-->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">  
            <!--定义把每一天的日志归档到一个文件中，其中用到了 property 定义的变量-->
            <fileNamePattern>
                <!--                ${logback.dir}/info.${logback.projname}.%d{yyyy-MM-dd}.log-->
                ${logback.dir}/%d{yyyy-MM-dd}.log
            </fileNamePattern>
            <!--只保留最近 90 天的日志-->
            <maxHistory>90</maxHistory>
            <!--用来指定日志文件的上限大小，到了这个值，就会删除旧的日志-->
            <totalSizeCap>1GB</totalSizeCap>
        </rollingPolicy>
    </appender>

    <root level="info">
        <appender-ref ref="consoleLog"/>
        <appender-ref ref="fileLog"/>
    </root>
</configuration>

  • ：配置文件的根元素节点。包含3个属性：scan、scanPerio、debug

    • sacn：当此属性设置为 true 时表示如果配置文件发生改变，将被重新加载，反之则不对配置文件是否发生改变进行监测。scan的默认值为 true
    • scanPeriod：设置监测日志配置文件是否有修改的时间间隔。当 scan 为 true 时，此属性有效，默认的时间间隔是1分钟
    • debug：当此属性设置为 true 时，将输出 LogBack 默认日志信息。默认值为 false

  • ：日志的上下文名称。此属性用于区分不同程序的日志。

    • <contextName>testLogback</contextName>
<appender name="consoleLog" class="ch.qos.logback.core.ConsoleAppender">
    <layout>
        <pattern>
            [%-5level]%d %testLogback - %msg%n
        </pattern>
    </layout> 
</appender>

  • ：设置变量值，在日志配置文件中使用。有两个属性——name 和 value

    • <property name="logback.dir" value="C:/logback/test"/>
<property name="logback.projname" value="logbackproj"/>

  • ：配置日志输出的策略。有两个属性——name 和 class，class 用来指定具体采用的输出策略

    • ：指定日志格式，在 ConsoleAppender 控制台输出策略中使用
    • ：指定日志格式，和 layout 的格式化方式相同，只是 encoder 须在 RollingFileAppender 文件输出策略中使用。

    ​ 常用的日志格式及含义

    配置含义
    %d{HH: mm:ss.SSS}日志输出时间
    %thread输出日志的进程名字，这在Web应用以及异步任务处理中很有用
    %-5level日志级别，并且使用5个字符靠左对齐
    %logger{36}日志输出者的名字
    %msg日志消息
    %n平台的换行符

  • ：日志过滤器，如可以过滤指定级别的日志等

    • 一个 可以有多个过滤，这些过滤器按照配置顺序执行。
    <filter class="ch.qos.logback.classic.filter.LevelFilter">
    <!--过滤 Error 级别的日志，只能写一个--> 
    <level>ERROR</level>
    <!--匹配到 ERROR 级别的日志就禁止-->
    <onMatch>DENY</onMatch>
    <!--没有匹配到就允许-->
    <onMismatch>ACCEPT</onMismatch>
</filter>

  • ：当输出日志到文件时，指定文件的路径和文件名，可以是相对路径，也可以是绝对路径。如果上级目录不存在会自动创建，没有默认值。在 Windows 中，反斜杠 \ 需要转义，也可以使用正斜杠 /

  • ：日志输出时的循环策略。

<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy"> 
    <!--定义把每一天的日志归档到一个文件中，其中用到了 property 定义的变量-->
    <fileNamePattern>  
        ${logback.dir}/%d{yyyy-MM-dd}.log
    </fileNamePattern>
    <!--只保留最近 90 天的日志-->
    <maxHistory>90</maxHistory>
    <!--用来指定日志文件的上限大小，到了这个值，就会删除旧的日志-->
    <totalSizeCap>1GB</totalSizeCap>
</rollingPolicy>

3、Java 配置的方式

实现 Java 配置的方式，主要通过两个注解：@Configuration 和 @Bean

  • 当 @Configuration 标注在一个 Java 类上时，此类便具有了和 Spring 的 IoC 配置文件相同的功能，即被 @configuration 标注的类，可以实现 Bean 组件的管理。
  • 若要在 @Configuration 标注的类中实现 Bean 组件的管理，还需要 @Bean 注解，@Bean 注解用于标注在类的方法上，被 @Bean 注解标注的方法返回的类的实例，才能被称为 Bean 组件。

例如，实体类

public class Employee {
    private String userName;//部门名称  
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    @Override
    public String toString() {
        return "Employee{" +
                "userName='" + userName + '\'' +
                ", number='" + number + '\'' +
                '}';
    }
}

@Configuration
public class JavaConfig {
    @Bean
    public Employee employee(){
        Employee employee = new Employee();
        employee.setUserName("嘉龙");
        employee.setNumber("007");
        return employee;
    } 
}

@Bean 注解标注的方法名即 Bean 组件的 id 值。被标注的方法返回的类型，即配置 Bean 组件所需的 class 属性的值。

@Bean 注解提供了 name 属性，通过 name 属性也可以指定 Bean 组件的 id 值。

@Bean 注解没有 id 属性，而是用 name 属性来指定 Bean 组件的 id 值。

@SpringBootTest
class ChapterFourApplicationTests {
    @Test
    void contextLoads() {
        System.out.println(123);
        ApplicationContext context = new AnnotationConfigApplicationContext(JavaConfig.class);
        Employee employee = (Employee) context.getBean("employee");
        System.out.println(employee.toString());
    }
}

AnnotationConfigApplicationContext 类是 ApplicationContext 的实现类之一，用于管理 Java 配置的方式生成的 Spring 容器。

3.1、Java 配置的方式扩展

使用 @Scope 注解，@Scope 注解可以标注到方法上，与 @Bean 注解搭配使用。

使用 @Bean 注解的两个属性 initMethod 和 destoryMethod，可以实现初始化 Bean 和容器销毁之前的所做的操作。

hot water.
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring Boot基础学习笔记04
M_1725046289的博客
05-07 91
1、熟悉使用@PropertySource加载配置文件 2、熟悉使用@ImportResource加载XML配置文件 3、掌握使用@Configuration编写自定义配置类 一、为什么需要加载自定义配置文件 Spring Boot免除了项目中大部分的手动配置，对于一些特定情况，我们可以通过修改全局配置文件以适应具体生产环境，可以说，几乎所有的配置都可以写在application.peroperties文件中，Spring Boot会自动加载全局配置文件从而免除我们手动加载的烦恼。但是，如果我们自定义配置文
spring.profiles的使用详解
wh柒八九的博客
07-02 1万+
本文来说下spring.profiles.active和spring.profiles.include的使用与区别。
spring.profiles.active配置介绍与使用说明
最新发布
码码哈哈的博客
06-08 1870
配置在 Spring 应用程序中用于指定当前激活的配置文件（profiles）。配置文件是 Spring 提供的一种机制，用于将应用程序的配置划分为不同的环境，比如开发（development）、测试（test）、生产（production）等。如果你希望使用不同的命名方式，可以在主配置文件或中使用或来指定其他配置文件的位置。假设你有一个自定义命名的配置文件​配置使得应用程序能够在不同的环境中使用不同的配置，从而简化了开发、测试和部署过程中的配置管理。这一机制可以确保应用程序在不同环境中具有一致性和灵活性。
Spring Profiles的几个小知识
xiaohao718的博客
06-17 1234
Spring Profiles的几个小知识
SpringBoot的多环境配置详解(下)——注解版
扬帆天涯
03-24 1874
在项目运行中，包括多种环境，例如线上环境prod(product)、开发环境dev(development)、测试环境test、提测环境qa、单元测试unitest等等。不同的环境需要进行不同的配置，从而在不同的场景中跑我们的程序。例如prod环境和dev环境通常需要连接不同的数据库、需要配置不同的日志输出配置。还有一些类和方法，在不同的环境下有不同的实现方式。Spring Boot 对此提供了支持，一方面是注解@Profile，另一方面还有多资源配置文件。
profiles标签一键切换微服务环境
癸酉金鸡的博客
05-05 544
父pom.xml: <profiles> <!-- 默认开发环境 --> <profile> <!--id惟一，不能有重复的--> <id>dev</id> <!--配置--> <properties> <!-- 环境标识，须要与配置文件的名称相对应 --> <profiles.active>dev</profiles.active> &lt
SpringBoot基础
11-09
2. 能够理解SpringBoot的特点 3. 能够理解SpringBoot的核心功能 4. 能够搭建SpringBoot的环境 5. 能够完成application.properties配置文件的配置 6. 能够完成application.yml配置文件的配置 7. 能够使用SpringBoot...
SpringBoot基础.zip
11-21
SpringBoot基础教程是一个针对初学者精心设计的课程，旨在帮助新手快速掌握SpringBoot的核心概念和实践技巧。SpringBoot是Spring框架的一个子项目，它简化了Java应用的初始搭建以及开发过程，通过内置的依赖和自动...
SpringBoot基础视频
11-19
网上的资源基本都是根据培训机构改编的，我也都看了看，然后发现对于刚刚接触的人来说，还是这个培训机构的比较好
springboot基础框架
02-19
**SpringBoot基础框架详解** SpringBoot是由Pivotal团队提供的全新框架，其设计目标是为了简化Spring应用的初始搭建以及开发过程。它集成了大量的常用组件，如数据源、定时任务、缓存等，并且默认提供了合理的配置...
springboot 基础工程源代码（包括父工程，子模块，基础模块三部分）
02-26
SpringBoot基础工程源代码分析 在本项目中，我们探讨的是一个基于SpringBoot的基础工程，它分为三个主要部分：父工程、子模块和基础模块。这样的结构有助于代码组织和项目管理，尤其对于大型项目而言，它能提升开发...
windows如何配置springboot_Spring Boot是如何加载配置文件的？
weixin_42604188的博客
01-25 482
Spring Boot框架提供了很多的默认配置，但是还是有部分配置需要我们自己手动配置。一般情况下，我们的配置都是写在application.properties或application.yml中，那么Spring Boot如何加载配置文件的呢？这里我们从SpringApplication.run(class, args);开始，这里我们使用的Spring Boot的版本是都2.2.1....
SpringBoot的多环境开发以及常见配置方法
qq_35227352的博客
02-26 690
多环境开发 yaml版——多环境全都写在单个配置文件内 spring: profiles: active: pro #设置为应用生产环境 --- #生产环境 spring: config: activate: on-profile: pro server: port: 80 --- #开发环境 spring: config: activate: on-profile: dev server: port: 81 --- #测试环境 spring: config:
SpringBoot多环境配置及配置文件分类
萌兔兔MMQ！！
10-10 2553
一、多环境配置在工作中，对于开发环境、测试环境、生产环境的配置肯定都不相同，比如我们开发阶段会在自己的电脑上安装 mysql ，连接自己电脑上的 mysql 即可，但是项目开发完毕后要上线就需要该配置，将环境的配置改为线上环境的。来回的修改配置会很麻烦，而 SpringBoot 给开发者提供了多环境的快捷配置，需要切换环境时只需要改一个配置即可。不同类型的配置文件多环境开发的配置都不相同，接下来对不同类型的配置文件进行说明1.1 yaml文件。
spring中使用内存数据库（Embedded database）
gb4215287的博客
10-07 3680
内存数据库（Embedded database或in-momery database）具有配置简单、启动速度快、尤其是其可测试性等优点，使其成为开发过程中非常有用的轻量级数据库。在spring中支持HSQL、H2和Derby三种数据库。 下面看一下具体使用方法： 1.需要在applicationContext.xml中添加如下： Xml代码 <jdbc:embedded-databaseid="dataSource"> <jdbc:scriptlocati...
SpringBoot激活profiles你知道几种方式？
恒宇少年De成长之路
10-23 3870
多环境是最常见的配置隔离方式之一，可以根据不同的运行环境提供不同的配置信息来应对不同的业务场景，在SpringBoot内支持了多种配置隔离的方式，可以激活单个或者多个配置文件。 激活Profiles的方式 激活的profiles要在项目内创建对应的配置文件，格式为application-{profile}.yml。 命令行方式 命令行方式是一种外部配置的方式，在执行java -ja...
6_1.springboot2.x整合JDBC与数据源配置原理解析
含江君
10-04 892
1、引言 对于数据访问层，无论是SQL还是NOSQL，Spring Boot默认采用整合 Spring Data的方式进行统一处理，添加大量自动配置，屏蔽了很多设置。引入各种xxxTemplate，xxxRepository来简化我们对数据访问层的操作。对我们来说只需要进行简单的设置即可。 2、步骤 这里springboot版本是springboot2.18 1、引入starter ...
SpringBoot常见问题--启动报错（Cannot determine embedded database driver class for database type NONE）
兵哥LOVE坤
08-30 2008
SpringBoot启动报错：Cannot determine embedded database driver class for database type NONE springboot启动时会自动注入数据源和配置jpa 解决办法一：启动类中加入注解：@SpringBootApplication(exclude={DataSourceAutoConfiguration.class,Hib...
springboot之核心依赖spring-boot-starter，spring-boot-starter-parent，spring-boot-starter-web依赖解析
热门推荐
大海无量的博客
04-25 3万+
参考：https://blog.csdn.net/zhou920786312/article/details/84324915 https://blog.csdn.net/tr1912/article/details/79217132 spring-boot-starter：spring-boot场景启动器，后面跟的单词就是场景，比如说后面跟web,就是导入web场景的所有依赖。 1.sp...
Springboot基础
08-24
Spring Boot是一个用于构建独立的、生产级别的Spring应用程序的框架。它简化了Spring应用程序的配置和部署过程，提供了一种快速开发的方式。 Spring Boot提供了一些核心功能，包括自动配置、起步依赖和命令行界面。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值