001
014
015 package com.liferay.portal.kernel.template;
016
017 import com.liferay.portal.kernel.configuration.Filter;
018 import com.liferay.portal.kernel.log.Log;
019 import com.liferay.portal.kernel.log.LogFactoryUtil;
020 import com.liferay.portal.kernel.util.PropsUtil;
021 import com.liferay.portal.kernel.util.Validator;
022 import com.liferay.registry.Registry;
023 import com.liferay.registry.RegistryUtil;
024 import com.liferay.registry.ServiceReference;
025 import com.liferay.registry.ServiceTracker;
026 import com.liferay.registry.ServiceTrackerCustomizer;
027
028 import java.util.Collection;
029 import java.util.Collections;
030 import java.util.HashMap;
031 import java.util.HashSet;
032 import java.util.Map;
033 import java.util.Set;
034 import java.util.concurrent.ConcurrentHashMap;
035
036
040 public class TemplateManagerUtil {
041
042 public static void destroy() {
043 _instance._destroy();
044 }
045
046 public static void destroy(ClassLoader classLoader) {
047 _instance._destroy(classLoader);
048 }
049
050 public static Set<String> getSupportedLanguageTypes(String propertyKey) {
051 return _instance._getSupportedLanguageTypes(propertyKey);
052 }
053
054 public static Template getTemplate(
055 String templateManagerName, TemplateResource templateResource,
056 boolean restricted)
057 throws TemplateException {
058
059 return _instance._getTemplate(
060 templateManagerName, templateResource, restricted);
061 }
062
063 public static Template getTemplate(
064 String templateManagerName, TemplateResource templateResource,
065 TemplateResource errorTemplateResource, boolean restricted)
066 throws TemplateException {
067
068 return _instance._getTemplate(
069 templateManagerName, templateResource, errorTemplateResource,
070 restricted);
071 }
072
073 public static TemplateManager getTemplateManager(
074 String templateManagerName) {
075
076 return _instance._getTemplateManager(templateManagerName);
077 }
078
079 public static Set<String> getTemplateManagerNames() {
080 return _instance._getTemplateManagerNames();
081 }
082
083 public static Map<String, TemplateManager> getTemplateManagers() {
084 return _instance._getTemplateManagers();
085 }
086
087 public static boolean hasTemplateManager(String templateManagerName) {
088 return _instance._hasTemplateManager(templateManagerName);
089 }
090
091 private TemplateManagerUtil() {
092 Registry registry = RegistryUtil.getRegistry();
093
094 com.liferay.registry.Filter filter = registry.getFilter(
095 "(&(language.type=*)(objectClass=" +
096 TemplateManager.class.getName() + "))");
097
098 _serviceTracker = registry.trackServices(
099 filter, new TemplateManagerServiceTrackerCustomizer());
100
101 _serviceTracker.open();
102 }
103
104 private void _destroy() {
105 Map<String, TemplateManager> templateManagers = _getTemplateManagers();
106
107 for (TemplateManager templateManager : templateManagers.values()) {
108 templateManager.destroy();
109 }
110
111 templateManagers.clear();
112 }
113
114 private void _destroy(ClassLoader classLoader) {
115 Map<String, TemplateManager> templateManagers = _getTemplateManagers();
116
117 for (TemplateManager templateManager : templateManagers.values()) {
118 templateManager.destroy(classLoader);
119 }
120 }
121
122 private Set<String> _getSupportedLanguageTypes(String propertyKey) {
123 Set<String> supportedLanguageTypes = _supportedLanguageTypes.get(
124 propertyKey);
125
126 if (supportedLanguageTypes != null) {
127 return supportedLanguageTypes;
128 }
129
130 Map<String, TemplateManager> templateManagers = _getTemplateManagers();
131
132 supportedLanguageTypes = new HashSet<>();
133
134 for (String templateManagerName : templateManagers.keySet()) {
135 String content = PropsUtil.get(
136 propertyKey, new Filter(templateManagerName));
137
138 if (Validator.isNotNull(content)) {
139 supportedLanguageTypes.add(templateManagerName);
140 }
141 }
142
143 supportedLanguageTypes = Collections.unmodifiableSet(
144 supportedLanguageTypes);
145
146 _supportedLanguageTypes.put(propertyKey, supportedLanguageTypes);
147
148 return supportedLanguageTypes;
149 }
150
151 private Template _getTemplate(
152 String templateManagerName, TemplateResource templateResource,
153 boolean restricted)
154 throws TemplateException {
155
156 TemplateManager templateManager = _getTemplateManagerChecked(
157 templateManagerName);
158
159 return templateManager.getTemplate(templateResource, restricted);
160 }
161
162 private Template _getTemplate(
163 String templateManagerName, TemplateResource templateResource,
164 TemplateResource errorTemplateResource, boolean restricted)
165 throws TemplateException {
166
167 TemplateManager templateManager = _getTemplateManagerChecked(
168 templateManagerName);
169
170 return templateManager.getTemplate(
171 templateResource, errorTemplateResource, restricted);
172 }
173
174 private TemplateManager _getTemplateManager(String templateManagerName) {
175 Collection<TemplateManager> templateManagers =
176 _templateManagers.values();
177
178 for (TemplateManager templateManager : templateManagers) {
179 if (templateManagerName.equals(templateManager.getName())) {
180 return templateManager;
181 }
182 }
183
184 return null;
185 }
186
187 private TemplateManager _getTemplateManagerChecked(
188 String templateManagerName)
189 throws TemplateException {
190
191 Collection<TemplateManager> templateManagers =
192 _templateManagers.values();
193
194 for (TemplateManager templateManager : templateManagers) {
195 if (templateManagerName.equals(templateManager.getName())) {
196 return templateManager;
197 }
198 }
199
200 throw new TemplateException(
201 "Unsupported template manager " + templateManagerName);
202 }
203
204 private Set<String> _getTemplateManagerNames() {
205 Map<String, TemplateManager> templateManagers = _getTemplateManagers();
206
207 return templateManagers.keySet();
208 }
209
210 private Map<String, TemplateManager> _getTemplateManagers() {
211 Map<String, TemplateManager> map = new HashMap<>();
212
213 Collection<TemplateManager> templateManagers =
214 _templateManagers.values();
215
216 for (TemplateManager templateManager : templateManagers) {
217 map.put(templateManager.getName(), templateManager);
218 }
219
220 return Collections.unmodifiableMap(map);
221 }
222
223 private boolean _hasTemplateManager(String templateManagerName) {
224 Collection<TemplateManager> templateManagers =
225 _templateManagers.values();
226
227 for (TemplateManager templateManager : templateManagers) {
228 if (templateManagerName.equals(templateManager.getName())) {
229 return true;
230 }
231 }
232
233 return false;
234 }
235
236 private static final Log _log = LogFactoryUtil.getLog(
237 TemplateManagerUtil.class);
238
239 private static final TemplateManagerUtil _instance =
240 new TemplateManagerUtil();
241
242 private final ServiceTracker<TemplateManager, TemplateManager>
243 _serviceTracker;
244 private final Map<String, Set<String>> _supportedLanguageTypes =
245 new ConcurrentHashMap<>();
246 private final Map<ServiceReference<TemplateManager>, TemplateManager>
247 _templateManagers = new ConcurrentHashMap<>();
248
249 private class TemplateManagerServiceTrackerCustomizer
250 implements ServiceTrackerCustomizer<TemplateManager, TemplateManager> {
251
252 @Override
253 public TemplateManager addingService(
254 ServiceReference<TemplateManager> serviceReference) {
255
256 Registry registry = RegistryUtil.getRegistry();
257
258 TemplateManager templateManager = registry.getService(
259 serviceReference);
260
261 String name = templateManager.getName();
262
263 try {
264 templateManager.init();
265
266 _templateManagers.put(serviceReference, templateManager);
267 }
268 catch (TemplateException te) {
269 if (_log.isWarnEnabled()) {
270 _log.warn(
271 "unable to init " + name + " Template Manager ", te);
272 }
273 }
274
275 return templateManager;
276 }
277
278 @Override
279 public void modifiedService(
280 ServiceReference<TemplateManager> serviceReference,
281 TemplateManager templateManager) {
282 }
283
284 @Override
285 public void removedService(
286 ServiceReference<TemplateManager> serviceReference,
287 TemplateManager templateManager) {
288
289 Registry registry = RegistryUtil.getRegistry();
290
291 registry.ungetService(serviceReference);
292
293 _templateManagers.remove(serviceReference);
294
295 templateManager.destroy();
296 }
297
298 }
299
300 }