Java tutorial
package org.apache.torque.generator.template.velocity; /* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you 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. */ import java.io.StringWriter; import java.io.Writer; import java.util.Properties; import java.util.Set; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.torque.generator.GeneratorException; import org.apache.torque.generator.configuration.ConfigurationException; import org.apache.torque.generator.configuration.ConfigurationProvider; import org.apache.torque.generator.control.ControllerState; import org.apache.torque.generator.option.Option; import org.apache.torque.generator.option.Options; import org.apache.torque.generator.outlet.OutletResult; import org.apache.torque.generator.qname.Namespace; import org.apache.torque.generator.qname.QualifiedName; import org.apache.torque.generator.qname.QualifiedNameMap; import org.apache.torque.generator.source.SourceElement; import org.apache.torque.generator.template.TemplateOutletImpl; import org.apache.torque.generator.variable.Variable; import org.apache.torque.generator.variable.VariableStore; import org.apache.velocity.VelocityContext; import org.apache.velocity.app.Velocity; import org.apache.velocity.context.Context; import org.apache.velocity.runtime.RuntimeConstants; import org.apache.velocity.runtime.log.Log4JLogChute; import org.apache.velocity.util.StringUtils; /** * A Outlet which uses a velocity template for generation. */ public class VelocityOutlet extends TemplateOutletImpl { /** * The name under which the Torque generator interface will be put * into the context. */ public static final String TORQUE_GEN_CONTEXT_NAME = "torqueGen"; /** * The name under which the velocity StringUtils will be put * into the context. */ public static final String STRING_UTILS_CONTEXT_NAME = "stringUtils"; /** * The key under which the null attribute of a source element is put * into the context. */ public static final String NULL_KEY_CONTEXT_NAME = "value"; /** The log. */ private static Log log = LogFactory.getLog(VelocityOutlet.class); /** * Whether the options should be put into the context. */ private boolean optionsInContext = true; /** * Whether the variables should be put into the context. */ private boolean variablesInContext = true; /** * Whether the attributes of the current source element should be put * into the context. */ private boolean sourceAttributesInContext = true; /** * Constructs a new VelocityTemplateOutlet. * * @param name the name of this outlet, not null. * @param configurationProvider the provider for reading the templates, * not null. * @param path the path to the templates, not null. * May contain tokens of the form ${....}, these are parsed. * @param encoding the encoding of the file, or null if the system's * default encoding should be used. * * @throws NullPointerException if name, path or directories are null. * @throws ConfigurationException if an error occurs while reading the * template. */ public VelocityOutlet(QualifiedName name, ConfigurationProvider configurationProvider, String path, String encoding) throws ConfigurationException { super(name, configurationProvider, path, encoding, new VelocityTemplateFilter()); } /** * Tells the outlet to put all options which name space is visible to * the namespace of this outlet into the context. * Only the variable names are used as keys in the context, the namespaces * are stripped. * * @param optionsInContext whether to put the options into the context. */ public void setOptionsInContext(boolean optionsInContext) { this.optionsInContext = optionsInContext; } /** * Returns whether all options which namespaces are visible to * the name space of this outlet are put into the context. * * @return whether the outlet puts the options into the context. */ public boolean isOptionsInContext() { return optionsInContext; } /** * Tells the outlet to put all variables which are visible to this * outlet into the context. * Only the variable names are used as keys in the context, the namespaces * are stripped. * * @param variablesInContext whether to put the variables into the context. */ public void setVariablesInContext(boolean variablesInContext) { this.variablesInContext = variablesInContext; } /** * Returns whether all variables which are visible to this * outlet are put into the context. * * @return whether the outlet puts the variables into the context. */ public boolean isVariablesInContext() { return variablesInContext; } /** * Tells the outlet to put the attributes of the current source element * into the context or not. * * @param sourceAttributesInContext whether to put the source attributes * into the context. */ public void setSourceAttributesInContext(boolean sourceAttributesInContext) { this.sourceAttributesInContext = sourceAttributesInContext; } /** * Returns whether the attributes of the current source element * are put into the context. * * @return whether the outlet puts the attributes of the current source * element into the context. */ public boolean isSourceAttributesInContext() { return sourceAttributesInContext; } /** * Executes the generation process; the result is returned. * * @param controllerState the current controller state. * * @return the result of the generation, not null. * * @see org.apache.torque.generator.outlet.Outlet#execute(ControllerState) */ @Override public OutletResult execute(ControllerState controllerState) throws GeneratorException { if (log.isDebugEnabled()) { log.debug("Start executing VelocityOutlet " + getName()); } try { try { Properties properties = new Properties(); properties.put(RuntimeConstants.RUNTIME_LOG_LOGSYSTEM_CLASS, Log4JLogChute.class.getName()); properties.put(RuntimeConstants.RUNTIME_LOG, ""); Velocity.init(properties); } catch (Exception e) { throw new GeneratorException("Could not initialize velocity", e); } SourceElement sourceElement = controllerState.getSourceElement(); String inputElementName = getInputElementName(); if (inputElementName != null && !inputElementName.equals(sourceElement.getName())) { throw new GeneratorException("Input element name, " + sourceElement.getName() + ", is not the expected name, " + getInputElementName() + ", for outlet " + getName()); } Context context = createVelocityContext(controllerState); Writer writer = new StringWriter(); try { Velocity.evaluate(context, writer, "VelocityTemplateOutlet:" + getName(), getContent(controllerState)); writer.flush(); writer.close(); } catch (Exception e) { log.error("error during execution of outlet " + getName() + " : " + e.getMessage(), e); throw new GeneratorException( "Error during execution of outlet " + getName() + " : " + e.getMessage(), e); } return new OutletResult(writer.toString()); } finally { if (log.isDebugEnabled()) { log.debug("End executing VelocityOutlet " + getName()); } } } /** * Creates the velocity context for the outlet. * * @param controllerState the controller state, not null. * @return */ private Context createVelocityContext(ControllerState controllerState) { Context context = new VelocityContext(); context.put(TORQUE_GEN_CONTEXT_NAME, new TorqueGenVelocity(this, controllerState)); context.put(STRING_UTILS_CONTEXT_NAME, new StringUtils()); if (optionsInContext) { // Only consider options visible from the current namespace. Options visibleOptions = controllerState.getVisibleOptions(); for (Option option : visibleOptions.values()) { QualifiedName qualifiedName = option.getQualifiedName(); context.put(qualifiedName.getName(), option.getValue()); } log.debug("Put options in context " + visibleOptions.keySet()); } else { log.debug("options in context are disabled"); } SourceElement sourceElement = controllerState.getSourceElement(); if (sourceAttributesInContext) { Set<String> attributes = sourceElement.getAttributeNames(); for (String key : attributes) { Object value = sourceElement.getAttribute(key); if (key == null) { // The null key cannot be accessed in the context. // So if the attribute NULL_KEY_CONTEXT_NAME does not // exist, use this as attribute name. if (sourceElement.getAttributeNames().contains(NULL_KEY_CONTEXT_NAME)) { continue; } key = NULL_KEY_CONTEXT_NAME; } context.put(key, value); } log.debug("Put attributes in context " + attributes); } else { log.debug("source attributes in context are disabled"); } if (variablesInContext) { // Only consider variables visible from the namespace // of this outlet. If a name exists in different // namespaces visible from this namespace, // only consider the most significant name. Namespace namespace = getName().getNamespace(); VariableStore variableStore = controllerState.getVariableStore(); QualifiedNameMap<Variable> visibleVariables = variableStore.getContent().getInHierarchy(namespace); for (Variable variable : visibleVariables.values()) { QualifiedName qualifiedName = variable.getName(); context.put(qualifiedName.getName(), variable.getValue()); } log.debug("Put variables in context " + visibleVariables.keySet()); } else { log.debug("variables in context are disabled"); } return context; } }