| Method from org.apache.struts2.views.freemarker.FreemarkerManager Detail: |
|---|
 protected ScopesHashModel buildScopesHashModel(ServletContext servletContext,
HttpServletRequest request,
HttpServletResponse response,
ObjectWrapper wrapper,
ValueStack stack) {
ScopesHashModel model = new ScopesHashModel(wrapper, servletContext, request, stack);
// Create hash model wrapper for servlet context (the application)
// only need one thread to do this once, per servlet context
synchronized (servletContext) {
ServletContextHashModel servletContextModel = (ServletContextHashModel) servletContext.getAttribute(ATTR_APPLICATION_MODEL);
if (servletContextModel == null) {
GenericServlet servlet = JspSupportServlet.jspSupportServlet;
// TODO if the jsp support servlet isn't load-on-startup then it won't exist
// if it hasn't been accessed, and a JSP page is accessed
if (servlet != null) {
servletContextModel = new ServletContextHashModel(servlet, wrapper);
servletContext.setAttribute(ATTR_APPLICATION_MODEL, servletContextModel);
TaglibFactory taglibs = new TaglibFactory(servletContext);
servletContext.setAttribute(ATTR_JSP_TAGLIBS_MODEL, taglibs);
}
}
model.put(KEY_APPLICATION, servletContextModel);
model.put(KEY_JSP_TAGLIBS, (TemplateModel) servletContext.getAttribute(ATTR_JSP_TAGLIBS_MODEL));
}
// Create hash model wrapper for session
HttpSession session = request.getSession(false);
if (session != null) {
model.put(KEY_SESSION_MODEL, new HttpSessionHashModel(session, wrapper));
} else {
// no session means no attributes ???
// model.put(KEY_SESSION_MODEL, new SimpleHash());
}
// Create hash model wrapper for the request attributes
HttpRequestHashModel requestModel = (HttpRequestHashModel) request.getAttribute(ATTR_REQUEST_MODEL);
if ((requestModel == null) || (requestModel.getRequest() != request)) {
requestModel = new HttpRequestHashModel(request, response, wrapper);
request.setAttribute(ATTR_REQUEST_MODEL, requestModel);
}
model.put(KEY_REQUEST_MODEL, requestModel);
// Create hash model wrapper for request parameters
HttpRequestParametersHashModel reqParametersModel = (HttpRequestParametersHashModel) request.getAttribute(ATTR_REQUEST_PARAMETERS_MODEL);
if (reqParametersModel == null || requestModel.getRequest() != request) {
reqParametersModel = new HttpRequestParametersHashModel(request);
request.setAttribute(ATTR_REQUEST_PARAMETERS_MODEL, reqParametersModel);
}
model.put(KEY_REQUEST_PARAMETER_MODEL, reqParametersModel);
return model;
}
|
public SimpleHash buildTemplateModel(ValueStack stack,
Object action,
ServletContext servletContext,
HttpServletRequest request,
HttpServletResponse response,
ObjectWrapper wrapper) {
ScopesHashModel model = buildScopesHashModel(servletContext, request, response, wrapper, stack);
populateContext(model, stack, action, request, response);
for (String prefix : tagLibraries.keySet()) {
model.put(prefix, tagLibraries.get(prefix).getFreemarkerModels(stack, request, response));
}
return model;
} |
protected Configuration createConfiguration(ServletContext servletContext) throws TemplateException {
freemarker.template.Configuration configuration = new freemarker.template.Configuration();
configuration.setTemplateLoader(getTemplateLoader(servletContext));
configuration.setTemplateExceptionHandler(TemplateExceptionHandler.HTML_DEBUG_HANDLER);
configuration.setObjectWrapper(getObjectWrapper());
if (encoding != null) {
configuration.setDefaultEncoding(encoding);
}
loadSettings(servletContext, configuration);
return configuration;
} Create the instance of the freemarker Configuration object.
this implementation
- obtains the default configuration from Configuration.getDefaultConfiguration()
- sets up template loading from a ClassTemplateLoader and a WebappTemplateLoader
- sets up the object wrapper to be the BeansWrapper
- loads settings from the classpath file /freemarker.properties
|
public final synchronized Configuration getConfiguration(ServletContext servletContext) throws TemplateException {
freemarker.template.Configuration config = (freemarker.template.Configuration) servletContext.getAttribute(CONFIG_SERVLET_CONTEXT_KEY);
if (config == null) {
config = createConfiguration(servletContext);
// store this configuration in the servlet context
servletContext.setAttribute(CONFIG_SERVLET_CONTEXT_KEY, config);
}
config.setWhitespaceStripping(true);
return config;
} |
protected BeansWrapper getObjectWrapper() {
return new StrutsBeanWrapper(altMapWrapper);
} |
protected TemplateLoader getTemplateLoader(ServletContext servletContext) {
// construct a FileTemplateLoader for the init-param 'TemplatePath'
FileTemplateLoader templatePathLoader = null;
String templatePath = servletContext.getInitParameter("TemplatePath");
if (templatePath == null) {
templatePath = servletContext.getInitParameter("templatePath");
}
if (templatePath != null) {
try {
templatePathLoader = new FileTemplateLoader(new File(templatePath));
} catch (IOException e) {
LOG.error("Invalid template path specified: " + e.getMessage(), e);
}
}
// presume that most apps will require the class and webapp template loader
// if people wish to
return templatePathLoader != null ?
new MultiTemplateLoader(new TemplateLoader[]{
templatePathLoader,
new WebappTemplateLoader(servletContext),
new StrutsClassTemplateLoader()
})
: new MultiTemplateLoader(new TemplateLoader[]{
new WebappTemplateLoader(servletContext),
new StrutsClassTemplateLoader()
});
} The default template loader is a MultiTemplateLoader which includes
a ClassTemplateLoader and a WebappTemplateLoader (and a FileTemplateLoader depending on
the init-parameter 'TemplatePath').
The ClassTemplateLoader will resolve fully qualified template includes
that begin with a slash. for example /com/company/template/common.ftl
The WebappTemplateLoader attempts to resolve templates relative to the web root folder |
protected void loadSettings(ServletContext servletContext,
Configuration configuration) {
InputStream in = null;
try {
in = FileManager.loadFile("freemarker.properties", FreemarkerManager.class);
if (in != null) {
Properties p = new Properties();
p.load(in);
configuration.setSettings(p);
}
} catch (IOException e) {
LOG.error("Error while loading freemarker settings from /freemarker.properties", e);
} catch (TemplateException e) {
LOG.error("Error while loading freemarker settings from /freemarker.properties", e);
} finally {
if (in != null) {
try {
in.close();
} catch(IOException io) {
LOG.warn("Unable to close input stream", io);
}
}
}
} Load the settings from the /freemarker.properties file on the classpath |
protected void populateContext(ScopesHashModel model,
ValueStack stack,
Object action,
HttpServletRequest request,
HttpServletResponse response) {
// put the same objects into the context that the velocity result uses
Map standard = ContextUtil.getStandardContext(stack, request, response);
model.putAll(standard);
// support for JSP exception pages, exposing the servlet or JSP exception
Throwable exception = (Throwable) request.getAttribute("javax.servlet.error.exception");
if (exception == null) {
exception = (Throwable) request.getAttribute("javax.servlet.error.JspException");
}
if (exception != null) {
model.put(KEY_EXCEPTION, exception);
}
} |
public void setContainer(Container container) {
Map< String,TagLibrary > map = new HashMap< String,TagLibrary >();
Set< String > prefixes = container.getInstanceNames(TagLibrary.class);
for (String prefix : prefixes) {
map.put(prefix, container.getInstance(TagLibrary.class, prefix));
}
this.tagLibraries = Collections.unmodifiableMap(map);
} |
public void setEncoding(String encoding) {
this.encoding = encoding;
} |
public void setWrapperAltMap(String val) {
altMapWrapper = "true".equals(val);
} |
org.apache.struts2.views.freemarker.FreemarkerManager
Save This Page