如何从属性文件中读取值？

我用的是弹簧。我需要从属性文件中读取值。这是内部属性文件，不是外部属性文件。属性文件可以如下所示。

some.properties ---file name. values are below.


abc = abc
def = dsd
ghi = weds
jil = sdd

我需要不以传统方式从属性文件中读取这些值。如何实现呢？Spring 3.0有什么最新的方案吗？

536885 次浏览
小开

您需要在应用程序上下文中放置 PropertyPlaceholderConfigurerbean 并设置其位置属性。

详情请参阅: http://www.zparacha.com/how-to-read-properties-file-in-spring/

您可能需要稍微修改一下属性文件才能使这个程序工作。

希望能有帮助。

小开
最佳答案

在您的上下文中配置 PropertyPlaceholder:

<context:property-placeholder location="classpath*:my.properties"/>

然后引用 bean 中的属性:

@Component
class MyClass {
@Value("${my.property.name}")
private String[] myValues;
}

用多个逗号分隔值解析属性:

my.property.name=aaa,bbb,ccc

如果这不起作用，你可以用属性定义一个 bean，注入并手动处理它:

<bean id="myProperties"
class="org.springframework.beans.factory.config.PropertiesFactoryBean">
<property name="locations">
<list>
<value>classpath*:my.properties</value>
</list>
</property>
</bean>

还有豆子:

@Component
class MyClass {
@Resource(name="myProperties")
private Properties myProperties;


@PostConstruct
public void init() {
// do whatever you need with properties
}
}
小开

在配置类中

@Configuration
@PropertySource("classpath:/com/myco/app.properties")
public class AppConfig {
@Autowired
Environment env;


@Bean
public TestBean testBean() {
TestBean testBean = new TestBean();
testBean.setName(env.getProperty("testbean.name"));
return testBean;
}
}
小开

这里有一个额外的答案，也是很大的帮助我了解它是如何工作的: http://www.javacodegeeks.com/2013/07/spring-bean-and-propertyplaceholderconfigurer.html

任何 BeanFactoryPostProcessor bean 都必须使用 静电干扰修饰符声明

@Configuration
@PropertySource("classpath:root/test.props")
public class SampleConfig {
@Value("${test.prop}")
private String attr;
@Bean
public SampleService sampleService() {
return new SampleService(attr);
}


@Bean
public static PropertySourcesPlaceholderConfigurer placeHolderConfigurer() {
return new PropertySourcesPlaceholderConfigurer();
}
}
小开 
 [project structure]: http://i.stack.imgur.com/RAGX3.jpg
-------------------------------
package beans;


import java.util.Properties;
import java.util.Set;


public class PropertiesBeans {


private Properties properties;


public void setProperties(Properties properties) {
this.properties = properties;
}


public void getProperty(){
Set keys = properties.keySet();
for (Object key : keys) {
System.out.println(key+" : "+properties.getProperty(key.toString()));
}
}


}
----------------------------


package beans;


import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


public class Test {


public static void main(String[] args) {
// TODO Auto-generated method stub
ApplicationContext ap = new ClassPathXmlApplicationContext("resource/spring.xml");
PropertiesBeans p = (PropertiesBeans)ap.getBean("p");
p.getProperty();
}


}
----------------------------


- driver.properties


Driver = com.mysql.jdbc.Driver
url = jdbc:mysql://localhost:3306/test
username = root
password = root
----------------------------






<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd">


<bean id="p" class="beans.PropertiesBeans">
<property name="properties">
<util:properties location="classpath:resource/driver.properties"/>
</property>
</bean>


</beans>
小开

有很多方法可以达到同样的效果。下面是一些在春天常用的方法

  1. 使用 PropertyPlaceholderConfigrer

  2. 使用 PropertySource

  3. 使用 ResourceBundleMessageSource

  4. 使用 PropertiesFactoryBean

    还有更多..。

假设 ds.type是属性文件中的关键字。

使用 PropertyPlaceholderConfigurer

注册 PropertyPlaceholderConfigurer bean-

<context:property-placeholder location="classpath:path/filename.properties"/>

或者

<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations" value="classpath:path/filename.properties" ></property>
</bean>

或者

@Configuration
public class SampleConfig {
@Bean
public static PropertySourcesPlaceholderConfigurer placeHolderConfigurer() {
return new PropertySourcesPlaceholderConfigurer();
//set locations as well.
}
}

注册 PropertySourcesPlaceholderConfigurer之后，可以访问值-

@Value("${ds.type}")private String attr;

使用 PropertySource

在最新的春季版本，你不需要注册 PropertyPlaceHolderConfigurer与 @PropertySource，我发现一个很好的 链接了解版本兼容性-

@PropertySource("classpath:path/filename.properties")
@Component
public class BeanTester {
@Autowired Environment environment;
public void execute() {
String attr = this.environment.getProperty("ds.type");
}
}

使用 ResourceBundleMessageSource

登记册 Bean-

<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basenames">
<list>
<value>classpath:path/filename.properties</value>
</list>
</property>
</bean>

接达值 -

((ApplicationContext)context).getMessage("ds.type", null, null);

或者

@Component
public class BeanTester {
@Autowired MessageSource messageSource;
public void execute() {
String attr = this.messageSource.getMessage("ds.type", null, null);
}
}

使用 PropertiesFactoryBean

登记册 Bean-

<bean id="properties"
class="org.springframework.beans.factory.config.PropertiesFactoryBean">
<property name="locations">
<list>
<value>classpath:path/filename.properties</value>
</list>
</property>
</bean>

将 Properties 实例连接到您的类-

@Component
public class BeanTester {
@Autowired Properties properties;
public void execute() {
String attr = properties.getProperty("ds.type");
}
}
小开

如果需要在不使用@Value 的情况下手动读取属性文件。

感谢 Lokesh Gupta: 博客写得很好的一页

enter image description here

package utils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.ResourceUtils;


import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import java.io.File;




public class Utils {


private static final Logger LOGGER = LoggerFactory.getLogger(Utils.class.getName());


public static Properties fetchProperties(){
Properties properties = new Properties();
try {
File file = ResourceUtils.getFile("classpath:application.properties");
InputStream in = new FileInputStream(file);
properties.load(in);
} catch (IOException e) {
LOGGER.error(e.getMessage());
}
return properties;
}
}
小开

我建议您阅读 SpringBoot 文档中关于注入外部配置的链接 https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html。他们不仅讨论了从属性文件中检索，还讨论了 YAML 甚至 JSON 文件。我觉得很有帮助。我希望你也是。

小开

另一种方法是使用 资源包

private static final ResourceBundle resource = ResourceBundle.getBundle("config");

你可以用这个恢复任何值:

private final String prop = resource.getString("propName");
小开

我想要一个实用程序类是不管理的春天，所以没有像 @Component，@Configuration等春天注释。但是我想让这个班从 application.properties开始读

我设法让它工作，让类知道 Spring 上下文，因此知道 Environment，因此 environment.getProperty()按预期工作。

明确地说，我有:

应用性能

mypath=somestring

Utils.java

import org.springframework.core.env.Environment;


// No spring annotations here
public class Utils {
public String execute(String cmd) {
// Making the class Spring context aware
ApplicationContextProvider appContext = new ApplicationContextProvider();
Environment env = appContext.getApplicationContext().getEnvironment();


// env.getProperty() works!!!
System.out.println(env.getProperty("mypath"))
}
}

ApplicationContextProvider.java (参见 Spring 获取当前的 ApplicationContext)

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;


@Component
public class ApplicationContextProvider implements ApplicationContextAware {
private static ApplicationContext CONTEXT;


public ApplicationContext getApplicationContext() {
return CONTEXT;
}


public void setApplicationContext(ApplicationContext context) throws BeansException {
CONTEXT = context;
}


public static Object getBean(String beanName) {
return CONTEXT.getBean(beanName);
}
}

提交答案