Używam wiosny. Muszę odczytać wartości z pliku właściwości. To jest wewnętrzny plik właściwości, a nie zewnętrzny plik właściwości. Plik właściwości może wyglądać jak poniżej.
some.properties ---file name. values are below.
abc = abc
def = dsd
ghi = weds
jil = sdd
Muszę odczytać te wartości z pliku właściwości, a nie w tradycyjny sposób. Jak to osiągnąć? Czy jest jakieś najnowsze podejście do wiosny 3.0?
Odpowiedzi:
Skonfiguruj PropertyPlaceholder w swoim kontekście:
<context:property-placeholder location="classpath*:my.properties"/>
Następnie odwołujesz się do właściwości swoich ziaren:
@Component
class MyClass {
@Value("${my.property.name}")
private String[] myValues;
}
EDYCJA: zaktualizowano kod, aby parsował właściwość z wieloma wartościami oddzielonymi przecinkami:
my.property.name=aaa,bbb,ccc
Jeśli to nie zadziała, możesz zdefiniować ziarno z właściwościami, wstrzyknąć i przetworzyć go ręcznie:
<bean id="myProperties"
class="org.springframework.beans.factory.config.PropertiesFactoryBean">
<property name="locations">
<list>
<value>classpath*:my.properties</value>
</list>
</property>
</bean>
i fasola:
@Component
class MyClass {
@Resource(name="myProperties")
private Properties myProperties;
@PostConstruct
public void init() {
// do whatever you need with properties
}
}
aaa? Czy to @Value(${aaa}) private String aaa;wtedy możemy System.out.println(aaa)???????
@Value("${aaa}"), zwróć uwagę na cytaty. I tak, możesz go wydrukować, ale nie w konstruktorze, ponieważ konstruktor jest wykonywany przed wstrzyknięciem wartości.
Jest wiele sposobów na osiągnięcie tego samego. Poniżej znajduje się kilka powszechnie używanych sposobów na wiosnę:
Korzystanie z PropertyPlaceholderConfigurer
Korzystanie z PropertySource
Korzystanie z ResourceBundleMessageSource
Korzystanie z PropertiesFactoryBean
i wiele więcej........................
Zakładając, że ds.typejest to kluczowe w pliku nieruchomości.
Za pomocą PropertyPlaceholderConfigurer
Zarejestruj PropertyPlaceholderConfigurerfasolę-
<context:property-placeholder location="classpath:path/filename.properties"/>
lub
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations" value="classpath:path/filename.properties" ></property>
</bean>
lub
@Configuration
public class SampleConfig {
@Bean
public static PropertySourcesPlaceholderConfigurer placeHolderConfigurer() {
return new PropertySourcesPlaceholderConfigurer();
//set locations as well.
}
}
Po rejestracji PropertySourcesPlaceholderConfigurermożesz uzyskać dostęp do wartości-
@Value("${ds.type}")private String attr;
Za pomocą PropertySource
W najnowszej wersji wiosennej nie trzeba zarejestrować PropertyPlaceHolderConfigurersię @PropertySource, znalazłem dobrą odnośnik do zrozumienia wersji compatibility-
@PropertySource("classpath:path/filename.properties")
@Component
public class BeanTester {
@Autowired Environment environment;
public void execute() {
String attr = this.environment.getProperty("ds.type");
}
}
Za pomocą ResourceBundleMessageSource
Zarejestruj Bean-
<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basenames">
<list>
<value>classpath:path/filename.properties</value>
</list>
</property>
</bean>
Wartość dostępu
((ApplicationContext)context).getMessage("ds.type", null, null);
lub
@Component
public class BeanTester {
@Autowired MessageSource messageSource;
public void execute() {
String attr = this.messageSource.getMessage("ds.type", null, null);
}
}
Za pomocą PropertiesFactoryBean
Zarejestruj Bean-
<bean id="properties"
class="org.springframework.beans.factory.config.PropertiesFactoryBean">
<property name="locations">
<list>
<value>classpath:path/filename.properties</value>
</list>
</property>
</bean>
Podłącz instancję Properties do swojej klasy
@Component
public class BeanTester {
@Autowired Properties properties;
public void execute() {
String attr = properties.getProperty("ds.type");
}
}
W klasie konfiguracji
@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;
}
}
app.propertiesw testowaniu produkcyjnym? Innymi słowy, czy częścią procesu wdrażania byłoby zastąpienie app.propertieswartościami produkcyjnymi?
Oto dodatkowa odpowiedź, która również była dla mnie bardzo pomocna, aby zrozumieć, jak to działa: http://www.javacodegeeks.com/2013/07/spring-bean-and-propertyplaceholderconfigurer.html
wszystkie ziarna BeanFactoryPostProcessor muszą być zadeklarowane ze statycznym modyfikatorem
@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();
}
}
@PropertySource.
Jeśli chcesz ręcznie odczytać plik właściwości bez użycia @Value.
Dzięki za dobrze napisaną stronę przez Lokesh Gupta: Blog
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;
}
}
Musisz umieścić komponent bean PropertyPlaceholderConfigurer w kontekście aplikacji i ustawić jego właściwość lokalizacji.
Zobacz szczegóły tutaj: http://www.zparacha.com/how-to-read-properties-file-in-spring/
Być może będziesz musiał nieco zmodyfikować plik właściwości, aby to zadziałało.
Mam nadzieję, że to pomoże.
Innym sposobem jest użycie ResourceBundle . Zasadniczo otrzymujesz pakiet, używając jego nazwy bez „.properties”
private static final ResourceBundle resource = ResourceBundle.getBundle("config");
I odzyskasz każdą wartość, używając tego:
private final String prop = resource.getString("propName");
[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>
Polecam przeczytanie tego linku https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html z dokumentacji SpringBoot na temat wstrzykiwania zewnętrznych konfiguracji. Rozmawiali nie tylko o pobieraniu z pliku właściwości, ale także o plikach YAML, a nawet JSON. Uważam, że to pomocne. Mam nadzieję, że Ty też.
Chciałem klasę użytkową, który nie jest zarządzany przez wiosnę, więc nie ma adnotacji wiosny podoba @Component, @Configurationitd. Ale chciałem klasę odczytu zapplication.properties
Udało mi się to sprawić, aby klasa była świadoma kontekstu sprężyny, stąd jest świadoma Environmenti dlatego environment.getProperty()działa zgodnie z oczekiwaniami.
Mówiąc wprost, mam:
application.properties
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 (zobacz Spring, aby pobrać aktualny 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);
}
}