spring读取properties

合集下载

Spring加载Properties配置文件的三种方式

Spring加载Properties配置⽂件的三种⽅式⼀、通过 context:property-placeholder 标签实现配置⽂件加载1) ⽤法:1、在spring.xml配置⽂件中添加标签<context:property-placeholder ignore-unresolvable="true" location="classpath:redis-key.properties"/>2、在 spring.xml 中使⽤配置⽂件属性:$<property name="url" value="${jdbc.url}"/><property name="username" value="${ername}"/><property name="password" value="${jdbc.password}" /3、在java⽂件中使⽤：@Value("${jdbc.url}")private String jdbcUrl; // 注意：这⾥变量不能定义成static2) 注意点:踩过的坑在Spring中的xml中使⽤<context:property-placeholderlocation>标签导⼊配置⽂件时，想要导⼊多个properties配置⽂件，如下：<context:property-placeholderlocation="classpath:db.properties " /><context:property-placeholderlocation="classpath:zxg.properties " />结果发现不⾏，第⼆个配置⽂件始终读取不到，Spring容器是采⽤反射扫描的发现机制，通过标签的命名空间实例化实例，当Spring探测到容器中有⼀个org.springframework.beans.factory.config.PropertyPlaceholderConfigurer的Bean就会停⽌对剩余PropertyPlaceholderConfigurer的扫描，即只能存在⼀个实例如果有多个配置⽂件可以使⽤ “,” 分隔<context:property-placeholderlocation="classpath:db.properties,classpath:monitor.properties"/>可以使⽤通配符 *<context:property-placeholderlocation="classpath:*.properties"/>3) 属性⽤法ignore-resource-not-found //如果属性⽂件找不到，是否忽略，默认false，即不忽略，找不到⽂件并不会抛出异常。

springboot获取properties属性值的多种方式总结

springboot获取properties属性值的多种⽅式总结⽬录获取properties属性值⽅式总结1. 除了默认配置在 application.properties的多环境中添加属性2. 使⽤之前在spring中加载的value值形式3. 也可以使⽤springboot⾥⾯的Environment 直接取值4. 如果是⾃⼰新建的⼀个properties⽂件获取多个⾃定义属性值⽐如在application中⾃定义属性获取properties属性值⽅式总结spring boot 在多环境情况下我们需要根据不同的获取不⼀样的值，我们会配置在不同的⽂件中,那么我们怎么获取配置的属性值呢！下⾯介绍⼏种⽤法。

1. 除了默认配置在 application.properties的多环境中添加属性我们会在application.properties 中激活不同⽅式选择下⾯的不同⽂件进⾏发布。

设置的激活参数：dev, test, prodspring.profiles.active=produrl.lm=editMessageCode=100120171116031838url.ybd=/sales/url.PostUrl=/LmCpa/apply/applyInfo获取属性可以, 定义配置类：@ConfigurationProperties(prefix = "url")public class ManyEnvProperties{private String lm;private String orgCode;private String ybd;private String postUrl;// 省列getter setter ⽅法}2. 使⽤之前在spring中加载的value值形式@Componentpublic class ManyEnvProperties {@Value("${url.lm}")private String lmPage;@Value("${url.ybd}")private String sendYbdUrl;@Value("${Code}")private String orgCode;@Value("${url.PostUrl}")private String PostUrl;// 省列getter setter ⽅法}3. 也可以使⽤springboot⾥⾯的Environment 直接取值显⽰注⼊，其次是在需要的地⽅获取值@Autowiredprivate Environment env;("===============》 " + env.getProperty("url.lm"));4. 如果是⾃⼰新建的⼀个properties⽂件@Component@ConfigurationProperties(prefix = "url")@PropertySource("classpath:/platform.properties")public class PropertiesEnv {private String lm;private String orgCode;private String ybd;private String postUrl;// 省列getter setter ⽅法}获取多个⾃定义属性值使⽤@Value 注⼊每个⾃定义配置，当⾃定义配置的属性值过多时就⽐较⿇烦了，这时通过springboot提供了基于类型安全的配置⽅法，通过@ConfigurationProperties将properties中的属性和⼀个bean的属性关联，从⽽实现类型安全的配置，⽐如在application中⾃定义属性note.author=yzh=china可以通过@ConfigurationProperties(prefix="note")需要注意的是⾃定义属性值的前缀统⼀为note才可以获取到对应的属性值.属性值名称要跟配置⽂件⾥⾯的名称对应起来同时通过这种⽅法需要⽣成属性值的get/set ⽅法，否则获取不到对应的属性值以上为个⼈经验，希望能给⼤家⼀个参考，也希望⼤家多多⽀持。

springboot如何读取自定义properties并注入到bean中

springboot如何读取⾃定义properties并注⼊到bean中⽬录读取⾃定义properties注⼊到beanspringboot启动⽇志如下springboot bean实例化和属性注⼊过程springboot版本（2.0.4 RELEASE）Bean的实例化Bean的属性注⼊读取⾃定义properties注⼊到bean在使⽤springboot项⽬时，可使⽤@value的⽅式直接读取application.properties中的⽂件，但有时我们需要配置⾃定义的properties，下⾯⽅法将在springboot启动时利⽤fileinputstream读取properties⽂件中的内容，并注⼊到bean中，@Configuration注解会在springboot启动时执⾏⼀次，代码如下：package com.shanqis.parking.properties;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import java.io.IOException;import java.io.InputStream;import java.util.HashMap;import java.util.Map;import java.util.Properties;/*** 读取resource下的.properties⽂件，将⽂件中的内容封装到map中，注⼊到bean中⽅便依赖注⼊** @author Administrator*/@Configurationpublic class PropertiesClassLoader {private Logger logger = LoggerFactory.getLogger(PropertiesClassLoader.class);private Map<String, Object> versionProperties = new HashMap<>(16);private void init(String name) {try {Properties properties = new Properties();InputStream in = PropertiesClassLoader.class.getClassLoader().getResourceAsStream(name + ".properties");properties.load(in);("加载{}.properties参数", name);for (String keyName : properties.stringPropertyNames()) {String value = properties.getProperty(keyName);if ("version".equals(name)) {versionProperties.put(keyName, value);}("{}.properties---------key:{},value:{}", name, keyName, value);}("{}.properties参数加载完毕", name);} catch (IOException ignored) {}}@Bean(name = "versionProperties")public Map<String, Object> commonMap() {init("version");return versionProperties;}}springboot启动⽇志如下然后在controller层或者service层等可以这样使⽤/*** 读取common.properties⽂件*/@Autowired @Qualifier("commonMap")protected Map<String, String> commonMap;springboot bean实例化和属性注⼊过程springboot版本（2.0.4 RELEASE）⼤致描述springboot中bean的实例化和属性注⼊过程流程1）在某⼀时刻Spring调⽤了Bean⼯⼚的getBean(beanName)⽅法。

Spring框架读取property属性文件常用5种方法

Spring框架读取property属性⽂件常⽤5种⽅法1、⽅式⼀：通过spring框架 PropertyPlaceholderConfigurer ⼯具实现<bean id="propertyConfig" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"><property name="ignoreUnresolvablePlaceholders" value="true"/><property name="locations"><value>classpath:conf/jdbc.properties</value></property><property name="fileEncoding"><value>UTF-8</value></property><property name="systemPropertiesModeName" value="SYSTEM_PROPERTIES_MODE_OVERRIDE" /></bean><bean id="dataSource" class="mons.dbcp.BasicDataSource"destroy-method="close"><property name="driverClassName" value="${database.connection.driver}"/><property name="url" value="${database.connection.url}"/><property name="username" value="${ername}"/><property name="password" value="${database.connection.password}"/></bean><bean id="dataSource" class="mons.dbcp.BasicDataSource"destroy-method="close"><property name="driverClassName" value="${database.connection.driver}"/><property name="url" value="${database.connection.url}"/><property name="username" value="${ername}"/><property name="password" value="${database.connection.password}"/></bean><bean id="dalClient" class="org.springframework.jdbc.core.JdbcTemplate"><property name="dataSource" ref="dataSource"/></bean>jdbc.properties⽂件：database.connection.driver=com.mysql.jdbc.Driverdatabase.connection.url=jdbc:mysql://*.*.*.*:3306/mysql?characterEncoding=utf-8ername=*database.connection.password=*上述配置理解：1）ignore-unresolvable属性的⽰意：<xsd:documentation><![CDATA[Specifies if failure to find the property value to replace a key should be ignored.Default is "false", meaning that this placeholder configurer will raise an exceptionif it cannot resolve a key. Set to "true" to allow the configurer to pass on the keyto any others in the context that have not yet visited the key in question.]]>翻译后：指定是否应忽略未能找到⽤于替换键的属性值。

关于properties文件的读取（Javaspringspringmvcspringboot）

关于properties⽂件的读取（Javaspringspringmvcspringboot）⼀.Java读取properties⽂件1、基于ClassLoder读取配置⽂件注意：该⽅式只能读取类路径下的配置⽂件，有局限但是如果配置⽂件在类路径下⽐较⽅便。

1 Properties properties = new Properties();2// 使⽤ClassLoader加载properties配置⽂件⽣成对应的输⼊流3 InputStream in = PropertiesMain.class.getClassLoader().getResourceAsStream("config/config.properties");4// 使⽤properties对象加载输⼊流5 properties.load(in);6//获取key对应的value值7 properties.getProperty(String key);2、基于 InputStream 读取配置⽂件注意：该⽅式的优点在于可以读取任意路径下的配置⽂件1 Properties properties = new Properties();23// 使⽤InPutStream流读取properties⽂件45 BufferedReader bufferedReader = new BufferedReader(new FileReader("E:/config.properties"));67 properties.load(bufferedReader);89// 获取key对应的value值properties.getProperty(String key);3、通过 java.util.ResourceBundle 类来读取，这种⽅式⽐使⽤ Properties 要⽅便⼀些 1>通过 ResourceBundle.getBundle() 静态⽅法来获取（ResourceBundle是⼀个抽象类），这种⽅式来获取properties属性⽂件不需要加.properties后缀名，只需要⽂件名即可1 properties.getProperty(String key);2//config为属性⽂件名，放在包com.test.config下，如果是放在src下，直接⽤config即可3 ResourceBundle resource = ResourceBundle.getBundle("com/test/config/config");4 String key = resource.getString("keyWord"); 2>从 InputStream 中读取，获取 InputStream 的⽅法和上⾯⼀样，不再赘述1 ResourceBundle resource = new PropertyResourceBundle(inStream);注意：在使⽤中遇到的最⼤的问题可能是配置⽂件的路径问题，如果配置⽂件⼊在当前类所在的包下，那么需要使⽤包名限定，如：config.properties⼊在com.test.config包下，则要使⽤com/test/config/config.properties（通过Properties来获取）或com/test/config/config（通过ResourceBundle来获取）；属性⽂件在src根⽬录下，则直接使⽤config.properties或config即可。

Spring读取Properties配置文件

Spring读取Properties配置⽂件　⼀、application.properties 配置⽂件 ①：⽤Spring容器获取Environment变量，然后getProperty获取到配置的value ConfigurableEnvironment environment = context.getEnvironment();　 String name = environment.getProperty("name"); ②：@Value注解使⽤@Value（"${key}" ③：@ConfigurationProperties @ConfigurationProperties注解有⼀个prefix属性，通过指定的前缀，绑定配置⽂件中的配置，如：@Component@ConfigurationProperties(prefix = "global.jdbc")public class GlobalProperties {private String url;private String driver;private String username;private String password;...getter/setter}　⼆、⾃定义properties 配置⽂件 ①：@PropertySource + @Value("${key}") @PropertySource ：使⽤@PropertySource读取外部配置⽂件中的k/v保存到运⾏的环境变量Environment中；如：@PropertySource("classpath:mysql.properties") 取值⽅式： ①：使⽤@Value（"${key}" ②：也可以⽤Spring容器获取Environment变量，然后getProperty获取到配置的value ConfigurableEnvironment environment = context.getEnvironment();　 String name = environment.getProperty("name"); ②：⾃⾏直接读取配置⽂件的值并缓存public class PropertiesUtil {private static final Logger LOGGER = LoggerFactory.getLogger(PropertiesUtil.class);private PropertiesUtil() {}private static final Properties PROPERTIES = readProperties("config.properties", "talos.properties");private static Properties readProperties(String... confFile) {final Properties properties = new Properties();try {for (String path : confFile) {final ClassPathResource resource = new ClassPathResource(path);properties.load(new InputStreamReader(resource.getInputStream(), StandardCharsets.UTF_8));}} catch (IOException e) {LOGGER.error(e.getMessage(), e);}return properties;}public static String get(String key) {return PROPERTIES.getProperty(key); }}END.。

SPRINGBOOT读取PROPERTIES配置文件数据过程详解

SPRINGBOOT读取PROPERTIES配置文件数据过程详解
Spring Boot读取properties配置文件的过程可以通过下面的步骤
来详解：
1. 创建配置文件：首先，在Spring Boot项目的resources目录下
创建一个新的配置文件，可以是application.properties或者自定义的
文件名，例如custom.properties。

在配置文件中，可以设置任意的属性
和对应的值。

例如，可以设置数据库连接信息、日志配置、端口号等。

2. 加载配置文件：Spring Boot会自动加载并解析配置文件。

它会
并加载资源目录下的所有properties文件，并将属性值加载到属性映射中。

5.使用配置值：一旦属性值被注入到类中，就可以通过类的字段来访
问配置值。

然后，可以在需要使用配置值的地方，直接使用对应的字段即可。

6. 配置文件的优先级：在Spring Boot中，配置文件的优先级是由
低到高的，高优先级的配置会覆盖低优先级的配置。

优先级从低到高依次为：默认的配置文件（application.properties或application.yml）<
自定义的配置文件（如custom.properties）<命令行参数。

总的来说，Spring Boot读取properties配置文件的过程包括创建
配置文件、加载配置文件、创建配置类、注入配置值、使用配置值等步骤。

通过这些步骤，可以方便地使用配置文件中的属性值，并实现动态刷新配置。

Spring中属性文件properties的读取与使用详解

Spring中属性⽂件properties的读取与使⽤详解Spring中属性⽂件properties的读取与使⽤详解实际项⽬中，通常将⼀些可配置的定制信息放到属性⽂件中（如数据库连接信息，邮件发送配置信息等），便于统⼀配置管理。

例中将需配置的属性信息放在属性⽂件/WEB-INF/configInfo.properties中。

其中部分配置信息（邮件发送相关）：#邮件发送的相关配置email.host = email.port = xxxername = xxxemail.password = xxxemail.sendFrom=***********在Spring容器启动时，使⽤内置bean对属性⽂件信息进⾏加载，在bean.xml中添加如下：Xml代码<bean id="propertyConfigurer"class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"><property name="location"><value>/WEB-INF/configInfo.properties</value></property><property name="fileEncoding" value="utf-8" /></bean>属性信息加载后其中⼀种使⽤⽅式是在其它bean定义中直接根据属性信息的key引⽤value，如邮件发送器bean的配置如下：Xml代码<bean id="mailSender"class="org.springframework.mail.javamail.JavaMailSenderImpl"><property name="host"><value>${email.host}</value></property><property name="port"><value>${email.port}</value></property><property name="username"><value>${ername}</value></property><property name="password"><value>${email.password}</value></property><property name="javaMailProperties"><props><prop key="mail.smtp.auth">true</prop><prop key="sendFrom">${email.sendFrom}</prop></props></property></bean>另⼀种使⽤⽅式是在代码中获取配置的属性信息，可定义⼀个javabean：ConfigInfo.java，利⽤注解将代码中需要使⽤的属性信息注⼊；如属性⽂件中有如下信息需在代码中获取使⽤：Java代码#⽣成⽂件的保存路径file.savePath = D:/test/#⽣成⽂件的备份路径，使⽤后将对应⽂件移到该⽬录file.backupPath = D:/test bak/ConfigInfo.java 中对应代码：Java代码@Component("configInfo")public class ConfigInfo {@Value("${file.savePath}")private String fileSavePath;@Value("${file.backupPath}")private String fileBakPath;public String getFileSavePath() {return fileSavePath;}public String getFileBakPath() {return fileBakPath;}}业务类bo中使⽤注解注⼊ConfigInfo对象：Java代码@Autowiredprivate ConfigInfo configInfo;需在bean.xml中添加组件扫描器，⽤于注解⽅式的⾃动注⼊：Xml代码<context:component-scan base-package="com.my.model" />（上述包model中包含了ConfigInfo类）。

在SpringBoot下读取自定义properties配置文件的方法

在SpringBoot下读取⾃定义properties配置⽂件的⽅法SpringBoot⼯程默认读取application.properties配置⽂件。

如果需要⾃定义properties⽂件，如何读取呢？⼀、在resource中新建.properties⽂件在resource⽬录下新建⼀个config⽂件夹，然后新建⼀个.properties⽂件放在该⽂件夹下。

如图remote.properties所⽰⼆、编写配置⽂件remote.uploadFilesUrl=/resource/files/remote.uploadPicUrl=/resource/pic/三、新建⼀个配置类RemoteProperties.java@Configuration@ConfigurationProperties(prefix = "remote", ignoreUnknownFields = false)@PropertySource("classpath:config/remote.properties")@Data@Componentpublic class RemoteProperties {private String uploadFilesUrl;private String uploadPicUrl;}其中@Configuration 表明这是⼀个配置类@ConfigurationProperties(prefix = "remote", ignoreUnknownFields = false) 该注解⽤于绑定属性。

prefix⽤来选择属性的前缀，也就是在remote.properties⽂件中的“remote”，ignoreUnknownFields是⽤来告诉SpringBoot在有属性不能匹配到声明的域时抛出异常。

@PropertySource("classpath:config/remote.properties") 配置⽂件路径@Data 这个是⼀个lombok注解，⽤于⽣成getter&setter⽅法，详情请查阅lombok相关资料@Component 标识为Bean四、如何使⽤？在想要使⽤配置⽂件的⽅法所在类上表上注解EnableConfigurationProperties(RemoteProperties.class)并⾃动注⼊@AutowiredRemoteProperties remoteProperties;在⽅法中使⽤ remoteProperties.getUploadFilesUrl()就可以拿到配置内容了。

Spring读取properties文件的步骤：

Spring读取properties⽂件的步骤：Spring读取properties⽂件的步骤:
开门见⼭
操作步骤:
1.准备外部properties⽂件
我的项⽬是⽤maven部署的，该⽂件在资源⽂件⾥，你们若不是，可放在src⽂件⾥，或需要的⽬录⾥。

2.开启context命名空间⽀持
在xmlns:xsi="xxx"的下⼀⾏加⼊
xmlns:context="/schema/context"
在xsi:schemaLocation="xxx"⾥⾯的字符串中加⼊
/schema/context
https:///schema/context/spring-context.xsd
注：Spring⾥有不少命名空间，最好⾃⼰仔细观察，找到其中规律，像上⾯这三⾏和原⽂中的⽐较。

3.加载指定的properties⽂件
<context:property-placeholder location="classpath:filename.properties"/>
4.使⽤加载的数据
<property name="propertyName" value="${propertiesName}"/>
注意: 如果需要加载所有的properties⽂件，可以使⽤*.properties表⽰加载所有的properties⽂件
注意: propertyName,指属性名，propertiesName指properties⽂件中的属性名。

SpringBoot四种读取properties文件的方式

二、使用`@Value("${propertyName}")`注解，在需要使用的类中使用成员变量
三、使用Environment，在任何想要用的地方直接获取值四、通过注册监听器(`Listeners`) + `PropertiesLoaderUtils`的方式（比较前三种方式，更复杂）（1）、编写配置文件监听器，用来加载自定义配置文件，实现ApplicationListener<ApplicationStartedEvent> （2）、编写加载配置文件的类 3、修改启动类，注册监听器 4.编写测试类，运行结果如下
登录后才能查看或发表评论立即登录或者逛逛博客园首页
SpringBoot四种读取 propertgBoot2.1.4 例，使用如下.properties为后缀的默认application.properties文件，yml格式文件也同理一、使用`@ConfigurationProperties`注解将配置文件属性注入到自定义配置对象类中（1）、首先定义配置对象（2）、具体使用，运行后将可以得到实体返回数据

详解SpringBoot读取resource目录下properties文件的常见方式

详解SpringBoot读取resource⽬录下properties⽂件的常见⽅式个⼈理解在企业开发中，我们经常需要⾃定义⼀些全局变量/不可修改变量或者参数来解决⼤量的变量重复问题，当需要这个全局变量时，只需要从配置⽂件中读取即可，根据开发中常见的情况，可以分为以下两种情况，分别是:配置⽂件为SpringBoot默认的application.properties⽂件中的⾃定义参数加载⾃定义properties⽂件中的⾃定义参数，⽐如xxx.properties的⾃定义参数加载SpringBoot默认的application.properties准备⼯作server.port=8081# ⾃定义参数->都是person.变量名的形式person.id=1=szh# list/set/数组->两种写法person.hobby=play,read,writeperson.family[0]=fatherperson.family[1]=mother# map->两种写法person.map.key1=value1person.map[key2]=value2# Entity对象->Pet实体类person.pet.type=dog=旺财import lombok.AllArgsConstructor;import lombok.Data;import lombok.NoArgsConstructor;import java.io.Serializable;@NoArgsConstructor@AllArgsConstructor@Datapublic class Pet implements Serializable {private String type;private String name;}⽅式⼀： @ConfigurationProperties开发中如果获取整个以xxx开头的所有参数，那么推荐使⽤第⼀种⽅式，如果获取单个参数，那么建议使⽤第⼆种获取参数⽅式。

SPRINGBOOT读取PROPERTIES配置文件数据过程详解

SPRINGBOOT读取PROPERTIES配置⽂件数据过程详解这篇⽂章主要介绍了SPRINGBOOT读取PROPERTIES配置⽂件数据过程详解,⽂中通过⽰例代码介绍的⾮常详细，对⼤家的学习或者⼯作具有⼀定的参考学习价值,需要的朋友可以参考下⼀.使⽤@ConfigurationProperties来读取1、Coffer entity@Configuration@ConfigurationProperties(prefix = "coffer")@PropertySource("classpath:config/coffer.properties")public class Coffer {private String brand;private Double length;private Double width;private Double height; //省略了get/set⽅法private String[] contains;private ArrayList<Fruit> fruits;private HashMap<String,Object> map;}2、Fruit entity@Configuration@ConfigurationProperties(prefix = "coffer.fruits")@PropertySource("classpath:config/coffer.properties")public class Fruit {private String fruitName;private String fruitColor; //省略了get/set⽅法}3、coffer.propertiescoffer.brand=Camelcoffer.length=100.00coffer.width=80.00coffer.height=60.00coffer.contains[0]=Raincoatcoffer.contains[1]=trouserscoffer.contains[2]=hatcoffer.contains[3]=glovecoffer.contains[4]=scarfcoffer.contains[5]=hoodcoffer.fruits[0].fruitName=apricotcoffer.fruits[0].fruitColor=yellowcoffer.fruits[1].fruitName=plumcoffer.fruits[1].fruitColor=greencoffer.fruits[2].fruitName=pineapplecoffer.fruits[2].fruitColor=yellowcoffer.fruits[3].fruitName=watermeloncoffer.fruits[3].fruitColor=greencoffer.fruits[4].fruitName=strawberrycoffer.fruits[4].fruitColor=red=xiaomaocoffer.map.age=22coffer.map.gender=female4、springbootApplicationTest@SpringBootTestclass SpringbootApplicationTests {@Autowiredprivate ApplicationContext ioc;@Autowiredprivate Coffer coffer;@Testpublic void springbootTest(){System.out.println(coffer);}}5、resultCoffer{ brand='Camel', length=100.0, width=80.0, height=60.0, contains=[Raincoat, trousers, hat, glove, scarf, hood], fruits=[ Fruit{fruitName='apricot', fruitColor='yellow'}, Fruit{fruitName='plum', fruitColor='green'}, Fruit{fruitName='pineapple', fruitColor='yellow'}, Fruit{fruitName='watermelon', fruitColor='green'}, Fruit{fruitName='strawberry', fruitColor='red'} ], map={age=22, gender=female, name=xiaomao}}⼆、使⽤@Value来读取在springTest中⽆法使⽤@Value来读取配置属性,需要放到Controller中去读取@PropertySource("classpath:config/coffer.properties")@RestControllerpublic class SpringbootController {@Value("${coffer.brand}")private String brand;@Value("${coffer.height}")private Double height;@RequestMapping("/test")public String springbootTest() {return brand+"====="+height;}}以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

SpringBoot读取properties或者application.yml配置文件中的数据

SpringBoot读取properties或者application.yml配置⽂件中的数据读取application⽂件在application.yml或者properties⽂件中添加：user.address=chinapany=demo=让我康康1、使⽤@Value注解读取直接代码如下：package im.homeapi.controller;import org.springframework.beans.factory.annotation.Value;import org.omg.CORBA.PUBLIC_MEMBER;import org.springframework.web.bind.annotation.RestController;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestMethod;@RestController@RequestMapping(value="/api")public class HomeController {@Value("${user.address}")private String address;@Value("${pany}")private String company;@Value("${}")private String name;//value 指定访问地址，method 指定请求类型@RequestMapping(value = "/home",method = RequestMethod.GET)public String Home(){return "Hello Word";}@RequestMapping(value = "/getConfig")public String getConfig() {return "获取的配置信息 :" +" name=" + name +" address=" + address +" , company=" + company;}}放到单独的配置类中读取：package im.homeapi.entity;import org.springframework.beans.factory.annotation.Value;import ponent;@Componentpublic class UserConfig {@Value("${user.address}")private String address;@Value("${pany}")private String company;public String getAddress() {return address;}public void setAddress(String address) {this.address = address;}public String getCompany() {return company;public void setCompany(String company) {pany = company;}public String getName() {return name;}public void setName(String name) { = name;}@Value("${}")private String name;}调⽤如下：@Autowiredprivate UserConfig userConfig;//读取配置类@RequestMapping(value = "/getConfigEntity")public String getConfigEntity() {return "获取的配置信息 :" +" name=" + userConfig.getName() +" address=" + userConfig.getAddress() +" , company=" + userConfig.getCompany();}运⾏结果如下：2、使⽤@ConfigurationProperties注解读取⽅式代码如下：package im.homeapi.entity;import org.springframework.boot.context.properties.ConfigurationProperties; import ponent;@Component@ConfigurationProperties(prefix = "user")public class UserConfig1 {private String address;private String company;private String name;public String getAddress() {return address;}public void setAddress(String address) {this.address = address;}public String getCompany() {return company;}public void setCompany(String company) {pany = company;}public String getName() {return name;public void setName(String name) { = name;}}调⽤：package im.homeapi.controller;import erConfig;import erConfig1;import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; import org.omg.CORBA.PUBLIC_MEMBER;import org.springframework.web.bind.annotation.RestController; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; @RestController@RequestMapping(value="/api")public class ConfigController {@Autowiredprivate UserConfig1 userConfig;//读取配置类 ConfigurationProperties注解读取⽅式@RequestMapping(value = "/getConfigEntity1")public String getConfigEntity() {return "获取的配置信息 :" +" name=" + userConfig.getName() +" address=" + userConfig.getAddress() +" , company=" + userConfig.getCompany();}}运⾏结果：3、读取指定⽂件3.1、@PropertySource+@Value注解读取⽅式在resources下新建配置config/db-config.properties注意：@PropertySource不⽀持yml⽂件读取。

读取properties四种方式

读取properties四种⽅式前⾔在项⽬开发中经常会⽤到配置⽂件，配置⽂件的存在解决了很⼤⼀份重复的⼯作。

今天就分享四种在Springboot中获取配置⽂件的⽅式。

注：前三种测试配置⽂件为springboot默认的application.properties⽂件[html]1. #######################⽅式⼀#########################2. com.battle.type3=Springboot - @ConfigurationProperties3. com.battle.title3=使⽤@ConfigurationProperties获取配置⽂件4. #map5. com.battle.login[username]=admin6. com.battle.login[password]=1234567. com.battle.login[callback]=8. #list9. com.battle.urls[0]=10. com.battle.urls[1]=/format/js11. com.battle.urls[2]=/str2image12. com.battle.urls[3]=/json2Entity13. com.battle.urls[4]=/ua14.15. #######################⽅式⼆#########################16. com.battle.type=Springboot - @Value17. com.battle.title=使⽤@Value获取配置⽂件18.19. #######################⽅式三#########################20. com.battle.type2=Springboot - Environment21. com.battle.title2=使⽤Environment获取配置⽂件⼀、@ConfigurationProperties⽅式⾃定义配置类：PropertiesConfig.java[java]1. import java.io.UnsupportedEncodingException;2. import java.util.ArrayList;3. import java.util.HashMap;4. import java.util.List;5. import java.util.Map;6. import org.springframework.boot.context.properties.ConfigurationProperties;7. //import org.springframework.context.annotation.PropertySource;8. import ponent;9. /**10. * 对应上⽅配置⽂件中的第⼀段配置11. * @author battle12. * @date 2017年6⽉1⽇下午4:34:1813. * @version V1.014. * @since JDK ： 1.7 */15. @Component16. @ConfigurationProperties(prefix = "com.zyd")17. // PropertySource默认取application.properties18. // @PropertySource(value = "config.properties")19. public class PropertiesConfig {20. public String type3; public String title3;21. public Map<String, String> login = new HashMap<String, String>();22. public List<String> urls = new ArrayList<>();23. public String getType3() {24. return type3;25. }26. public void setType3(String type3) {27. this.type3 = type3;28. }29. public String getTitle3() {30. try {31. return new String(title3.getBytes("ISO-8859-1"), "UTF-8");32. } catch (UnsupportedEncodingException e) {33. e.printStackTrace();34. }35. return title3;36. }37. public void setTitle3(String title3) {38. this.title3 = title3;39. }40. public Map<String, String> getLogin() { return login; }41. public void setLogin(Map<String, String> login) { this.login = login; }42. public List<String> getUrls() { return urls; }43. public void setUrls(List<String> urls) { this.urls = urls; } }程序启动类：Applaction.java[java]1. import java.io.UnsupportedEncodingException;2. import java.util.HashMap;3. import java.util.Map;4. import org.springframework.beans.factory.annotation.Autowired;5. import org.springframework.boot.SpringApplication;6. import org.springframework.boot.autoconfigure.SpringBootApplication;7. import org.springframework.web.bind.annotation.RequestMapping;8. import org.springframework.web.bind.annotation.RestController;9. import com.zyd.property.config.PropertiesConfig;10. @SpringBootApplication11. @RestController12. public class Applaction {13. @Autowired private PropertiesConfig propertiesConfig;14. /**15. * 第⼀种⽅式：使⽤`@ConfigurationProperties`注解将配置⽂件属性注⼊到配置对象类中16. * @throws UnsupportedEncodingException17. * @since JDK 1.7 */18. @RequestMapping( "/config" ) public Map<String, Object> configurationProperties()19. {20. Map<String, Object> map = new HashMap<String, Object>();21. map.put( "type", propertiesConfig.getType3() );22. map.put( "title", propertiesConfig.getTitle3() );23. map.put( "login", propertiesConfig.getLogin() );24. map.put( "urls", propertiesConfig.getUrls() );25. return(map);26. }27. public static void main( String[] args ) throws Exception28. {29. SpringApplication application = new SpringApplication( Applaction.class );30. application.run( args );31. }32. }访问结果：{"title":"使⽤@ConfigurationProperties获取配置⽂件","urls":["","/format/js","/str2image","/json2Entity","/ua"],"login":{"username":"admin","callback":"","password":"123456"},"type":"Springboot - @ConfigurationProperties"}⼆、使⽤@Value注解⽅式程序启动类：Applaction.java[java]1. import java.io.UnsupportedEncodingException;2. import java.util.HashMap;3. import java.util.Map;4. import org.springframework.beans.factory.annotation.Value;5. import org.springframework.boot.SpringApplication;6. import org.springframework.boot.autoconfigure.SpringBootApplication;7. import org.springframework.web.bind.annotation.RequestMapping;8. import org.springframework.web.bind.annotation.RestController;9. @SpringBootApplication10. @RestController11. public class Applaction {12. @Value("${com.zyd.type}") private String type;13. @Value("${com.zyd.title}") private String title;14. /** * * 第⼆种⽅式：使⽤`@Value("${propertyName}")`注解 *15. * @throws UnsupportedEncodingException * @since JDK 1.7 */16. @RequestMapping("/value") public Map<String, Object> value() throws UnsupportedEncodingException {17. Map<String, Object> map = new HashMap<String, Object>();18. map.put("type", type);19. // *.properties⽂件中的中⽂默认以ISO-8859-1⽅式编码，因此需要对中⽂内容进⾏重新编码20. map.put("title", new String(title.getBytes("ISO-8859-1"), "UTF-8"));21. return map;22. }23. public static void main(String[] args) throws Exception {24. SpringApplication application = new SpringApplication(Applaction.class);25. application.run(args);26. } }访问结果：{"title":"使⽤@Value获取配置⽂件","type":"Springboot - @Value"}三、使⽤Environment程序启动类：Applaction.java[java]1. import java.io.UnsupportedEncodingException;2. import java.util.HashMap;3. import java.util.Map;4. import org.springframework.beans.factory.annotation.Autowired;5. import org.springframework.boot.SpringApplication;6. import org.springframework.boot.autoconfigure.SpringBootApplication;7. import org.springframework.core.env.Environment;8. import org.springframework.web.bind.annotation.RequestMapping;9. import org.springframework.web.bind.annotation.RestController;10.11. @SpringBootApplication12. @RestController13. public class Applaction {14. @Autowired private Environment env;15. /** * * 第三种⽅式：使⽤`Environment` * * @author zyd * @throws UnsupportedEncodingException * @since JDK 1.7 */16. @RequestMapping("/env") public Map<String, Object> env() throws UnsupportedEncodingException {17. Map<String, Object> map = new HashMap<String, Object>();18. map.put("type", env.getProperty("com.zyd.type2"));19. map.put("title", new String(env.getProperty("com.zyd.title2").getBytes("ISO-8859-1"), "UTF-8"));20. return map;21. }22. public static void main(String[] args) throws Exception {23. SpringApplication application = new SpringApplication(Applaction.class);24. application.run(args);25. }26. }访问结果：{"title":"使⽤Environment获取配置⽂件","type":"Springboot - Environment"}四、使⽤PropertiesLoaderUtilsapp-config.properties[html]1. #### 通过注册监听器(`Listeners`) + `PropertiesLoaderUtils`的⽅式2. com.battle.type=Springboot - Listeners3. com.battle.title=使⽤Listeners + PropertiesLoaderUtils获取配置⽂件4. =zyd5. com.battle.address=Beijing6. pany=inPropertiesListener.java ⽤来初始化加载配置⽂件[java]1. import org.springframework.boot.context.event.ApplicationStartedEvent;2. import org.springframework.context.ApplicationListener;3. import com.zyd.property.config.PropertiesListenerConfig;4. public class PropertiesListener implements ApplicationListener<ApplicationStartedEvent> {5. private String propertyFileName;6. public PropertiesListener(String propertyFileName) {7. this.propertyFileName = propertyFileName;8. }9. @Override public void onApplicationEvent(ApplicationStartedEvent event) {10. PropertiesListenerConfig.loadAllProperties(propertyFileName);11. }12. }PropertiesListenerConfig.java 加载配置⽂件内容[java]1. import org.springframework.boot.context.event.ApplicationStartedEvent;2. import org.springframework.context.ApplicationListener;3. import com.zyd.property.config.PropertiesListenerConfig;4. public class PropertiesListener implements ApplicationListener<ApplicationStartedEvent> {5. private String propertyFileName;6. public PropertiesListener(String propertyFileName) {7. this.propertyFileName = propertyFileName;8. }9. @Override public void onApplicationEvent(ApplicationStartedEvent event) {10. PropertiesListenerConfig.loadAllProperties(propertyFileName);11. }12. }Applaction.java 启动类[java]1. import java.io.UnsupportedEncodingException;2. import java.util.HashMap;3. import java.util.Map;4. import org.springframework.boot.SpringApplication;5. import org.springframework.boot.autoconfigure.SpringBootApplication;6. import org.springframework.web.bind.annotation.RequestMapping;7. import org.springframework.web.bind.annotation.RestController;8. import com.zyd.property.config.PropertiesListenerConfig;9. import com.zyd.property.listener.PropertiesListener;10.11. @SpringBootApplication @RestController public class Applaction {12. /** * * 第四种⽅式：通过注册监听器(`Listeners`) + `PropertiesLoaderUtils`的⽅式 * * @author zyd * @throws UnsupportedEncodingException * @since JDK 1.7 */13. @RequestMapping("/listener") public Map<String, Object> listener() {14. Map<String, Object> map = new HashMap<String, Object>();15. map.putAll(PropertiesListenerConfig.getAllProperty());16. return map;17. }18. public static void main(String[] args) throws Exception {19. SpringApplication application = new SpringApplication(Applaction.class);20. // 第四种⽅式：注册监听器 application.addListeners(new PropertiesListener("app-config.properties")); application.run(args); } } 访问结果：[java]1. {"":"zyd",2. "com.battle.address":"Beijing",3. "com.battle.title":"使⽤Listeners + PropertiesLoaderUtils获取配置⽂件",4. "com.battle.type":"Springboot - Listeners",5. "pany":"in"}。

Springboot从配置文件properties读取字符串乱码的解决

Springboot从配置⽂件properties读取字符串乱码的解决⽬录从配置⽂件properties读取字符串乱码⽅式⼀⽅法⼆properties⽂件的属性值为中⽂，读取时乱码把属性值直接转成unicode编码在⽅法中转码从配置⽂件properties读取字符串乱码当读取properties的内容为：发现中⽂乱码。

原因是由于默认读取的为ISO-8859-1格式，因此需要切换为UTF-8。

主要⽅式有如下两种：⽅式⼀在你的application.properties中增加如下配置，避免中⽂乱码spring.http.encoding.enabled=true⽅法⼆在你的settings⾥⾯的File Encodings进⾏更改为如图1.1 中红框。

图1.1properties⽂件的属性值为中⽂，读取时乱码我们在开发中使⽤properties⽂件时，常会遇到这样的问题，⽐如说：test.property.value=中⽂值我们想把属性值设置成中⽂，这样⽆论使⽤@value还是直接读取出来会出现乱码，总结了两种解决⽅案如下：把属性值直接转成unicode编码写在⽂件中，如：test.property.value.unicode=\u4e2d\u6587\u503c在⽅法中转码如下⾯代码中的getChinese()⽅法package com.xiaobai.util;import lombok.extern.slf4j.Slf4j;import java.io.UnsupportedEncodingException;import java.util.PropertyResourceBundle;import java.util.ResourceBundle;@Slf4jpublic class PropertiesUtil {protected static ResourceBundle erpResponse;protected static final String PROPERTIES_FILE = "propertytest";static {try {erpResponse = PropertyResourceBundle.getBundle(PROPERTIES_FILE);} catch (Exception e) {log.error(PROPERTIES_FILE + "配置⽂件加载失败。

Spring中@Value读取properties作为map或list的操作

Spring中@Value读取properties作为map或list的操作Spring读取properties作为map:properties⽂件中:blog-top-links={home:"/home"}blog-list=1,2,3map的写法和json差不多，但是应该不⽀持嵌套，没有尝试。

key加不加引号都可以,value加双引号单引号都可以，但是当key中有”-“时就必须加引号,例如key为:about-me时,就必须加引号否则解析失败list的写法和数组差不多，可以⾃定义分隔符，在java中分割即可配置类中:@Component@ConfigurationProperties@PropertySource("properties⽂件路径")public class BlogConfig {@Value("#{${blog-top-links}}")private Map<String, String> topLinks;@Value("#{'${blog-list}'.split(',')}")private List<Integer> list;...省略get/set实际不能省略,否则虽然能启动不报错，但是⽆法获取到值}获取map的⽅法:@Value("#{${blog-top-links}}")使⽤#{${key}}的⽅式获取list的⽅法:@Value("#{'${blog-list}'.split(',')}")使⽤@Value(“#{‘${key}'.split(‘,')}”)的⽅式split(‘,')只以','为分隔符,也可以换成别的当配置⽂件中没有key时，也可以使⽤key:default_value的⽅法设置默认值@Value注⼊map、Listyaml格式@Value("#{'${list}'.split(',')}")private List<String> list;@Value("#{${maps}}")private Map<String,String> maps;@Value("#{${redirectUrl}}")private Map<String,String> redirectUrl;配置⽂件list: topic1,topic2,topic3maps: "{key1: 'value1', key2: 'value2'}"redirectUrl: "{sso_client_id: '${id}',sso_client_secret: '${secret}',redirect_url: '${client.main.url.default}'}"注意上⾯的map解析中，⼀定要⽤"“把map所对应的value包起来，要不然解析会失败，导致不能转成 Map<String,String>因为yaml语法中如果⼀个值以 “{” 开头, YAML 将认为它是⼀个字典, 所以我们必须引⽤它必须⽤”" yaml写法注意：字符串默认不⽤加上单引号或者双引号“”：双引号；不会转义字符串⾥⾯的特殊字符；特殊字符会作为本⾝想表⽰的意思name: “zhangsan \n lisi”：输出；zhangsan 换⾏ lisi‘'：单引号；会转义特殊字符，特殊字符最终只是⼀个普通的字符串数据name: ‘zhangsan \n lisi'：输出；zhangsan \n lisiproperties格式以上为个⼈经验，希望能给⼤家⼀个参考，也希望⼤家多多⽀持。

spring无法读取properties文件数据问题详解

spring⽆法读取properties⽂件数据问题详解1. controller中⽆法读取config.properties⽂件controller中注⼊的@Value配置是从servlet-context.xml配置⽂件中获取的；service中注⼊的@Value配置可以从applicationContext.xml中获取的。

所以，如果要在controller中注⼊属性配置，需要在相应servlet⽂件中添加配置，同applicationContext.xml中⼀样。

<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"><property name="locations"><list><value>classpath:jdbc.properties</value><value>classpath:config.properties</value></list></property><property name="ignoreUnresolvablePlaceholders" value="true"/></bean>2.service中⽆法读取config.properties⽂件查看配置⽂件是否有多个。

如果配置的路径是classpath:config.properties, ⿏标点击⽂件。

如果显⽰”multiple implementations”, 表⽰有多个⽂件，查看其他的⽂件中是否有需要的配置项，没有的话，很可能就是加载了其他⽂件的配置项。

这时，将路径改为classpath*:config.properties即可。

Spring配置文件读取引用properties文件的值

Spring配置⽂件读取引⽤properties⽂件的值使⽤Spring提供的 org.springframework.beans.factory.config.PropertyPlaceholderConfigurer可以引⼊properties⽂件，并且在Spring配置⽂件的其他部分⽤${}引⽤其中的值。

1：创建cfgs.properties⽂件1 #hibernate.dialect=org.hibernate.dialect.MySQLDialect2 hibernate.dialect=org.hibernate.dialect.Oracle10gDialect3 hibernate.show_sql=true4 hibernate.hbm2ddl.auto=update5 hibernate.connection.release_mode=after_transaction6 hibernate.transaction.factory_class=org.hibernate.transaction.JDBCTransactionFactory7 hibernate.generate_statistics=true8 hibernate.validation.mode=none2.在Spring配置⽂件中导⼊该⽂件。

1<bean2class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">3<property name="locations">4<list>56<value>c lasspath:cfgs.properties</value>7</list>8</property>9</bean>3：这样就可以在Spring配置⽂件中通过${}调⽤cfgs.properties中的值1<property name="hibernateProperties">2<props>3<prop key="hibernate.dialect">${hibernate.dialect}</prop>4<prop key="hibernate.jdbc.batch_size">20</prop>5<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>6<prop key="hibernate.format_sql">true</prop>7<prop key="hibernate.connection.isolation">2</prop>8<prop key="e_streams_for_binary">true</prop>9<prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>10<prop key="hibernate.connection.release_mode">${hibernate.connection.release_mode}</prop>11<prop key="hibernate.current_session_context_class">thread</prop>12<prop key="hibernate.transaction.factory_class">${hibernate.transaction.factory_class}</prop>13<prop key="hibernate.generate_statistics">${hibernate.generate_statistics}</prop>14<prop key="javax.persistence.validation.mode">${hibernate.validation.mode}</prop>15<prop key="hibernate.cache.provider_class">com.opensymphony.oscache.hibernate.OSCacheProvider16</prop>1718</props>19</property>4：使⽤org.springframework.beans.factory.config.PropertyOverrideConfigurer可以⽤properties⽂件中的值覆盖spring中定义的bean的property值。

spring使用@Value注解读取.properties文件时出现中文乱码问题的解决

spring使⽤@Value注解读取.properties⽂件时出现中⽂乱码问题的解决解决办法在spring中我们常常使⽤.properties对⼀些属性进⾏⼀个提前配置, spring 在读取*.properties⽂件时,默认使⽤的是asci码, 这时我们需要对其编码进⾏转换. 下⾯列举两种常见的⽅法。

⽅法⼀：在配置spring.xml⽂件时,声明所需的∗.properties⽂件时直接使⽤"utf−8"编码<context:property-placeholder location="classpath:conf/*.properties"file-encoding="UTF-8"/>⽅法⼆：如果在所需类上注⼊可使⽤以下⽅式来声明编码格式:@Component@PropertySource(value = "classpath:conf/copyWriteUI.properties",encoding = "utf-8")@Getterpublic class CopyWriteUI {@Value("${a}")private String a;@Value("${b}")private String b;}附录 spring <context:property-placeholder/>的属性说明<context:property-placeholderlocation="属性⽂件，多个之间逗号分隔"file-encoding="⽂件编码"ignore-resource-not-found="是否忽略找不到的属性⽂件"ignore-unresolvable="是否忽略解析不到的属性，如果不忽略，找不到将抛出异常"properties-ref="本地Properties配置"local-override="是否本地覆盖模式，即如果true，那么properties-ref的属性将覆盖location加载的属性，否则相反"system-properties-mode="系统属性模式，默认ENVIRONMENT（表⽰先找ENVIRONMENT，再找properties-ref/location的），NEVER：表⽰永远不⽤ENVIRONMENT的，OVERRIDE类似于ENVIRONMENT" order="顺序"/>。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

spring 框架的xml文件如何读取properties文件数据
第一步：在spring配置文件中
注意：value可以多配置几个properties文件
<bean id="propertyConfigurer"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<value>/db.properties</value>
</list>
</property>
</bean>
第二步：
在src目录下面建立db.properties文件
user=sa
password=sa
driver=com.microsoft.sqlserver.jdbc.SQLServerDriver
url=jdbc:sqlserver://localhost:1433;databaseName=DB1
第三步：
在spring的配置文件中通过EL表达式的形式调用
${user}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="/schema/beans"
xmlns:xsi="/2001/XMLSchema-instance"
xsi:schemaLocation="/schema/beans
/schema/beans/spring-beans-2.0.xsd">
<bean id="propertyConfigurer"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<value>/db.properties</value>
</list>
</property>
</bean>
<bean id="datasource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName"
value="${driver}">
</property>
<property name="url"
value="${url}">
</property>
<property name="username" value="${user}"></property>
<property name="password" value="${password}"></property> </bean>
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref bean="datasource" />
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">
org.hibernate.dialect.SQLServerDialect
</prop>
</props>
</property>
<property name="mappingResources">
<list>
<value>entity/Users.hbm.xml</value>
</list>
</property>
</bean>
<bean id="UsersDAO" class="ersDAO">
<property name="sessionFactory">
<ref bean="sessionFactory" />
</property>
</bean>
</beans>。