/** * Initialize the PersistenceManagerFactory for the given location. * * @throws IllegalArgumentException in case of illegal property values * @throws IOException if the properties could not be loaded from the given location * @throws JDOException in case of JDO initialization errors */ public void afterPropertiesSet() throws IllegalArgumentException, IOException, JDOException { if (this.persistenceManagerFactoryName != null) { if (this.configLocation != null || !this.jdoPropertyMap.isEmpty()) { throw new IllegalStateException( "'configLocation'/'jdoProperties' not supported in " + "combination with 'persistenceManagerFactoryName' - specify one or the other, not both"); } if (logger.isInfoEnabled()) { logger.info( "Building new JDO PersistenceManagerFactory for name '" + this.persistenceManagerFactoryName + "'"); } this.persistenceManagerFactory = newPersistenceManagerFactory(this.persistenceManagerFactoryName); } else { Map<String, Object> mergedProps = new HashMap<String, Object>(); if (this.configLocation != null) { if (logger.isInfoEnabled()) { logger.info("Loading JDO config from [" + this.configLocation + "]"); } CollectionUtils.mergePropertiesIntoMap( PropertiesLoaderUtils.loadProperties(this.configLocation), mergedProps); } mergedProps.putAll(this.jdoPropertyMap); logger.info("Building new JDO PersistenceManagerFactory"); this.persistenceManagerFactory = newPersistenceManagerFactory(mergedProps); } // Build default JdoDialect if none explicitly specified. if (this.jdoDialect == null) { this.jdoDialect = new DefaultJdoDialect(this.persistenceManagerFactory.getConnectionFactory()); } }
/** * Load and/or apply Quartz properties to the given SchedulerFactory. * * @param schedulerFactory the SchedulerFactory to initialize */ private void initSchedulerFactory(SchedulerFactory schedulerFactory) throws SchedulerException, IOException { if (!(schedulerFactory instanceof StdSchedulerFactory)) { if (this.configLocation != null || this.quartzProperties != null || this.taskExecutor != null || this.dataSource != null) { throw new IllegalArgumentException( "StdSchedulerFactory required for applying Quartz properties: " + schedulerFactory); } // Otherwise assume that no initialization is necessary... return; } Properties mergedProps = new Properties(); if (this.resourceLoader != null) { mergedProps.setProperty( StdSchedulerFactory.PROP_SCHED_CLASS_LOAD_HELPER_CLASS, ResourceLoaderClassLoadHelper.class.getName()); } if (this.taskExecutor != null) { mergedProps.setProperty( StdSchedulerFactory.PROP_THREAD_POOL_CLASS, LocalTaskExecutorThreadPool.class.getName()); } else { // Set necessary default properties here, as Quartz will not apply // its default configuration when explicitly given properties. mergedProps.setProperty( StdSchedulerFactory.PROP_THREAD_POOL_CLASS, SimpleThreadPool.class.getName()); mergedProps.setProperty(PROP_THREAD_COUNT, Integer.toString(DEFAULT_THREAD_COUNT)); } if (this.configLocation != null) { if (logger.isInfoEnabled()) { logger.info("Loading Quartz config from [" + this.configLocation + "]"); } PropertiesLoaderUtils.fillProperties(mergedProps, this.configLocation); } CollectionUtils.mergePropertiesIntoMap(this.quartzProperties, mergedProps); if (this.dataSource != null) { mergedProps.put( StdSchedulerFactory.PROP_JOB_STORE_CLASS, LocalDataSourceJobStore.class.getName()); } // Make sure to set the scheduler name as configured in the Spring configuration. if (this.schedulerName != null) { mergedProps.put(StdSchedulerFactory.PROP_SCHED_INSTANCE_NAME, this.schedulerName); } ((StdSchedulerFactory) schedulerFactory).initialize(mergedProps); }
/** * Prepare the VelocityEngine instance and return it. * * @return the VelocityEngine instance * @throws IOException if the config file wasn't found * @throws VelocityException on Velocity initialization failure */ public VelocityEngine createVelocityEngine() throws IOException, VelocityException { VelocityEngine velocityEngine = newVelocityEngine(); Map<String, Object> props = new HashMap<String, Object>(); // Load config file if set. if (this.configLocation != null) { if (logger.isInfoEnabled()) { logger.info("Loading Velocity config from [" + this.configLocation + "]"); } CollectionUtils.mergePropertiesIntoMap( PropertiesLoaderUtils.loadProperties(this.configLocation), props); } // Merge local properties if set. if (!this.velocityProperties.isEmpty()) { props.putAll(this.velocityProperties); } // Set a resource loader path, if required. if (this.resourceLoaderPath != null) { initVelocityResourceLoader(velocityEngine, this.resourceLoaderPath); } // Log via Commons Logging? if (this.overrideLogging) { velocityEngine.setProperty( RuntimeConstants.RUNTIME_LOG_LOGSYSTEM, new CommonsLoggingLogSystem()); } // Apply properties to VelocityEngine. for (Map.Entry<String, Object> entry : props.entrySet()) { velocityEngine.setProperty(entry.getKey(), entry.getValue()); } postProcessVelocityEngine(velocityEngine); try { // Perform actual initialization. velocityEngine.init(); } catch (IOException ex) { throw ex; } catch (VelocityException ex) { throw ex; } catch (RuntimeException ex) { throw ex; } catch (Exception ex) { logger.error("Why does VelocityEngine throw a generic checked exception, after all?", ex); throw new VelocityException(ex.toString()); } return velocityEngine; }
@Test public void testMergePropertiesIntoMap() { Properties defaults = new Properties(); defaults.setProperty("prop1", "value1"); Properties props = new Properties(defaults); props.setProperty("prop2", "value2"); props.put("prop3", new Integer(3)); Map<String, String> map = new HashMap<>(); map.put("prop4", "value4"); CollectionUtils.mergePropertiesIntoMap(props, map); assertEquals("value1", map.get("prop1")); assertEquals("value2", map.get("prop2")); assertEquals(new Integer(3), map.get("prop3")); assertEquals("value4", map.get("prop4")); }
/** * Return a merged Properties instance containing both the loaded properties and properties set on * this FactoryBean. */ protected Properties mergeProperties() throws IOException { Properties result = new Properties(); if (this.localOverride) { // Load properties from file upfront, to let local properties override. loadProperties(result); } if (this.localProperties != null) { for (int i = 0; i < this.localProperties.length; i++) { CollectionUtils.mergePropertiesIntoMap(this.localProperties[i], result); } } if (!this.localOverride) { // Load properties from file afterwards, to let those properties override. loadProperties(result); } return result; }
/** * Set JDO properties, such as"javax.jdo.PersistenceManagerFactoryClass". * * <p>Can be used to override values in a JDO properties config file, or to specify all necessary * properties locally. * * <p>Can be populated with a String "value" (parsed via PropertiesEditor) or a "props" element in * XML bean definitions. */ public void setJdoProperties(Properties jdoProperties) { CollectionUtils.mergePropertiesIntoMap(jdoProperties, this.jdoPropertyMap); }
/** * Set Velocity properties, like "file.resource.loader.path". Can be used to override values in a * Velocity config file, or to specify all necessary properties locally. * * <p>Note that the Velocity resource loader path also be set to any Spring resource location via * the "resourceLoaderPath" property. Setting it here is just necessary when using a * non-file-based resource loader. * * @see #setVelocityPropertiesMap * @see #setConfigLocation * @see #setResourceLoaderPath */ public void setVelocityProperties(Properties velocityProperties) { CollectionUtils.mergePropertiesIntoMap(velocityProperties, this.velocityProperties); }
/** * Set static attributes for this view from a <code>java.util.Properties</code> object. * * <p>"Static" attributes are fixed attributes that are specified in the View instance * configuration. "Dynamic" attributes, on the other hand, are values passed in as part of the * model. * * <p>This is the most convenient way to set static attributes. Note that static attributes can be * overridden by dynamic attributes, if a value with the same name is included in the model. * * <p>Can be populated with a String "value" (parsed via PropertiesEditor) or a "props" element in * XML bean definitions. * * @see org.springframework.beans.propertyeditors.PropertiesEditor */ public void setAttributes(Properties attributes) { CollectionUtils.mergePropertiesIntoMap(attributes, this.staticAttributes); }
/** * Specify bean validation properties to be passed to the validation provider. * * <p>Can be populated with a String "value" (parsed via PropertiesEditor) or a "props" element in * XML bean definitions. * * @see javax.validation.Configuration#addProperty(String, String) */ public void setValidationProperties(Properties jpaProperties) { CollectionUtils.mergePropertiesIntoMap(jpaProperties, this.validationPropertyMap); }