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?
spring
properties-file
user1016403
źródło
źródło
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 } }
źródło
aaa
? Czy to@Value(${aaa}) private String aaa;
wtedy możemySystem.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.type
jest to kluczowe w pliku nieruchomości.Za pomocą
PropertyPlaceholderConfigurer
Zarejestruj
PropertyPlaceholderConfigurer
fasolę-<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
PropertySourcesPlaceholderConfigurer
możesz uzyskać dostęp do wartości-@Value("${ds.type}")private String attr;
Za pomocą
PropertySource
W najnowszej wersji wiosennej nie trzeba zarejestrować
PropertyPlaceHolderConfigurer
się@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"); } }
źródło
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; } }
źródło
app.properties
w testowaniu produkcyjnym? Innymi słowy, czy częścią procesu wdrażania byłoby zastąpienieapp.properties
wartoś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
@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(); } }
źródło
PropertySourcesPlaceholderConfigurer
Beana na@PropertySource
@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; } }
źródło
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.
źródło
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");
źródło
[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>
źródło
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ż.
źródło
Chciałem klasę użytkową, który nie jest zarządzany przez wiosnę, więc nie ma adnotacji wiosny podoba
@Component
,@Configuration
itd. 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
Environment
i dlategoenvironment.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); } }
źródło