24 |
25 | ### Example Spring XML Configuration ###
26 | * See [spring-reloadableProperties.xml](https://github.com/jamesemorgan/ReloadablePropertiesAnnotation/blob/master/src/main/resources/spring/spring-reloadableProperties.xml) for example configuration
27 | * All main components can be extended or replaced if required
28 |
29 | ### How it Works ###
30 | When Spring starts an Application Context an implementation of Springs [PropertySourcesPlaceholderConfigurer](http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/context/support/PropertySourcesPlaceholderConfigurer.html) is instantiated to perform additional logic when loading and setting values from a given set of properties files. (see: [ReadablePropertySourcesPlaceholderConfigurer](https://github.com/jamesemorgan/ReloadablePropertiesAnnotation/blob/master/src/main/java/com/morgan/design/properties/internal/ReadablePropertySourcesPlaceholderConfigurer.java))
31 |
32 | During the instantiation phasae of an Application Context a new instance of [InstantiationAwareBeanPostProcessorAdapter](http://static.springsource.org/spring/docs/2.5.x/api/org/springframework/beans/factory/config/InstantiationAwareBeanPostProcessorAdapter.html) is also created which allows post bean processing to occur.
33 |
34 | Google Guava is used to implement a simple Publish & Subscribe (Pub-Sub) Pattern so that beans can be updated once created, i.e. a bean can subscribe to property change events. (see: [EventBus](http://code.google.com/p/guava-libraries/wiki/EventBusExplained))
35 | EventBus was chosen as it is a very easy and simplistic way to implement loosely couple object structure. (see: [blog](http://codingjunkie.net/guava-eventbus/))
36 |
37 | When each properties file resource is loaded a [PropertiesWatcher](https://github.com/jamesemorgan/ReloadablePropertiesAnnotation/blob/master/src/main/java/com/morgan/design/properties/internal/PropertiesWatcher.java) is started and attached to the given resource set, reporting on any [java.nio.file.StandardWatchEventKinds.ENTRY_MODIFY](http://docs.oracle.com/javase/7/docs/api/java/nio/file/StandardWatchEventKinds.html#ENTRY_MODIFY) events from the host operating system
38 |
39 | When an ENTRY_MODIFY event is fired firstly the resource changed is checked for property value changes then any bean subscribing to changes to the modified property has the specified field value updated with the new property. Once the filed value is updated no other operations are performed on the object.
40 |
41 | Each resource specified starts a new thread per parent directory i.e. two properties files in the same directory requires only one ResourceWatcher thread, three properties files in three different directories will start three threads.
42 |
43 | ### Tests ###
44 | A set of integration and unit tests can be found in _src/test/java_ (tests) & _src/test/resources_ (test resources)
45 |
46 | ### TODO (Unfinished) ###
47 | * Update test method names
48 | * Creation of any test utilities or helper classes
49 |
50 | ### Why? ###
51 | * Useful for web applications which often need configuration changes but you don't always want to restart the application before new properties are used.
52 | * Can be used to define several layers of properties which can aid in defining multiple application configurations e.g sandbox/development/testing/production.
53 | * A pet project of mine I have been intending to implement for a while
54 | * A test of the new Java 7 WatchService API
55 | * Another dive in Spring & general investigation of Google Guava's EventBus
56 | * The project is aimed to be open to modification if required
57 | * Sample testing tools (CountDownLatch, Hamcrest-1.3, JMock-2.6.0-RC2)
58 |
59 | ### Future Changes ###
60 | * Ability to use Spring Expression language to map properties files
61 | * Support for Java 7 Date and Time classes
62 | * Include the ability to define a database driven properties source not just properties files
63 | * Implement error recovery inside PropertiesWatcher.class, including better thread recovery
64 | * Ability to perform additional re-bind logic when a property is changed, i.e. if a class has an open DB connection which needs to be re-established using newly set properties.
65 | * Replace callback Properties EventHandler with Guava EventBus
66 | * Ability to configure usage via spring's @Configuration
67 |
68 | ### Contributions ###
69 | * Thank you [normanatashbar](https://github.com/normanatashbar) for adding composite string replacement
70 | * Thank you [shiva2991](https://github.com/normanatashbar) for adding java.util.Date type conversion.
71 |
72 | ### Supported Property Type Conversions Available ###
73 | * LocalDate.class
74 | * LocalTime.class
75 | * LocalDateTime.class
76 | * Period.class
77 |
78 |
79 | * Spring Supported (3.1.2-RELEASE)
80 | * String.class
81 | * Date.class
82 | * boolean.class, Boolean.class
83 | * byte.class, Byte.class
84 | * char.class, Character.class
85 | * short.class, Short.class
86 | * int.class, Integer.class
87 | * long.class,Long.class
88 | * float.class, Float.class
89 | * double.class, Double.class
90 |
91 | ### Dependencies ###
92 |
93 | #### Core ####
94 | * Java 7 SDK
95 | * Spring (3.2.5-RELEASE)
96 | * Google Guava (14.0.1)
97 | * Joda Time Library (2.1) - [link](http://joda-time.sourceforge.net/)
98 |
99 | #### Logging ####
100 | * logback (1.0.13)
101 | * slf4j (1.7.5)
102 |
103 | #### Testing ####
104 | * juint (4.11)
105 | * jmock (2.6.0)
106 | * hamcrest-all (1.3)
107 | * spring-test (3.2.5-RELEASE)
108 |
109 |
110 | [](https://bitdeli.com/free "Bitdeli Badge")
111 |
112 |
--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
1 |
3 | 4.0.0
4 | com.morgan.design
5 | ReloadablePropertiesAnnotation
6 | 0.0.2-SNAPSHOT
7 |
8 |
9 | 3.2.5.RELEASE
10 | 1.0.13
11 |
12 |
13 |
14 |
15 |
16 | com.google.guava
17 | guava
18 | 14.0.1
19 |
20 |
21 | joda-time
22 | joda-time
23 | 2.3
24 |
25 |
26 | org.slf4j
27 | slf4j-api
28 | 1.7.5
29 |
30 |
31 | ch.qos.logback
32 | logback-core
33 | ${logback.version}
34 |
35 |
36 | ch.qos.logback
37 | logback-classic
38 | ${logback.version}
39 |
40 |
41 |
42 |
43 | org.springframework
44 | spring-context
45 | ${spring.version}
46 |
47 |
48 | org.springframework
49 | spring-core
50 | ${spring.version}
51 |
52 |
53 |
54 |
55 | junit
56 | junit
57 | test
58 | 4.11
59 |
60 |
61 | org.hamcrest
62 | hamcrest-all
63 | test
64 | 1.3
65 |
66 |
67 | org.jmock
68 | jmock
69 | 2.6.0
70 | test
71 |
72 |
73 | org.jmock
74 | jmock-legacy
75 | 2.6.0
76 | test
77 |
78 |
79 | org.jmock
80 | jmock-junit4
81 | 2.6.0
82 | test
83 |
84 |
85 | org.springframework
86 | spring-test
87 | ${spring.version}
88 | test
89 |
90 |
91 |
92 |
93 |
94 |
95 |
96 | org.apache.maven.plugins
97 | maven-eclipse-plugin
98 | 2.6
99 |
100 | true
101 | true
102 |
103 |
104 |
105 | org.apache.maven.plugins
106 | maven-clean-plugin
107 | 2.4.1
108 |
109 |
110 | org.apache.maven.plugins
111 | maven-compiler-plugin
112 | 2.3.2
113 |
114 |
115 | compile
116 | compile
117 |
118 | compile
119 |
120 |
121 |
122 | unit-test-compile
123 |
124 | testCompile
125 |
126 |
127 |
128 |
129 | 1.7
130 | 1.7
131 |
132 |
133 |
134 | org.apache.maven.plugins
135 | maven-jar-plugin
136 | 2.4
137 |
138 |
139 | **/logback.xml
140 |
141 |
142 |
143 |
144 |
145 |
146 |
147 |
148 | central
149 | Maven Plugin Repository
150 | http://repo1.maven.org/maven2
151 |
152 | true
153 |
154 |
155 | true
156 |
157 |
158 |
159 |
160 |
161 |
162 |
--------------------------------------------------------------------------------
/src/main/java/com/morgan/design/properties/ReloadableProperty.java:
--------------------------------------------------------------------------------
1 | package com.morgan.design.properties;
2 |
3 | import java.lang.annotation.ElementType;
4 | import java.lang.annotation.Retention;
5 | import java.lang.annotation.RetentionPolicy;
6 | import java.lang.annotation.Target;
7 |
8 | /**
9 | * Marks a field to be set from the given property value, the specified property will reset the field if changed during runtime.
10 | *
11 | * @author James Morgan
12 | */
13 | @Retention(RetentionPolicy.RUNTIME)
14 | @Target(ElementType.FIELD)
15 | public @interface ReloadableProperty {
16 |
17 | String value();
18 |
19 | }
20 |
--------------------------------------------------------------------------------
/src/main/java/com/morgan/design/properties/bean/BeanPropertyHolder.java:
--------------------------------------------------------------------------------
1 | package com.morgan.design.properties.bean;
2 |
3 | import java.lang.reflect.Field;
4 |
5 | import com.google.common.base.Objects;
6 |
7 | public class BeanPropertyHolder {
8 |
9 | private final Object bean;
10 | private final Field field;
11 |
12 | public BeanPropertyHolder(Object bean, Field field) {
13 | this.bean = bean;
14 | this.field = field;
15 | }
16 |
17 | public Object getBean() {
18 | return this.bean;
19 | }
20 |
21 | public Field getField() {
22 | return this.field;
23 | }
24 |
25 | @Override
26 | public int hashCode() {
27 | return Objects.hashCode(this.bean, this.field);
28 | }
29 |
30 | @Override
31 | public boolean equals(Object object) {
32 | if (object instanceof BeanPropertyHolder) {
33 | BeanPropertyHolder that = (BeanPropertyHolder) object;
34 | return Objects.equal(this.bean, that.bean) && Objects.equal(this.field, that.field);
35 | }
36 | return false;
37 | }
38 |
39 | @Override
40 | public String toString() {
41 | return Objects.toStringHelper(this)
42 | .add("bean", this.bean)
43 | .add("field", this.field)
44 | .toString();
45 | }
46 |
47 | }
48 |
--------------------------------------------------------------------------------
/src/main/java/com/morgan/design/properties/bean/PropertyModifiedEvent.java:
--------------------------------------------------------------------------------
1 | package com.morgan.design.properties.bean;
2 |
3 | import com.google.common.base.Objects;
4 |
5 | public class PropertyModifiedEvent {
6 |
7 | private final String propertyName;
8 | private final Object oldValue;
9 | private final Object newValue;
10 |
11 | public PropertyModifiedEvent(final String propertyName, final Object oldValue, final Object newValue) {
12 | this.propertyName = propertyName;
13 | this.oldValue = oldValue;
14 | this.newValue = newValue;
15 | }
16 |
17 | public String getPropertyName() {
18 | return this.propertyName;
19 | }
20 |
21 | public Object getOldValue() {
22 | return this.oldValue;
23 | }
24 |
25 | public Object getNewValue() {
26 | return this.newValue;
27 | }
28 | @Override
29 | public int hashCode() {
30 | return Objects.hashCode(this.propertyName, this.oldValue, this.newValue);
31 | }
32 |
33 | @Override
34 | public boolean equals(final Object object) {
35 | if (object instanceof PropertyModifiedEvent) {
36 | final PropertyModifiedEvent that = (PropertyModifiedEvent) object;
37 | return Objects.equal(this.propertyName, that.propertyName) && Objects.equal(this.oldValue, that.oldValue)
38 | && Objects.equal(this.newValue, that.newValue);
39 | }
40 | return false;
41 | }
42 |
43 | @Override
44 | public String toString() {
45 | return Objects.toStringHelper(this)
46 | .add("propertyName", this.propertyName)
47 | .add("oldValue", this.oldValue)
48 | .add("newValue", this.newValue)
49 | .toString();
50 | }
51 |
52 | }
53 |
--------------------------------------------------------------------------------
/src/main/java/com/morgan/design/properties/conversion/CustomEditorsRegistrar.java:
--------------------------------------------------------------------------------
1 | package com.morgan.design.properties.conversion;
2 |
3 | import java.beans.PropertyEditor;
4 | import java.util.Map;
5 |
6 | import org.springframework.beans.PropertyEditorRegistrar;
7 | import org.springframework.beans.PropertyEditorRegistry;
8 |
9 | public class CustomEditorsRegistrar implements PropertyEditorRegistrar {
10 |
11 | private Map, PropertyEditor> extraEditors;
12 |
13 | public CustomEditorsRegistrar(Map, PropertyEditor> extraEditors)
14 | {
15 | this.extraEditors = extraEditors;
16 | }
17 |
18 | @Override
19 | public void registerCustomEditors(PropertyEditorRegistry registry) {
20 | for (Map.Entry, PropertyEditor> entry : extraEditors.entrySet()) {
21 | registry.registerCustomEditor(entry.getKey(), entry.getValue());
22 | }
23 | }
24 |
25 | }
26 |
--------------------------------------------------------------------------------
/src/main/java/com/morgan/design/properties/conversion/DefaultPropertyConversionService.java:
--------------------------------------------------------------------------------
1 | package com.morgan.design.properties.conversion;
2 |
3 | import java.lang.reflect.Field;
4 | import java.util.Map;
5 |
6 | import javax.annotation.PostConstruct;
7 |
8 | import org.joda.time.LocalDate;
9 | import org.joda.time.LocalDateTime;
10 | import org.joda.time.LocalTime;
11 | import org.joda.time.Period;
12 | import org.springframework.beans.SimpleTypeConverter;
13 | import org.springframework.beans.TypeConverter;
14 | import org.springframework.beans.factory.BeanInitializationException;
15 | import org.springframework.beans.factory.annotation.Autowired;
16 | import org.springframework.beans.factory.config.ConfigurableBeanFactory;
17 | import org.springframework.stereotype.Component;
18 |
19 | import com.google.common.base.Function;
20 | import com.google.common.base.Functions;
21 | import com.google.common.collect.Maps;
22 | import com.morgan.design.util.JodaUtils;
23 |
24 | /**
25 | * Default implementation of {@link PropertyConversionService}, attempting to convert an object otherwise utilising {@link SimpleTypeConverter} if no matching
26 | * converter is found.
27 | *
28 | * @author James Morgan
29 | */
30 | @Component
31 | public class DefaultPropertyConversionService implements PropertyConversionService {
32 |
33 | @Autowired
34 | private ConfigurableBeanFactory configurableBeanFactory;
35 | private static TypeConverter DEFAULT;
36 | private static Map, Function> CONVERTS = Maps.newHashMap();
37 | static {
38 | CONVERTS.put(Period.class, new PeriodConverter());
39 | CONVERTS.put(LocalDateTime.class, new LocalDateTimeConverter());
40 | CONVERTS.put(LocalDate.class, new LocalDateConverter());
41 | CONVERTS.put(LocalTime.class, new LocalTimeConverter());
42 | }
43 |
44 | @PostConstruct
45 | public void init() {
46 | DEFAULT = configurableBeanFactory.getTypeConverter();
47 | }
48 |
49 | @Override
50 | public Object convertPropertyForField(final Field field, final Object property) {
51 | try {
52 | return Functions.forMap(CONVERTS, new DefaultConverter(field.getType()))
53 | .apply(field.getType())
54 | .apply(property);
55 | }
56 | catch (final Throwable e) {
57 | throw new BeanInitializationException(String.format("Unable to convert property for field [%s]. Value [%s] cannot be converted to [%s]",
58 | field.getName(), property, field.getType()), e);
59 | }
60 | }
61 |
62 | private static class DefaultConverter implements Function {
63 | private final Class type;
64 |
65 | public DefaultConverter(final Class type) {
66 | this.type = type;
67 | }
68 |
69 | @Override
70 | public Object apply(final Object input) {
71 | return DEFAULT.convertIfNecessary(input, this.type);
72 | }
73 | }
74 |
75 | private static class PeriodConverter implements Function {
76 | @Override
77 | public Period apply(final Object input) {
78 | return JodaUtils.timeStringToPeriodOrNull((String) input);
79 | }
80 | }
81 |
82 | private static class LocalDateTimeConverter implements Function {
83 | @Override
84 | public LocalDateTime apply(final Object input) {
85 | return JodaUtils.timestampStringToLocalDateTimeOrNull((String) input);
86 | }
87 | }
88 |
89 | private static class LocalDateConverter implements Function {
90 | @Override
91 | public LocalDate apply(final Object input) {
92 | return JodaUtils.dateStringToLocalDateOrNull((String) input);
93 | }
94 | }
95 |
96 | private static class LocalTimeConverter implements Function {
97 | @Override
98 | public LocalTime apply(final Object input) {
99 | return JodaUtils.timeStringToLocalTimeOrNull((String) input);
100 | }
101 | }
102 | }
103 |
--------------------------------------------------------------------------------
/src/main/java/com/morgan/design/properties/conversion/PropertyConversionService.java:
--------------------------------------------------------------------------------
1 | package com.morgan.design.properties.conversion;
2 |
3 | import java.lang.reflect.Field;
4 |
5 | /**
6 | * Interface intended for use by any class willing to convert the given property {@link Object} which potentially requires conversion before being set on the
7 | * given {@link Field}
8 | *
9 | * @author James Morgan
10 | */
11 | public interface PropertyConversionService {
12 |
13 | /**
14 | * @param field the destination filed to set the property on
15 | * @param property the property to be converted for the given field
16 | * @return the potentially converted field
17 | */
18 | Object convertPropertyForField(final Field field, final Object property);
19 | }
20 |
--------------------------------------------------------------------------------
/src/main/java/com/morgan/design/properties/event/GuavaPropertyChangedEventNotifier.java:
--------------------------------------------------------------------------------
1 | package com.morgan.design.properties.event;
2 |
3 | import org.springframework.beans.factory.annotation.Autowired;
4 | import org.springframework.beans.factory.annotation.Qualifier;
5 | import org.springframework.stereotype.Component;
6 |
7 | import com.google.common.eventbus.EventBus;
8 | import com.morgan.design.properties.bean.PropertyModifiedEvent;
9 | import com.morgan.design.properties.internal.ReloadablePropertyPostProcessor;
10 |
11 | @Component
12 | public class GuavaPropertyChangedEventNotifier implements PropertyChangedEventNotifier {
13 |
14 | private final EventBus eventBus;
15 |
16 | @Autowired
17 | public GuavaPropertyChangedEventNotifier(@Qualifier("propertiesEventBus") final EventBus eventBus) {
18 | this.eventBus = eventBus;
19 | }
20 |
21 | @Override
22 | public void post(final PropertyModifiedEvent propertyChangedEvent) {
23 | this.eventBus.post(propertyChangedEvent);
24 | }
25 |
26 | @Override
27 | public void unregister(final ReloadablePropertyPostProcessor ReloadablePropertyPostProcessor) {
28 | this.eventBus.unregister(ReloadablePropertyPostProcessor);
29 | }
30 |
31 | @Override
32 | public void register(final ReloadablePropertyPostProcessor ReloadablePropertyPostProcessor) {
33 | this.eventBus.register(ReloadablePropertyPostProcessor);
34 | }
35 |
36 | }
37 |
--------------------------------------------------------------------------------
/src/main/java/com/morgan/design/properties/event/PropertyChangedEventNotifier.java:
--------------------------------------------------------------------------------
1 | package com.morgan.design.properties.event;
2 |
3 | import com.morgan.design.properties.bean.PropertyModifiedEvent;
4 | import com.morgan.design.properties.internal.ReloadablePropertyPostProcessor;
5 |
6 | public interface PropertyChangedEventNotifier {
7 |
8 | void post(PropertyModifiedEvent propertyChangedEvent);
9 |
10 | void unregister(ReloadablePropertyPostProcessor reloadablePropertyProcessor);
11 |
12 | void register(ReloadablePropertyPostProcessor reloadablePropertyProcessor);
13 |
14 | }
15 |
--------------------------------------------------------------------------------
/src/main/java/com/morgan/design/properties/internal/PropertiesWatcher.java:
--------------------------------------------------------------------------------
1 | package com.morgan.design.properties.internal;
2 |
3 | import static java.nio.file.StandardWatchEventKinds.ENTRY_MODIFY;
4 |
5 | import java.io.IOException;
6 | import java.nio.file.ClosedWatchServiceException;
7 | import java.nio.file.FileSystems;
8 | import java.nio.file.Path;
9 | import java.nio.file.Paths;
10 | import java.nio.file.WatchEvent;
11 | import java.nio.file.WatchEvent.Kind;
12 | import java.nio.file.WatchKey;
13 | import java.nio.file.WatchService;
14 | import java.util.ArrayList;
15 | import java.util.List;
16 | import java.util.Map;
17 | import java.util.concurrent.ExecutorService;
18 | import java.util.concurrent.Executors;
19 |
20 | import org.slf4j.Logger;
21 | import org.slf4j.LoggerFactory;
22 | import org.springframework.core.io.Resource;
23 |
24 | import com.google.common.collect.Maps;
25 |
26 | public class PropertiesWatcher implements Runnable {
27 |
28 | protected static Logger log = LoggerFactory.getLogger(PropertiesWatcher.class);
29 |
30 | public interface EventPublisher {
31 | void onResourceChanged(Resource resource);
32 | }
33 |
34 | private final Resource[] locations;
35 | private final EventPublisher eventPublisher;
36 |
37 | private WatchService watchService;
38 | final ExecutorService service;
39 |
40 | public PropertiesWatcher(final Resource[] locations, final EventPublisher eventPublisher) throws IOException {
41 | this.locations = locations;
42 | this.eventPublisher = eventPublisher;
43 | this.watchService = FileSystems.getDefault()
44 | .newWatchService();
45 | this.service = Executors.newCachedThreadPool();
46 | }
47 |
48 | @Override
49 | public void run() {
50 | final Map> pathsAndResources = findAvailableResourcePaths();
51 | for (final Path pathToWatch : pathsAndResources.keySet()) {
52 | final List availableResources = pathsAndResources.get(pathToWatch);
53 | log.debug("Starting ResourceWatcher on file {}", availableResources);
54 | this.service.submit(new ResourceWatcher(pathToWatch, availableResources));
55 | }
56 | }
57 |
58 | public void stop() {
59 | try {
60 | log.debug("Closing File Watching Service");
61 | this.watchService.close();
62 |
63 | log.debug("Shuting down Thread Service");
64 | this.service.shutdownNow();
65 | }
66 | catch (final IOException e) {
67 | log.error("Unable to stop file watcher", e);
68 | }
69 | }
70 |
71 | private Map> findAvailableResourcePaths() {
72 | final Map> map = Maps.newHashMap();
73 | for (final Resource resource : this.locations) {
74 | final Path resourceParentPath = getResourceParentPath(resource);
75 | if (null == map.get(resourceParentPath)) {
76 | map.put(resourceParentPath, new ArrayList());
77 | }
78 | map.get(resourceParentPath)
79 | .add(resource);
80 | }
81 | return map;
82 | }
83 |
84 | private Path getResourceParentPath(final Resource resource) {
85 | try {
86 | return Paths.get(resource.getFile()
87 | .getParentFile()
88 | .toURI());
89 | }
90 | catch (final IOException e) {
91 | log.error("Unable to get resource path", e);
92 | }
93 | return null;
94 | }
95 |
96 | private void publishResourceChangedEvent(final Resource resource) {
97 | this.eventPublisher.onResourceChanged(resource);
98 | }
99 |
100 | private WatchService getWatchService() {
101 | return this.watchService;
102 | }
103 |
104 | private class ResourceWatcher implements Runnable {
105 |
106 | private final Path path;
107 | private final List resources;
108 |
109 | public ResourceWatcher(final Path path, final List resources) {
110 | this.path = path;
111 | this.resources = resources;
112 | }
113 |
114 | @Override
115 | public void run() {
116 | try {
117 | log.debug("START");
118 | log.debug("Watching for modifcation events for path {}", this.path.toString());
119 | while (!Thread.currentThread()
120 | .isInterrupted()) {
121 | final WatchKey pathBeingWatched = this.path.register(getWatchService(), ENTRY_MODIFY);
122 |
123 | WatchKey watchKey = null;
124 | try {
125 | watchKey = getWatchService().take();
126 | }
127 | catch (final ClosedWatchServiceException | InterruptedException e) {
128 | log.debug("END");
129 | Thread.currentThread()
130 | .interrupt();
131 | }
132 |
133 | if (watchKey != null) {
134 | for (final WatchEvent event : pathBeingWatched.pollEvents()) {
135 | log.debug("File modification Event Triggered");
136 | final Path target = path(event.context());
137 | if (isValidTargetFile(target)) {
138 | final Path watchedPath = path(watchKey.watchable());
139 | final Kind eventKind = event.kind();
140 |
141 | logNewEvent(watchedPath, eventKind, target);
142 | publishResourceChangedEvent(getResource(target));
143 | }
144 | }
145 | if (!watchKey.reset()) {
146 | log.debug("END");
147 | Thread.currentThread()
148 | .interrupt();
149 | return;
150 | }
151 | }
152 | }
153 | }
154 | catch (final Exception e) {
155 | log.error("Exception thrown when watching resources, path {}\nException:", this.path.toString(), e.getMessage());
156 | stop();
157 | }
158 | }
159 |
160 | private void logNewEvent(final Path watchedPath, final Kind eventKind, final Path target) {
161 | log.debug("Watched Resource changed, modified file [{}]", target.getFileName()
162 | .toString());
163 | log.debug(" Event Kind [{}]", eventKind);
164 | log.debug(" Target [{}]", target);
165 | log.debug("Watched Path [{}]", watchedPath);
166 | }
167 |
168 | private Path path(final Object object) {
169 | return (Path) object;
170 | }
171 |
172 | private boolean isValidTargetFile(final Path target) {
173 | for (final Resource resource : this.resources) {
174 | if (pathMatchesResource(target, resource)) {
175 | return true;
176 | }
177 | }
178 | return false;
179 | }
180 |
181 | public Resource getResource(final Path target) {
182 | for (final Resource resource : this.resources) {
183 | if (pathMatchesResource(target, resource)) {
184 | return resource;
185 | }
186 | }
187 | return null;
188 | }
189 |
190 | private boolean pathMatchesResource(final Path target, final Resource resource) {
191 | return target.getFileName()
192 | .toString()
193 | .equals(resource.getFilename());
194 | }
195 | }
196 |
197 | }
198 |
--------------------------------------------------------------------------------
/src/main/java/com/morgan/design/properties/internal/ReadablePropertySourcesPlaceholderConfigurer.java:
--------------------------------------------------------------------------------
1 | package com.morgan.design.properties.internal;
2 |
3 | import java.io.IOException;
4 | import java.util.Properties;
5 | import java.util.concurrent.Executors;
6 |
7 | import org.slf4j.Logger;
8 | import org.slf4j.LoggerFactory;
9 | import org.springframework.beans.factory.BeanInitializationException;
10 | import org.springframework.beans.factory.annotation.Autowired;
11 | import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
12 | import org.springframework.core.io.Resource;
13 | import org.springframework.core.io.support.PropertiesLoaderUtils;
14 |
15 | import com.morgan.design.properties.bean.PropertyModifiedEvent;
16 | import com.morgan.design.properties.event.PropertyChangedEventNotifier;
17 | import com.morgan.design.properties.internal.PropertiesWatcher.EventPublisher;
18 | import com.morgan.design.properties.resolver.PropertyResolver;
19 |
20 | /**
21 | * Specialisation of {@link PropertySourcesPlaceholderConfigurer} that can react to changes in the resources specified. The watching process does not start by
22 | * default, initiation is triggered by calling ReadablePropertySourcesPlaceholderConfigurer.startWatching()
23 | *
24 | * @author James Morgan
25 | */
26 | public class ReadablePropertySourcesPlaceholderConfigurer extends PropertySourcesPlaceholderConfigurer implements EventPublisher {
27 |
28 | protected static Logger log = LoggerFactory.getLogger(ReadablePropertySourcesPlaceholderConfigurer.class);
29 |
30 | private final PropertyChangedEventNotifier eventNotifier;
31 | private final PropertyResolver propertyResolver;
32 |
33 | private Properties properties;
34 | private Resource[] locations;
35 |
36 | @Autowired
37 | public ReadablePropertySourcesPlaceholderConfigurer(final PropertyChangedEventNotifier eventNotifier, final PropertyResolver propertyResolver) {
38 | this.eventNotifier = eventNotifier;
39 | this.propertyResolver = propertyResolver;
40 | }
41 |
42 | @Override
43 | protected void loadProperties(final Properties props) throws IOException {
44 | super.loadProperties(props);
45 | this.properties = props;
46 | }
47 |
48 | @Override
49 | public void setLocations(final Resource[] locations) {
50 | super.setLocations(locations);
51 | this.locations = locations;
52 | }
53 |
54 | @Override
55 | public void onResourceChanged(final Resource resource) {
56 | try {
57 | final Properties reloadedProperties = PropertiesLoaderUtils.loadProperties(resource);
58 | for (final String property : this.properties.stringPropertyNames()) {
59 |
60 | final String oldValue = this.properties.getProperty(property);
61 | final String newValue = reloadedProperties.getProperty(property);
62 |
63 | if (propertyExistsAndNotNull(property, newValue) && propertyChange(oldValue, newValue)) {
64 |
65 | // Update locally stored copy of properties
66 | this.properties.setProperty(property, newValue);
67 |
68 | // Post change event to notify any potential listeners
69 | this.eventNotifier.post(new PropertyModifiedEvent(property, oldValue, newValue));
70 | }
71 | }
72 | }
73 | catch (final IOException e) {
74 | log.error("Failed to reload properties file once change", e);
75 | }
76 | }
77 |
78 | public Properties getProperties() {
79 | return this.properties;
80 | }
81 |
82 | public void startWatching() {
83 | if (null == this.eventNotifier) {
84 | throw new BeanInitializationException("Event bus not setup, you should not be calling this method...!");
85 | }
86 | try {
87 | // Here we actually create and set a FileWatcher to monitor the given locations
88 | Executors.newSingleThreadExecutor()
89 | .execute(new PropertiesWatcher(this.locations, this));
90 | }
91 | catch (final IOException e) {
92 | log.error("Unable to start properties file watcher", e);
93 | }
94 | }
95 |
96 | public Object resolveProperty(final Object property) {
97 | Object resolvedPropertyValue = this.properties.get(this.propertyResolver.resolveProperty(property));
98 | if (notStringpropertyToSubstitute(resolvedPropertyValue)) {
99 | return resolvedPropertyValue;
100 | }
101 | while (this.propertyResolver.requiresFurtherResoltuion(resolvedPropertyValue)) {
102 | resolvedPropertyValue = buildResolvedString(resolvedPropertyValue);
103 | }
104 | return resolvedPropertyValue;
105 | }
106 |
107 | private Object buildResolvedString(final Object resolvedPropertyValue) {
108 | final String resolvedValueStr = resolvedPropertyValue.toString();
109 |
110 | final int startingIndex = resolvedValueStr.indexOf("${");
111 | final int endingIndex = resolvedValueStr.indexOf("}", startingIndex) + 1;
112 |
113 | final String toResolve = resolvedValueStr.substring(startingIndex, endingIndex);
114 | final String resolved = resolveProperty(toResolve).toString();
115 |
116 | return new StringBuilder()
117 | .append(resolvedValueStr.substring(0, startingIndex))
118 | .append(resolved)
119 | .append(resolvedValueStr.substring(endingIndex))
120 | .toString();
121 | }
122 |
123 | private boolean notStringpropertyToSubstitute(final Object resolvedPropertyValue) {
124 | return !(resolvedPropertyValue instanceof String);
125 | }
126 |
127 | private boolean propertyChange(final String oldValue, final String newValue) {
128 | return null == oldValue || !oldValue.equals(newValue);
129 | }
130 |
131 | private boolean propertyExistsAndNotNull(final String property, final String newValue) {
132 | return this.properties.containsKey(property) && null != newValue;
133 | }
134 |
135 | }
136 |
--------------------------------------------------------------------------------
/src/main/java/com/morgan/design/properties/internal/ReloadablePropertyPostProcessor.java:
--------------------------------------------------------------------------------
1 | package com.morgan.design.properties.internal;
2 |
3 | import java.lang.reflect.Field;
4 | import java.lang.reflect.Modifier;
5 | import java.util.HashSet;
6 | import java.util.Map;
7 | import java.util.Properties;
8 | import java.util.Set;
9 |
10 | import javax.annotation.PostConstruct;
11 |
12 | import org.slf4j.Logger;
13 | import org.slf4j.LoggerFactory;
14 | import org.springframework.beans.BeansException;
15 | import org.springframework.beans.factory.BeanInitializationException;
16 | import org.springframework.beans.factory.annotation.Autowired;
17 | import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;
18 | import org.springframework.stereotype.Component;
19 | import org.springframework.util.ReflectionUtils;
20 |
21 | import com.google.common.collect.Maps;
22 | import com.google.common.eventbus.Subscribe;
23 | import com.morgan.design.properties.ReloadableProperty;
24 | import com.morgan.design.properties.bean.BeanPropertyHolder;
25 | import com.morgan.design.properties.bean.PropertyModifiedEvent;
26 | import com.morgan.design.properties.conversion.PropertyConversionService;
27 | import com.morgan.design.properties.event.PropertyChangedEventNotifier;
28 |
29 | /**
30 | *
31 | * Processes beans on start up injecting field values marked with {@link ReloadableProperty} setting the associated annotated property value with properties
32 | * configured in a {@link ReadablePropertySourcesPlaceholderConfigurer}.
33 | *
34 | *
35 | * The processor also has the ability to reload/re-inject properties from the configured {@link ReadablePropertySourcesPlaceholderConfigurer} which are changed.
36 | * Once a property is reloaded the associated bean holding that value will have its property updated, no further bean operations are performed on the reloaded
37 | * bean.
38 | *
39 | *
40 | * The processor will also substitute any properties with values starting with "${" and ending with "}", none recursive.
41 | *
42 | *
43 | * @author James Morgan
44 | */
45 | @Component
46 | public class ReloadablePropertyPostProcessor extends InstantiationAwareBeanPostProcessorAdapter {
47 |
48 | protected static Logger log = LoggerFactory.getLogger(ReloadablePropertyPostProcessor.class);
49 |
50 | private final PropertyChangedEventNotifier eventNotifier;
51 | private final PropertyConversionService propertyConversionService;
52 | private final ReadablePropertySourcesPlaceholderConfigurer placeholderConfigurer;
53 |
54 | private Map> beanPropertySubscriptions = Maps.newHashMap();
55 |
56 | @Autowired
57 | public ReloadablePropertyPostProcessor(final ReadablePropertySourcesPlaceholderConfigurer placeholderConfigurer,
58 | final PropertyChangedEventNotifier eventNotifier, final PropertyConversionService conversionService) {
59 | this.eventNotifier = eventNotifier;
60 | this.placeholderConfigurer = placeholderConfigurer;
61 | this.propertyConversionService = conversionService;
62 | }
63 |
64 | @PostConstruct
65 | protected void init() {
66 | log.info("Registering ReloadablePropertyProcessor for properties file changes");
67 | registerPropertyReloader();
68 | }
69 |
70 | /**
71 | * Utility method to unregister the class from receiving events about property files being changed.
72 | */
73 | public final void unregisterPropertyReloader() {
74 | log.info("Unregistering ReloadablePropertyProcessor from property file changes");
75 | this.eventNotifier.unregister(this);
76 | }
77 |
78 | /**
79 | * Utility method to register the class for receiving events about property files being changed, setting up bean re-injection once triggered.
80 | */
81 | public final void registerPropertyReloader() {
82 | // Setup Guava event bus listener
83 | this.eventNotifier.register(this);
84 | // Trigger resource change listener
85 | this.placeholderConfigurer.startWatching();
86 | }
87 |
88 | /**
89 | * Method subscribing to the {@link PropertyModifiedEvent} utilising the {@link Subscribe} annotation
90 | *
91 | * @param event the {@link PropertyModifiedEvent} detailing what's changed
92 | */
93 | @Subscribe
94 | public void handlePropertyChange(final PropertyModifiedEvent event) {
95 | for (final BeanPropertyHolder bean : this.beanPropertySubscriptions.get(event.getPropertyName())) {
96 | updateField(bean, event);
97 | }
98 | }
99 |
100 | public void updateField(final BeanPropertyHolder holder, final PropertyModifiedEvent event) {
101 | final Object beanToUpdate = holder.getBean();
102 | final Field fieldToUpdate = holder.getField();
103 | final String canonicalName = beanToUpdate.getClass()
104 | .getCanonicalName();
105 |
106 | final Object convertedProperty = convertPropertyForField(fieldToUpdate, event.getPropertyName());
107 | try {
108 | log.info("Reloading property [{}] on field [{}] for class [{}]", new Object[] { event.getPropertyName(), fieldToUpdate.getName(), canonicalName });
109 | fieldToUpdate.set(beanToUpdate, convertedProperty);
110 | }
111 | catch (final IllegalAccessException e) {
112 | log.error("Unable to reloading property [{}] on field [{}] for class [{}]\n Exception [{}]",
113 | new Object[] { event.getPropertyName(), fieldToUpdate.getName(), canonicalName, e.getMessage() });
114 | }
115 | }
116 |
117 | @Override
118 | public boolean postProcessAfterInstantiation(final Object bean, final String beanName) throws BeansException {
119 | if (log.isDebugEnabled()) {
120 | log.debug("Setting Reloadable Properties on [{}]", beanName);
121 | }
122 | setPropertiesOnBean(bean);
123 | return true;
124 | }
125 |
126 | private void setPropertiesOnBean(final Object bean) {
127 | ReflectionUtils.doWithFields(bean.getClass(), new ReflectionUtils.FieldCallback() {
128 |
129 | @Override
130 | public void doWith(final Field field) throws IllegalArgumentException, IllegalAccessException {
131 |
132 | final ReloadableProperty annotation = field.getAnnotation(ReloadableProperty.class);
133 | if (null != annotation) {
134 |
135 | ReflectionUtils.makeAccessible(field);
136 | validateFieldNotFinal(bean, field);
137 |
138 | final Object property = getProperties().get(annotation.value());
139 | validatePropertyAvailableOrDefaultSet(bean, field, annotation, property);
140 |
141 | if (null != property) {
142 |
143 | log.info("Attempting to convert and set property [{}] on field [{}] for class [{}] to type [{}]",
144 | new Object[] { property, field.getName(), bean.getClass()
145 | .getCanonicalName(), field.getType() });
146 |
147 | final Object convertedProperty = convertPropertyForField(field, annotation.value());
148 |
149 | log.info("Setting field [{}] of class [{}] with value [{}]", new Object[] { field.getName(), bean.getClass()
150 | .getCanonicalName(), convertedProperty });
151 |
152 | field.set(bean, convertedProperty);
153 |
154 | subscribeBeanToPropertyChangedEvent(annotation.value(), new BeanPropertyHolder(bean, field));
155 | }
156 | else {
157 | log.info("Leaving field [{}] of class [{}] with default value", new Object[] { field.getName(), bean.getClass()
158 | .getCanonicalName() });
159 | }
160 | }
161 | }
162 | });
163 | }
164 |
165 | private void validatePropertyAvailableOrDefaultSet(final Object bean, final Field field, final ReloadableProperty annotation, final Object property)
166 | throws IllegalArgumentException, IllegalAccessException {
167 | if (null == property && fieldDoesNotHaveDefault(field, bean)) {
168 | throw new BeanInitializationException(String.format("No property found for field annotated with @ReloadableProperty, "
169 | + "and no default specified. Property [%s] of class [%s] requires a property named [%s]", field.getName(), bean.getClass()
170 | .getCanonicalName(), annotation.value()));
171 | }
172 | }
173 |
174 | private void validateFieldNotFinal(final Object bean, final Field field) {
175 | if (Modifier.isFinal(field.getModifiers())) {
176 | throw new BeanInitializationException(String.format("Unable to set field [%s] of class [%s] as is declared final", field.getName(), bean.getClass()
177 | .getCanonicalName()));
178 | }
179 | }
180 |
181 | private boolean fieldDoesNotHaveDefault(final Field field, final Object value) throws IllegalArgumentException, IllegalAccessException {
182 | try {
183 | return (null == field.get(value));
184 | }
185 | catch (final NullPointerException e) {
186 | return true;
187 | }
188 | }
189 |
190 | private void subscribeBeanToPropertyChangedEvent(final String property, final BeanPropertyHolder fieldProperty) {
191 | if (!this.beanPropertySubscriptions.containsKey(property)) {
192 | this.beanPropertySubscriptions.put(property, new HashSet());
193 | }
194 | this.beanPropertySubscriptions.get(property)
195 | .add(fieldProperty);
196 | }
197 |
198 | // ///////////////////////////////////
199 | // Utility methods for class access //
200 | // ///////////////////////////////////
201 |
202 | private Object convertPropertyForField(final Field field, final Object property) {
203 | return this.propertyConversionService.convertPropertyForField(field, resolverProperty(property));
204 | }
205 |
206 | private Object resolverProperty(final Object property) {
207 | return this.placeholderConfigurer.resolveProperty(property);
208 | }
209 |
210 | private Properties getProperties() {
211 | return this.placeholderConfigurer.getProperties();
212 | }
213 | }
214 |
--------------------------------------------------------------------------------
/src/main/java/com/morgan/design/properties/resolver/PropertyResolver.java:
--------------------------------------------------------------------------------
1 | package com.morgan.design.properties.resolver;
2 |
3 | /**
4 | * Interface to be apply any special property resolution techniques on the given object, see {@link SubstitutingPropertyResolver} for default implementation
5 | *
6 | * @author James Morgan
7 | */
8 | public interface PropertyResolver {
9 |
10 | /**
11 | * @param property The property to resolve by substitution, if required
12 | * @return The result of the property resolution, or the property itself if no substitution was required
13 | */
14 | String resolveProperty(final Object property);
15 |
16 | /**
17 | * Can be used to check whether a property requires further resolution
18 | *
19 | * @param property The property to resolve by substitution, if required
20 | * @return true if the chosen {@link PropertyResolver} performs custom resolution
21 | */
22 | boolean requiresFurtherResoltuion(final Object property);
23 |
24 | }
25 |
--------------------------------------------------------------------------------
/src/main/java/com/morgan/design/properties/resolver/SubstitutingPropertyResolver.java:
--------------------------------------------------------------------------------
1 | package com.morgan.design.properties.resolver;
2 |
3 | import org.slf4j.Logger;
4 | import org.slf4j.LoggerFactory;
5 | import org.springframework.stereotype.Component;
6 |
7 | /**
8 | * Implementation of a {@link PropertyResolver} resolving property keys via substitution. Substitution occurs only for properly formatted markers e.g
9 | * ${...}
10 | *
11 | *