SpringBoot核心配置文件

最新推荐文章于 2024-02-27 15:08:08 发布
最新推荐文章于 2024-02-27 15:08:08 发布
阅读量2.9k 收藏 7
点赞数 1
分类专栏： Springboot 文章标签： spring boot java spring bean 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_49044908/article/details/121776614
版权

SpringBoot核心配置文件

配置文件的名称必须是application
扩展名有两种分别为 .properties(key=value形式)和.yml(key:value)

使用application.properties

文件结构
文件内容为

#设置端口号
server.port=8081
#设置访问应用的上下文路径
server.servlet.context-path=/myboot

视图层

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

@Controller
public class BootController {

    @RequestMapping("/hello")
    @ResponseBody
    public String doSome() {
        return "SpringBoot应用";
    }
}

此时如果我们访问之前的localhost:8081/hello就会404
404
由于在配置文件中配置过了,访问时必须访问localhost:8081/myboot/hello
结果展示

使用application.yml

我们将核心配置文件使用yml的方式创建

server:
  port: 8081
  servlet:
    context-path: /myboot2

这个yml和上面properties文件表示的配置一模一样,yml的优势在于结构化表示,层级更分明.
注意 :

  1. 每次分级都要使用tab或者两个空格
  2. :后必须使用一个空格在写value

解释
如果一个项目中既有application.properties和application.yml文件,那么properties的优先级高,先生效,但是不建议一个项目中有两种类型的配置文件.

多环境配置

在实际的开发过程中,我们的项目会经历很多的阶段(开发->测试->上线),每个阶段的配置也会有所不同,例如端口号,上下文根,数据库信息等,那么这个时候为了方便在不同的环境之间切换,SpringBoot提供了多环境配置.
具体步骤如下 :

  1. 先创建多个配置文件,命名的规则为application-环境名称.properties(.yml)
    例如开发环境 : application-dev.properties
    测试环境 : application-test.properties
  2. 在核心配置文件application.properties(.yml)指定当前需要使用哪个环境的配置文件

具体例子如下 :
文件结构文件结构
以测试的配置文件为例application-test.yml

#开发环境配置文件
server:
  port: 9001
  servlet:
    context-path: /mytest

然后再核心配置文件中指定使用的文件application.properties

#因为会先读取这个文件,所以我们在这个文件中告诉springboot读取那个文件
#即激活使用哪一个配置文件

#激活application-test的配置文件
spring.profiles.active=test

此时我们指定的就是测试的环境,访问的url为 http://localhost:9001/mytest/hello
结果

SpringBoot自定义配置

将一些内容写进application.properties文件中,我们就可以从文件中获取

@Value

直接给出例子 : 我们在application.properties中配置了如下键值对

#自定义key=value
school.name=SUST
school.website=www.baidu.com
school.address=西安市

site=www.baidu.com

我们在某处就可以使用@Value获取到
这里是在controller层中获取

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class HelloController {

    @Value("${server.port}")
    private Integer port;

    @Value("${server.servlet.context-path}")
    private String contextPath;

    @Value("${school.name}")
    private String name;

    @Value("${school.website}")
    private String web;

    @Value("${school.address}")
    private String address;

    @Value("${site}")
    private String baidu;

    @Override
    public String toString() {
        return "HelloController{" +
                "port=" + port +
                ", contextPath='" + contextPath + '\'' +
                ", name='" + name + '\'' +
                ", web='" + web + '\'' +
                ", address='" + address + '\'' +
                ", baidu='" + baidu + '\'' +
                '}';
    }

    @RequestMapping("/data")
    @ResponseBody
    public String queryData() {
        return this.toString();
    }
}

当我们使用多配置文件的时候,我们只能获取到正在使用的文件的信息
看下面的例子 : 文件结构如下
文件结构
我们的application.properties文件中指定了test环境的配置文件
application.properties

#使用test环境的配置文件
spring.profiles.active=test

#自定义key=value
school.name=SUST
school.website=www.baidu.com
school.address=西安市

site=www.baidu.com

application-dev.yml

#开发环境配置文件
server:
  port: 8081
  servlet:
    context-path: /mydev


#自定义键值对
dev:
  name: 开发

application-test.properties

#配置测试环境
server.port=8081
#配置上下文
server.servlet.context-path=/mytest

#自定义键值对
test.name=test

controller层中获取键值对信息

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class HelloController {

    @Value("${server.port}")
    private Integer port;

    @Value("${server.servlet.context-path}")
    private String contextPath;

    @Value("${school.name}")
    private String name;

    @Value("${school.website}")
    private String web;

    @Value("${school.address}")
    private String address;

    @Value("${site}")
    private String baidu;

    @Value("${test.name}")
    private String testName;

//    @Value("${dev.name}")
//    private String devName;

    @Override
    public String toString() {
        return "HelloController{" +
                "port=" + port +
                ", contextPath='" + contextPath + '\'' +
                ", name='" + name + '\'' +
                ", web='" + web + '\'' +
                ", address='" + address + '\'' +
                ", baidu='" + baidu + '\'' +
                ", testName='" + testName + '\'' +
//                ", devName='" + devName + '\'' +
                '}';
    }

    @RequestMapping("/data")
    @ResponseBody
    public String queryData() {
        return this.toString();
    }
}

访问url得到结果
结果
可以看到,我们可以访问到test.name,这是因为我们的核心配置文件加载到了test的配置文件,所以才可以读取只属于这个文件中的信息,而dev没有被加载,dev.name注入时会失败.

@ConfigurationProperties

前面我们获取信息是一条一条获取的,我们能否使用一个对象接受对应的信息?这就可以使用@ConfigurationProperties注解
直接给出例子 :
文件结构如下 :
文件结构
application.properties文件内容如下 :

#配置URl
server.port=8081
server.servlet.context-path=/myboot

#自定义key=value
school.name=SUST
school.website=www.baidu.com
school.address=西安市

我们将这些school开头的信息注入到一个对象中
SchoolInfo类信息如下 :

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "school")
public class SchoolInfo {

    private String name;

    private String website;

    private String address;

    @Override
    public String toString() {
        return "SchoolInfo{" +
                "name='" + name + '\'' +
                ", website='" + website + '\'' +
                ", address='" + address + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getWebsite() {
        return website;
    }

    public void setWebsite(String website) {
        this.website = website;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

在这个实体类中使用了@ConfigurationProperties注解
这个注解的prefix属性就是指前缀,框架会为我们自动识别前缀为"school"的键值对,注入到实体类SchoolInfo的成员中,匹配的规则为前缀相同,配置文件中的key和成员的名称相同则注入,在这个类上方我们还需使用注解创建对象,这里使用的是@Component创建对象,并且将对象放入容器中,我们就可以在别的地方取出这对象了.

controller类

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.zjb.vo.SchoolInfo;

import javax.annotation.Resource;

@Controller
public class HelloController {

    @Resource
    private SchoolInfo schoolInfo;

    @RequestMapping("/info")
    @ResponseBody
    public String queryInfo() {
        return schoolInfo.toString();
    }
}

这个controller中的schoolInfo属性上使用了@Resource注解完成赋值,先在容器中寻找和该属性名相同的bean的id,找不到在找相同类型的进行赋值.
访问页面得到如下结果 :
结果

SpringBoot中使用jsp

首先强调一点是springboot并不推荐使用jsp,默认框架也不支持使用jsp,需要经过一些配置才能使用jsp,现在已经使用模板技术替代jsp.

使用jsp需要做哪些处理?

  1. 加入一个处理jsp的依赖,负责编译jsp文件
<dependency>
 <groupId>org.apache.tomcat.embed</groupId>
 <artifactId>tomcat-embed-jasper</artifactId>
</dependency>
  1. 如果需要使用servlet,jsp或者jstl等功能需要加对应的依赖
<!--如果要使用 servlet 必须添加该以下两个依赖-->
<!-- servlet 依赖的 jar 包-->
<dependency>
 <groupId>javax.servlet</groupId>
 <artifactId>javax.servlet-api</artifactId>
</dependency>
<!-- jsp 依赖 jar 包-->
<dependency>
 <groupId>javax.servlet.jsp</groupId>
 <artifactId>javax.servlet.jsp-api</artifactId>
 <version>2.3.1</version>
</dependency>
<!--如果使用 JSTL 必须添加该依赖-->
<!--jstl 标签依赖的 jar 包 start-->
<dependency>
 <groupId>javax.servlet</groupId>
 <artifactId>jstl</artifactId>
</dependency>
  1. 创建一个存放jsp的目录,一般叫做webapp
    将这个webapp目录放在存放目录main文件下,之后这个将这个文件的性质改变才能创建jsp
    修改
    之后这个webapp就变成了一个小蓝点的文件,如下改变后
  2. 需要在pom.xml文件中指定jsp文件编译后的目录
    META-INF/resources
  3. 创建Controller,范文jsp
  4. 在application.properties文件中配置视图解析器

下面给出一个具体的小例子

  1. 加入对应依赖和指定jsp编译后存放的目录
    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>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.4.2</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>org.zjb</groupId>
	<artifactId>009-springbbot-jsp</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<properties>
		<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>
		</dependency>

		<!--处理jsp的依赖-->
		<dependency>
			<groupId>org.apache.tomcat.embed</groupId>
			<artifactId>tomcat-embed-jasper</artifactId>
		</dependency>


	</dependencies>


	<build>

		<!--指定jsp编译后的存放目录-->
		<resources>
			<resource>
				<!--jsp的原目录-->
				<directory>src/main/webapp</directory>
				<!--指定编译后的存放目录-->
				<targetPath>META-INF/resources</targetPath>
				<!--指定处理的目录和文件-->
				<includes>
					<include>**/*.*</include>
				</includes>
			</resource>
		</resources>

		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>
  1. 加入webapp目录并编写jsp文件
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>jsp</title>
</head>
<body>
    <h3>使用jsp显示Controller中的数据 ${data}</h3>
</body>
</html>
  1. 编写controller视图层
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;

@Controller
public class JspController {

//    public String doJsp(HttpServletRequest request) {
//
//        request.setAttribute("data", "Springboot使用JSP");
//        // 视图的逻辑名称
//        return "index";
//    }

    @RequestMapping("/myjsp")
    public String doJsp(Model model) {

        // 将数据放入到request作用域
        model.addAttribute("data", "springBoot使用jsp");
        return "index";
    }
}
  1. 在核心配置文件中配置视图解析器
    application.properties内容如下:
server.port=8081
server.servlet.context-path=/myboot

#配置视图解析器
#配置前缀 /代表src/main/webapp
spring.mvc.view.prefix=/
#配置后缀
spring.mvc.view.suffix=.jsp
  1. 运行并且访问
    运行结果
  2. 文件结构如下
    文件结构

SpringBoot中使用ApplicationContext

想通过代码从容器中获取对象可以使用如下方法:
SpringApplication.run()的返回值获取到容器对象.
点进该方法,
run方法
可以看见这个方法的返回值为ConfigurableApplicationContext
这个接口的信息如下:
接口信息
它继承了ApplicationContext容器对象,说明run方法的返回值就是容器对象

我们给出例子:
service接口实现类,使用注解创建对象并注入容器中

import org.springframework.stereotype.Service;
import org.zjb.service.UserService;

@Service("userService")
public class UserServiceImpl implements UserService {
    @Override
    public void sayHello(String name) {
        System.out.println("hello" + name);
    }
}

application.java中获取容器对象,并且将其中的bean取出.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.zjb.service.UserService;

@SpringBootApplication
public class Application {

	public static void main(String[] args) {

		// 获取容器对象
		ConfigurableApplicationContext ctx = SpringApplication.run(Application.class, args);

		// 从容器中获取对象
		UserService userService = (UserService) ctx.getBean("userService");

		userService.sayHello("李四");
	}

}

结果如下 :
结果

CommandLineRunner接口和ApplicationRunner接口

这两个接口都有一个run()方法,执行的时间是容器对象创建好后,我们可以依靠这个run方法在容器创建好之后完成一些操作,如数据库对象的赋值等.
例子如下 :
service实现类

import org.springframework.stereotype.Service;
import org.zjb.service.HelloService;

@Service("helloService")
public class HelloServiceImpl implements HelloService {
    @Override
    public String sayHello(String name) {
        return "你好" + name;
    }
}

application.java如下 :

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.zjb.service.HelloService;

import javax.annotation.Resource;

@SpringBootApplication
public class Application implements CommandLineRunner {

	@Resource
	private HelloService helloService;

	public static void main(String[] args) {

		// 创建容器对象
		System.out.println("准备创建容器");
		SpringApplication.run(Application.class, args);
		System.out.println("容器创建后");
	}

	@Override
	public void run(String... args) throws Exception {
		System.out.println(helloService.sayHello("张三"));
		// 可以这里做自定义的操作,比如读取文件,数据库等
		System.out.println("在容器对象创建后执行的方法");
	}
}

执行代码观察执行顺序,如下 :
执行顺序
可见容器创建的时候才会执行commandlineRunner的run()方法,同时单例的bean在容器创建之初就已经注入到容器中.
执行的顺序如下

  1. 先SpringApplication.run(Application.class, args)创建容器
  2. 注入单例bean
  3. 执行CommandLineRunner的run()方法
  4. 执行之后的代码
迷亭君
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot application.properties各种配置解释
哎呀的博客
12-27 1万+
SpringBoot引导应用程序的属性配置application.properties详解
SpringBoot入门系列（四）整合模板引擎Thymeleaf
章为忠的专栏
03-09 158
前面介绍了Spring Boot的优点，然后介绍了如何快速创建Spring Boot 项目。不清楚的朋友可以看看之前的文章：https://www.cnblogs.com/zhangweizhong/category/1657780.html。 今天我们主要来看看 Thymeleaf 在 Spring Boot 中的整合！ 这个系列课程的完整源码，也会提供给大家。大家关注我的微信公众号...
springboot yml方式多环境切换 dev,test,prod环境
weixin_55774961的博客
02-27 486
springboot 多环境配置
SpringBoot核心配置全面总结
mxt51220的博客
05-03 2216
在SpringBoot核心配置文件中，除以上使用内置的配置项之外，我们还可以在自定义配置，然后采用注解方式去读取配置。
Spring Boot2.0 启动加载指定环境application.properties配置文件
zzhongcy的专栏
09-04 1万+
通常我们在开发完成一个SpringBoot项目时，总是要打包部署的。 　　在启动SpringBoot应用时，我们常常会使用命令java -jar xxx.jar来启动这个服务。 　　命令java -jar 除了启动应用之外，还可以在命令中指定应用的参数，比如一下带参数的命令： 　　(1)java -jar xxx.jar --server.port=8081，直接以命令的方式来设置服务的访问...
springboot中配置文件application.properties的理解
yinni11的博客
06-19 319
前言 Spring Boot使用“习惯优于配置”（项目中存在大量的配置，此外还内置了一个习惯性的配置，让你无需手动进行配置）的理念让你的项目快速运行起来。所以，我们要想把Spring Boot玩的溜，就要懂得如何开启各个功能模块的默认配置，这就需要了解Spring Boot的配置文件application.properties。 正文 pring Boot使用了一个全局的配置文...
Spring Boot 核心配置文件
小凯的博客
03-21 2660
springboot 关于核心配置文件的笔记整理
Spring Boot 核心配置文件，yml 语法规范、多环境配置、配置文件加载顺序，EnvironmentAware 读取 yml 配置
热门推荐
蚩尤后裔-汪茂雄
07-13 1万+
目录 需求分析 多 profile 文件形式 yml 文档块形式 需求分析 Profile 是 Spring 对不同环境提供不同配置功能的支持，可以通过激活、指定参数等方式快速切换环境 项目开发时有开发环境、测试环境、部署环境等，可以通过 profile 配置切换 多 profile 文件形式 格式：application-{profile}.properties/yml，如：ap...
springboot配置文件application-dev.properties，application-prod.properties，application-test.properties
qq_16613311的博客
08-06 1万+
springboot的配置文件有以下 application.properties application-dev.properties 开发环境 application-prod.properties 运行环境 application-test.properties 测试环境 在application.properties中配置内容 spring.profiles.active=dev ...
3.SpringBoot 配置文件 - application.properties的常用配置
yiguang_820的博客
06-13 1万+
目录： 简单配置 详细配置 应用程序上下文初始化器 多种开发环境配置 服务器 配置端口和项目名访问 http tomcat的几个配置 数据库 数据库连接配置 Mybatis redis配置 视图 mvc thymeleaf组件配置 功能 测试生产日志分离 文件上传multipart 一. 简单配置 #多环境配置，测试，生产用不同的配置文件 spring.profiles.active=....
【SpringBoot】03-springboot核心配置文件
m0_50964976的博客
06-02 4123
springboot的核心配置
springboot 集成kettle核心包依赖文件配置信息pom.xml
10-22
springboot 集成kettle核心包依赖文件配置信息pom.xml
Spring Boot核心配置文件模板
08-19
Spring Boot核心配置文件模板application.properties，里面有所有配置的key以及value样例
Github 上最值得学习的 Springboot核心笔记
最新发布
05-06
我们知道，从 2002 年开始，Spring 一直在飞速的发展，如今已经成为了在Java EE（Java Enterprise Edition）开发中真正意义上的标准，但是随着技术的发展，JavaEE使用 Spring 逐渐变得笨重起来，大量的 XML 文件存在...
SpringBoot学习视频
06-02
尚硅谷_SpringBoot_配置-properties配置文件编码问题 尚硅谷_SpringBoot_配置-@ConfigurationProperties与@Value区别 尚硅谷_SpringBoot_配置-@PropertySource、@ImportResource、@Bean 尚硅谷_SpringBoot_配置-配置...
基于SpringBoot2的响应式编程与核心技术设计源码
04-12
系统专注于SpringBoot2的核心技术和响应式编程，提供了丰富的文件类型支持，包括JavaScript脚本、CSS样式表、PNG图片、Java源代码、HTML页面、JPG图片、XML配置文件、PROPERTIES配置文件、YAML配置文件和GIF动画。...
java：application.properties的详细使用以及区分环境
分享前端开发工程师的一些日常生活、前端知识点、职业发展、对一些问题的看法、感悟等等
11-22 1885
java：application.properties的详细使用以及区分环境
SpringBoot多环境(dev、test、prod)配置详解
Touch
12-16 2726
SpringBoot多环境(dev、test、prod)配置详解 我们在开发应用的时候，通常同一套程序会被应用和安装到几个不同的环境中，比如开发、测试、生产等。其中每个环境的数据库地址、服务器端口等配置都不同。如果在为不同环境打包时都要频繁的修改配置文件，那必将是个非常繁琐的且容易出错的事情。 对于多环境的配置，各种项目构建工具或是架...
@SpringBootApplication 与 @SpringBootTest 的区别与应用
一步一步往上爬
07-31 4632
@SpringBootApplication、 @SpringBootTest 、@ComponentScan、@EnableAutoConfiguration 注解区别与分析。
springboot核心配置文件
10-19
在编写SpringBoot核心配置文件时，需要注意以下几点： 1. 配置文件目录应该位于resources目录下。 2. 根据项目开发的阶段不同，应编写不同开发环境下的配置文件，使用时只需要在主配置文件中进行激活即可。 3. 根据...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值