@Test public void simpleBootstrap() { MockServletContext servletContext = new MockServletContext(); TilesConfigurer tc = new TilesConfigurer(); tc.setDefinitions("/org/springframework/web/servlet/view/tiles3/tiles-definitions.xml"); tc.setCheckRefresh(true); tc.setServletContext(servletContext); tc.afterPropertiesSet(); ApplicationContext tilesContext = ServletUtil.getApplicationContext(servletContext); BasicTilesContainer container = (BasicTilesContainer) TilesAccess.getContainer(tilesContext); Request requestContext = new ServletRequest(container.getApplicationContext(), new MockHttpServletRequest(), new MockHttpServletResponse()); assertNotNull(container.getDefinitionsFactory().getDefinition("test", requestContext)); tc.destroy(); }
/** * Instantiate a new definitions factory based on Locale. * @param applicationContext The Tiles application context. * @param resolver The locale resolver. * @return The definitions factory. * @since 2.2.1 */ protected UnresolvingLocaleDefinitionsFactory instantiateDefinitionsFactory( ApplicationContext applicationContext, LocaleResolver resolver) { return new UnresolvingLocaleDefinitionsFactory(); }
/** {@inheritDoc} */ public void reset() { if (definitionDao instanceof Refreshable) { ((Refreshable) definitionDao).refresh(); } }
/** * Creates the definitions factory. By default it creates a * {@link UrlDefinitionsFactory} with default dependencies. * @param applicationContext The Tiles application context. * @param contextFactory The Tiles context factory. * @param resolver The locale resolver. * * @return The definitions factory. * @since 2.1.1 */ protected DefinitionsFactory createDefinitionsFactory(TilesApplicationContext applicationContext, TilesRequestContextFactory contextFactory, LocaleResolver resolver) { LocaleDefinitionsFactory factory = instantiateDefinitionsFactory( applicationContext, contextFactory, resolver); factory.setApplicationContext(applicationContext); factory.setLocaleResolver(resolver); factory.setDefinitionDAO(createLocaleDefinitionDao(applicationContext, contextFactory, resolver)); if (factory instanceof Refreshable) { ((Refreshable) factory).refresh(); } return factory; }
/** {@inheritDoc} */ public void render(String definitionName, Request request) { log.debug("Render request received for definition '{}'", definitionName); Definition definition = getDefinition(definitionName, request); if (definition == null) { throw new NoSuchDefinitionException("Unable to find the definition '" + definitionName + "'"); } render(definition, request); }
/** * Creates the definitions factory. By default it creates a * {@link UnresolvingLocaleDefinitionsFactory} with default dependencies. * * @param applicationContext The Tiles application context. * @param resolver The locale resolver. * @return The definitions factory. * @since 2.1.1 */ protected DefinitionsFactory createDefinitionsFactory(ApplicationContext applicationContext, LocaleResolver resolver) { UnresolvingLocaleDefinitionsFactory factory = instantiateDefinitionsFactory( applicationContext, resolver); factory.setLocaleResolver(resolver); factory.setDefinitionDAO(createLocaleDefinitionDao(applicationContext, resolver)); return factory; }
/** * Creates a new instance of <code>Definitions</code>. Override this method * to provide your custom instance of Definitions. * * @return A new instance of <code>Definitions</code>. * @deprecated Do not use! Deprecated with no replacement. */ @Deprecated protected Definitions createDefinitions() { return new CompatibilityDefinitionsImpl(definitionDao); }
/** * Adds new Definition objects to the internal collection and * resolves inheritance attraibutes. * * @param defsMap The new definitions to add. * @throws NoSuchDefinitionException If something goes wrong during * addition. */ public void addDefinitions(Map<String, Definition> defsMap) { this.baseDefinitions.putAll(defsMap); resolveInheritances(); }
/** {@inheritDoc} */ @Override protected LocaleDefinitionsFactory instantiateDefinitionsFactory( ApplicationContext applicationContext, LocaleResolver resolver) { return new LocaleDefinitionsFactory(); } }
/** * Indicates whether the DefinitionsFactory is out of date and needs to be * reloaded. * * @return If the factory needs refresh. */ public boolean refreshRequired() { return (definitionDao instanceof RefreshMonitor) && ((RefreshMonitor) definitionDao).refreshRequired(); }
/** * Instantiate a new definitions factory based on Locale. * @param applicationContext The Tiles application context. * @param contextFactory The Tiles context factory. * @param resolver The locale resolver. * * @return The definitions factory. * @since 2.1.1 */ protected LocaleDefinitionsFactory instantiateDefinitionsFactory(TilesApplicationContext applicationContext, TilesRequestContextFactory contextFactory, LocaleResolver resolver) { return new UrlDefinitionsFactory(); }
/** {@inheritDoc} */ @Override public Definition getDefinition(String definitionName, Request request) { Definition definition = definitionsFactory.getDefinition(definitionName, request); return definition; }
/** {@inheritDoc} */ public synchronized void refresh() { log.debug("Updating Tiles definitions. . ."); if (definitionDao instanceof Refreshable) { ((Refreshable) definitionDao).refresh(); } }
/** {@inheritDoc} */ @Override public void render(String definition, Request request) { Definition toRender = getDefinition(definition, request); if (toRender == null) { throw new NoSuchDefinitionException( "Cannot find definition named '" + definition + "'"); } super.render(toRender, request); }
/** * Returns the definitions holder object. * * @return The definitions holder. * @deprecated Do not use! Deprecated with no replacement. */ @Deprecated protected Definitions getDefinitions() { return new CompatibilityDefinitionsImpl(definitionDao); }
/** * Adds new locale-specific Definition objects to the internal * collection and resolves inheritance attraibutes. * * @param defsMap The new definitions to add. * @param locale The locale to add the definitions to. * @throws NoSuchDefinitionException If something goes wrong during * inheritance resolution. */ public void addDefinitions(Map<String, Definition> defsMap, Locale locale) { localeSpecificDefinitions.put(locale, defsMap); resolveInheritances(locale); }
/** * Returns a definition specifying its name. * * @param definitionName The name of the definition to find. * @param request The request context. * @return The definition, if found. * @throws DefinitionsFactoryException If the definitions factory throws an * exception. */ protected Definition getDefinition(String definitionName, TilesRequestContext request) { Definition definition = definitionsFactory.getDefinition(definitionName, request); return definition; }
/** * Creates and returns a {@link Definitions} set by reading * configuration data from the applied sources. * * @return The definitions holder object, filled with base definitions. * @throws DefinitionsFactoryException if an error occurs reading the * sources. * @deprecated Let the Definitions Factory use it. */ @Deprecated public Definitions readDefinitions() { return new CompatibilityDefinitionsImpl(definitionDao); }
} else if (container.isValidDefinition(value, tilesRequest)) { resultMap.put(attributeName, attribute); Definition nestedDefinition = container.getDefinitionsFactory().getDefinition(value, tilesRequest); Assert.isTrue(nestedDefinition != definition, "Circular nested definition: " + value); flattenAttributeMap(container, tilesRequest, resultMap, nestedDefinition);
JstlUtils.exposeLocalizationContext(new RequestContext(request, servletContext)); Definition compositeDefinition = container.getDefinitionsFactory().getDefinition(getUrl(), tilesRequest);