1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 package org.apache.commons.configuration2.builder; 18 19 import java.util.Map; 20 21 import org.apache.commons.configuration2.FileBasedConfiguration; 22 import org.apache.commons.configuration2.ex.ConfigurationException; 23 import org.apache.commons.configuration2.io.FileHandler; 24 import org.apache.commons.configuration2.reloading.ReloadingController; 25 import org.apache.commons.configuration2.reloading.ReloadingControllerSupport; 26 import org.apache.commons.configuration2.reloading.ReloadingDetector; 27 28 /** 29 * <p> 30 * A specialized {@code ConfigurationBuilder} implementation which can handle configurations read from a 31 * {@link FileHandler} and supports reloading. 32 * </p> 33 * <p> 34 * This builder class exposes a {@link ReloadingController} object controlling reload operations on the file-based 35 * configuration produced as result object. For the {@code FileHandler} defining the location of the configuration a 36 * configurable {@link ReloadingDetector} is created and associated with the controller. So changes on the source file 37 * can be detected. When ever such a change occurs, the result object of this builder is reset. This means that the next 38 * time {@code getConfiguration()} is called a new {@code Configuration} object is created which is loaded from the 39 * modified file. 40 * </p> 41 * <p> 42 * Client code interested in notifications can register a listener at this builder to receive reset events. When such an 43 * event is received the new result object can be requested. This way client applications can be sure to work with an 44 * up-to-date configuration. It is also possible to register a listener directly at the {@code ReloadingController}. 45 * </p> 46 * <p> 47 * This builder does not actively trigger the {@code ReloadingController} to perform a reload check. This has to be done 48 * by an external component, e.g. a timer. 49 * </p> 50 * 51 * @since 2.0 52 * @param <T> the concrete type of {@code Configuration} objects created by this builder 53 */ 54 public class ReloadingFileBasedConfigurationBuilder<T extends FileBasedConfiguration> extends FileBasedConfigurationBuilder<T> 55 implements ReloadingControllerSupport { 56 /** The default factory for creating reloading detector objects. */ 57 private static final ReloadingDetectorFactory DEFAULT_DETECTOR_FACTORY = new DefaultReloadingDetectorFactory(); 58 59 /** 60 * Returns a {@code ReloadingDetectorFactory} either from the passed in parameters or a default factory. 61 * 62 * @param params the current parameters object 63 * @return the {@code ReloadingDetectorFactory} to be used 64 */ 65 private static ReloadingDetectorFactory fetchDetectorFactory(final FileBasedBuilderParametersImpl params) { 66 final ReloadingDetectorFactory factory = params.getReloadingDetectorFactory(); 67 return factory != null ? factory : DEFAULT_DETECTOR_FACTORY; 68 } 69 70 /** The reloading controller associated with this object. */ 71 private final ReloadingController reloadingController; 72 73 /** 74 * The reloading detector which does the actual reload check for the current result object. A new instance is created 75 * whenever a new result object (and thus a new current file handler) becomes available. The field must be volatile 76 * because it is accessed by the reloading controller probably from within another thread. 77 */ 78 private volatile ReloadingDetector resultReloadingDetector; 79 80 /** 81 * Creates a new instance of {@code ReloadingFileBasedConfigurationBuilder} which produces result objects of the 82 * specified class. 83 * 84 * @param resCls the result class (must not be <b>null</b> 85 * @throws IllegalArgumentException if the result class is <b>null</b> 86 */ 87 public ReloadingFileBasedConfigurationBuilder(final Class<? extends T> resCls) { 88 super(resCls); 89 reloadingController = createReloadingController(); 90 } 91 92 /** 93 * Creates a new instance of {@code ReloadingFileBasedConfigurationBuilder} which produces result objects of the 94 * specified class and sets initialization parameters. 95 * 96 * @param resCls the result class (must not be <b>null</b> 97 * @param params a map with initialization parameters 98 * @throws IllegalArgumentException if the result class is <b>null</b> 99 */ 100 public ReloadingFileBasedConfigurationBuilder(final Class<? extends T> resCls, final Map<String, Object> params) { 101 super(resCls, params); 102 reloadingController = createReloadingController(); 103 } 104 105 /** 106 * Creates a new instance of {@code ReloadingFileBasedConfigurationBuilder} which produces result objects of the 107 * specified class and sets initialization parameters and the <em>allowFailOnInit</em> flag. 108 * 109 * @param resCls the result class (must not be <b>null</b> 110 * @param params a map with initialization parameters 111 * @param allowFailOnInit the <em>allowFailOnInit</em> flag 112 * @throws IllegalArgumentException if the result class is <b>null</b> 113 */ 114 public ReloadingFileBasedConfigurationBuilder(final Class<? extends T> resCls, final Map<String, Object> params, final boolean allowFailOnInit) { 115 super(resCls, params, allowFailOnInit); 116 reloadingController = createReloadingController(); 117 } 118 119 /** 120 * {@inheritDoc} This method is overridden here to change the result type. 121 */ 122 @Override 123 public ReloadingFileBasedConfigurationBuilder<T> configure(final BuilderParameters... params) { 124 super.configure(params); 125 return this; 126 } 127 128 /** 129 * Creates the {@code ReloadingController} associated with this object. The controller is assigned a specialized 130 * reloading detector which delegates to the detector for the current result object. ( 131 * {@code FileHandlerReloadingDetector} does not support changing the file handler, and {@code ReloadingController} does 132 * not support changing the reloading detector; therefore, this level of indirection is needed to change the monitored 133 * file dynamically.) 134 * 135 * @return the new {@code ReloadingController} 136 */ 137 private ReloadingController createReloadingController() { 138 final ReloadingDetector ctrlDetector = createReloadingDetectorForController(); 139 final ReloadingController ctrl = new ReloadingController(ctrlDetector); 140 connectToReloadingController(ctrl); 141 return ctrl; 142 } 143 144 /** 145 * Creates a {@code ReloadingDetector} which monitors the passed in {@code FileHandler}. This method is called each time 146 * a new result object is created with the current {@code FileHandler}. This implementation checks whether a 147 * {@code ReloadingDetectorFactory} is specified in the current parameters. If this is the case, it is invoked. 148 * Otherwise, a default factory is used to create a {@code FileHandlerReloadingDetector} object. Note: This method is 149 * called from a synchronized block. 150 * 151 * @param handler the current {@code FileHandler} 152 * @param fbparams the object with parameters related to file-based builders 153 * @return a {@code ReloadingDetector} for this {@code FileHandler} 154 * @throws ConfigurationException if an error occurs 155 */ 156 protected ReloadingDetector createReloadingDetector(final FileHandler handler, final FileBasedBuilderParametersImpl fbparams) 157 throws ConfigurationException { 158 return fetchDetectorFactory(fbparams).createReloadingDetector(handler, fbparams); 159 } 160 161 /** 162 * Creates a {@code ReloadingDetector} wrapper to be passed to the associated {@code ReloadingController}. This detector 163 * wrapper simply delegates to the current {@code ReloadingDetector} if it is available. 164 * 165 * @return the wrapper {@code ReloadingDetector} 166 */ 167 private ReloadingDetector createReloadingDetectorForController() { 168 return new ReloadingDetector() { 169 @Override 170 public boolean isReloadingRequired() { 171 final ReloadingDetector detector = resultReloadingDetector; 172 return detector != null && detector.isReloadingRequired(); 173 } 174 175 @Override 176 public void reloadingPerformed() { 177 final ReloadingDetector detector = resultReloadingDetector; 178 if (detector != null) { 179 detector.reloadingPerformed(); 180 } 181 } 182 }; 183 } 184 185 /** 186 * Gets the {@code ReloadingController} associated with this builder. This controller is directly created. However, 187 * it becomes active (i.e. associated with a meaningful reloading detector) not before a result object was created. 188 * 189 * @return the {@code ReloadingController} 190 */ 191 @Override 192 public ReloadingController getReloadingController() { 193 return reloadingController; 194 } 195 196 /** 197 * {@inheritDoc} This implementation also takes care that a new {@code ReloadingDetector} for the new current 198 * {@code FileHandler} is created. Also, the reloading controller's reloading state has to be reset; after the creation 199 * of a new result object changes in the underlying configuration source have to be monitored again. 200 */ 201 @Override 202 protected void initFileHandler(final FileHandler handler) throws ConfigurationException { 203 super.initFileHandler(handler); 204 205 resultReloadingDetector = createReloadingDetector(handler, FileBasedBuilderParametersImpl.fromParameters(getParameters(), true)); 206 } 207 }