/*
* Copyright (c) 2002-2012 Alibaba Group Holding Limited.
* All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.citrus.service.velocity.impl;
import static com.alibaba.citrus.util.Assert.ExceptionType.*;
import static com.alibaba.citrus.util.Assert.*;
import static com.alibaba.citrus.util.CollectionUtil.*;
import java.lang.reflect.Method;
import java.util.List;
import com.alibaba.citrus.service.template.TemplateException;
import com.alibaba.citrus.service.velocity.FastCloneable;
import org.apache.velocity.app.event.EventCartridge;
import org.apache.velocity.app.event.EventHandler;
import org.apache.velocity.runtime.RuntimeServices;
import org.apache.velocity.util.ContextAware;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 扩展<code>EventCartridge</code>，增加如下功能：
* <ul>
* <li>只在系统初始化的时候初始化一次。</li>
* <li>假如event handler实现了<code>ContextAware</code>接口，则每次执行时复制一份。</li>
* </ul>
*
* @author Michael Zhou
*/
public class CloneableEventCartridge extends EventCartridge {
private final static Logger log = LoggerFactory.getLogger(CloneableEventCartridge.class);
private final static Method cloneMethod = getCloneMethod();
private final List<EventHandler> allHandlers = createLinkedList();
private boolean initialized;
private boolean needsClone = false;
private static Method getCloneMethod() {
Method method = null;
try {
method = Object.class.getDeclaredMethod("clone");
method.setAccessible(true);
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
throw new RuntimeException(e);
}
return method;
}
/** 在系统启动时初始化一次。 */
public void initOnce(RuntimeServices rs) throws Exception {
if (!initialized) {
super.initialize(rs);
initialized = true;
}
}
@Override
public void initialize(RuntimeServices rs) throws Exception {
assertTrue(initialized, ILLEGAL_STATE, "not initialized yet");
}
@Override
public boolean addEventHandler(EventHandler ev) {
boolean supported = super.addEventHandler(ev);
if (supported) {
allHandlers.add(ev);
if (ev instanceof ContextAware) {
needsClone = true;
if (!(ev instanceof FastCloneable)) {
if (ev instanceof Cloneable) {
log.warn("EventHandler which implements ContextAware and Cloneable "
+ "may slow down the velocity rendering process: {}", ev.getClass().getName());
} else {
throw new IllegalArgumentException(
"EventHandler which implements ContextAware should also implements FastCloneable or Cloneable: "
+ ev.getClass().getName());
}
}
}
}
return supported;
}
public EventCartridge getRuntimeInstance() {
EventCartridge runtimeInstance = this;
if (needsClone) {
runtimeInstance = new EventCartridge();
for (EventHandler ev : allHandlers) {
if (ev instanceof ContextAware) {
if (ev instanceof FastCloneable) {
ev = (EventHandler) ((FastCloneable) ev).createCopy();
} else {
try {
ev = (EventHandler) cloneMethod.invoke(ev);
} catch (Exception e) {
throw new TemplateException("Could not clone a ContextAware event handler: "
+ ev.getClass().getName(), e);
}
}
}
runtimeInstance.addEventHandler(ev);
}
}
return runtimeInstance;
}
}