我正在使用弹簧。我需要从属性文件中读取值。这是内部属性文件而不是外部属性文件。属性文件可以如下。
some.properties ---file name. values are below.
abc = abc
def = dsd
ghi = weds
jil = sdd
我需要不以传统方式从属性文件中读取这些值。如何实现?spring 3.0 有什么最新的方法吗?
我正在使用弹簧。我需要从属性文件中读取值。这是内部属性文件而不是外部属性文件。属性文件可以如下。
some.properties ---file name. values are below.
abc = abc
def = dsd
ghi = weds
jil = sdd
我需要不以传统方式从属性文件中读取这些值。如何实现?spring 3.0 有什么最新的方法吗?
在您的上下文中配置 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
}
}
有多种方法可以实现相同的目标。下面是一些spring中常用的方式——
使用 PropertyPlaceholderConfigurer
使用 PropertySource
使用 ResourceBundleMessageSource
使用 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
在你不需要注册的最新spring版本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");
}
}
在配置类
@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 都必须使用static修饰符声明
@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();
}
}
如果您需要在不使用@Value 的情况下手动读取属性文件。
感谢 Lokesh Gupta 撰写的精彩页面:博客
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;
}
}
另一种方法是使用ResourceBundle。基本上,您使用它的名称获取捆绑包,而不使用“.properties”
private static final ResourceBundle resource = ResourceBundle.getBundle("config");
您可以使用以下方法恢复任何价值:
private final String prop = resource.getString("propName");
您需要在应用程序上下文中放置一个 PropertyPlaceholderConfigurer bean 并设置其位置属性。
在此处查看详细信息:http ://www.zparacha.com/how-to-read-properties-file-in-spring/
您可能需要稍微修改您的属性文件才能使这个东西起作用。
希望能帮助到你。
我想要一个不由 spring 管理的实用程序类,所以没有 spring 注释等@Component
。@Configuration
但我希望该类从application.properties
我设法通过让类知道 Spring Context 来让它工作,因此知道Environment
,因此environment.getProperty()
按预期工作。
明确地说,我有:
应用程序属性
mypath=somestring
实用程序.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);
}
}
[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>
我建议阅读SpringBoot 文档中关于注入外部配置的链接https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html 。他们不仅谈论从属性文件中检索,还谈论从 YAML 甚至 JSON 文件中检索。我发现它很有帮助。我希望你也这样做。