View Javadoc

1   /*
2    * $Id: TemplateEngineManager.java 491656 2007-01-01 22:10:12Z mrdon $
3    *
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *  http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  package org.apache.struts2.components.template;
22  
23  import java.util.Collections;
24  import java.util.HashMap;
25  import java.util.Map;
26  import java.util.Set;
27  
28  import com.opensymphony.xwork2.config.ConfigurationException;
29  import com.opensymphony.xwork2.inject.Container;
30  import com.opensymphony.xwork2.inject.Inject;
31  
32  /***
33   * The TemplateEngineManager will return a template engine for the template
34   */
35  public class TemplateEngineManager {
36      public static final String DEFAULT_TEMPLATE_TYPE_CONFIG_KEY = "struts.ui.templateSuffix";
37  
38      /*** The default template extenstion is <code>ftl</code>. */
39      public static final String DEFAULT_TEMPLATE_TYPE = "ftl";
40  
41      
42      Map<String,EngineFactory> templateEngines = new HashMap<String,EngineFactory>();
43      Container container;
44      String defaultTemplateType;
45      
46      @Inject(DEFAULT_TEMPLATE_TYPE_CONFIG_KEY)
47      public void setDefaultTemplateType(String type) {
48          this.defaultTemplateType = type;
49      }
50      
51      @Inject
52      public void setContainer(Container container) {
53          this.container = container;
54          Map<String,EngineFactory> map = new HashMap<String,EngineFactory>();
55          Set<String> prefixes = container.getInstanceNames(TemplateEngine.class);
56          for (String prefix : prefixes) {
57              map.put(prefix, new LazyEngineFactory(prefix));
58          }
59          this.templateEngines = Collections.unmodifiableMap(map);
60          
61      }
62      
63      /***
64       * Registers the given template engine.
65       * <p/>
66       * Will add the engine to the existing list of known engines.
67       * @param templateExtension  filename extension (eg. .jsp, .ftl, .vm).
68       * @param templateEngine     the engine.
69       */
70      public void registerTemplateEngine(String templateExtension, final TemplateEngine templateEngine) {
71          templateEngines.put(templateExtension, new EngineFactory() {
72              public TemplateEngine create() {
73                  return templateEngine;
74              }
75          });
76      }
77  
78      /***
79       * Gets the TemplateEngine for the template name. If the template name has an extension (for instance foo.jsp), then
80       * this extension will be used to look up the appropriate TemplateEngine. If it does not have an extension, it will
81       * look for a Configuration setting "struts.ui.templateSuffix" for the extension, and if that is not set, it
82       * will fall back to "ftl" as the default.
83       *
84       * @param template               Template used to determine which TemplateEngine to return
85       * @param templateTypeOverride Overrides the default template type
86       * @return the engine.
87       */
88      public TemplateEngine getTemplateEngine(Template template, String templateTypeOverride) {
89          String templateType = DEFAULT_TEMPLATE_TYPE;
90          String templateName = template.toString();
91          if (templateName.indexOf(".") > 0) {
92              templateType = templateName.substring(templateName.indexOf(".") + 1);
93          } else if (templateTypeOverride !=null && templateTypeOverride.length() > 0) {
94              templateType = templateTypeOverride;
95          } else {
96              String type = defaultTemplateType;
97              if (type != null) {
98                  templateType = type;
99              }
100         }
101         return templateEngines.get(templateType).create();
102     }
103 
104     /*** Abstracts loading of the template engine */
105     interface EngineFactory {
106         public TemplateEngine create();
107     }    
108 
109     /*** 
110      * Allows the template engine to be loaded at request time, so that engines that are missing
111      * dependencies aren't accessed if never used.
112      */
113     class LazyEngineFactory implements EngineFactory {
114         private String name;
115         public LazyEngineFactory(String name) {
116             this.name = name;
117         }    
118         public TemplateEngine create() {
119             TemplateEngine engine = container.getInstance(TemplateEngine.class, name);
120             if (engine == null) {
121                 throw new ConfigurationException("Unable to locate template engine: "+name);
122             }
123             return engine;
124         }    
125     }    
126 }