ReloadingFileBasedConfigurationBuilder.java

  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;

  19. import java.util.Map;

  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;

  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, for example a timer.
  49.  * </p>
  50.  *
  51.  * @param <T> the concrete type of {@code Configuration} objects created by this builder
  52.  * @since 2.0
  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();

  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.     }

  70.     /** The reloading controller associated with this object. */
  71.     private final ReloadingController reloadingController;

  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;

  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 <strong>null</strong>
  85.      * @throws IllegalArgumentException if the result class is <strong>null</strong>
  86.      */
  87.     public ReloadingFileBasedConfigurationBuilder(final Class<? extends T> resCls) {
  88.         super(resCls);
  89.         reloadingController = createReloadingController();
  90.     }

  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 <strong>null</strong>
  97.      * @param params a map with initialization parameters
  98.      * @throws IllegalArgumentException if the result class is <strong>null</strong>
  99.      */
  100.     public ReloadingFileBasedConfigurationBuilder(final Class<? extends T> resCls, final Map<String, Object> params) {
  101.         super(resCls, params);
  102.         reloadingController = createReloadingController();
  103.     }

  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 <strong>null</strong>
  110.      * @param params a map with initialization parameters
  111.      * @param allowFailOnInit the <em>allowFailOnInit</em> flag
  112.      * @throws IllegalArgumentException if the result class is <strong>null</strong>
  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.     }

  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.     }

  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.     }

  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.     }

  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.             }

  175.             @Override
  176.             public void reloadingPerformed() {
  177.                 final ReloadingDetector detector = resultReloadingDetector;
  178.                 if (detector != null) {
  179.                     detector.reloadingPerformed();
  180.                 }
  181.             }
  182.         };
  183.     }

  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.     }

  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);

  205.         resultReloadingDetector = createReloadingDetector(handler, FileBasedBuilderParametersImpl.fromParameters(getParameters(), true));
  206.     }
  207. }
Created with JaCoCo 0.8.12.202403310830