Java tutorial
package com.ei.itop.common.tag; /* * Copyright 2002-2008 the original author or authors. * * 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. */ import java.io.IOException; import java.util.Collection; import java.util.Locale; import javax.servlet.http.Cookie; import javax.servlet.http.HttpServletRequest; import javax.servlet.jsp.JspException; import javax.servlet.jsp.JspTagException; import org.apache.log4j.Logger; import org.springframework.context.MessageSource; import org.springframework.context.MessageSourceResolvable; import org.springframework.context.NoSuchMessageException; import org.springframework.util.ObjectUtils; import org.springframework.util.StringUtils; import org.springframework.web.servlet.tags.HtmlEscapeTag; import org.springframework.web.servlet.tags.HtmlEscapingAwareTag; import org.springframework.web.util.ExpressionEvaluationUtils; import org.springframework.web.util.HtmlUtils; import org.springframework.web.util.JavaScriptUtils; import org.springframework.web.util.TagUtils; import org.springframework.web.util.WebUtils; /** * Custom JSP tag to look up a message in the scope of this page. Messages are * resolved using the ApplicationContext and thus support internationalization. * * <p>Detects an HTML escaping setting, either on this tag instance, the page level, * or the <code>web.xml</code> level. Can also apply JavaScript escaping. * * <p>If "code" isn't set or cannot be resolved, "text" will be used as default * message. Thus, this tag can also be used for HTML escaping of any texts. * * @author Rod Johnson * @author Juergen Hoeller * @see #setCode * @see #setText * @see #setHtmlEscape * @see #setJavaScriptEscape * @see HtmlEscapeTag#setDefaultHtmlEscape * @see org.springframework.web.util.WebUtils#HTML_ESCAPE_CONTEXT_PARAM */ public class MessageTag extends HtmlEscapingAwareTag { private static final Logger log = Logger.getLogger(MessageTag.class); /** * Default separator for splitting an arguments String: a comma (",") */ public static final String DEFAULT_ARGUMENT_SEPARATOR = ","; private Object message; private String code; private Object arguments; private String argumentSeparator = DEFAULT_ARGUMENT_SEPARATOR; private String text; private String var; private String scope = TagUtils.SCOPE_PAGE; private boolean javaScriptEscape = false; /** * Set the MessageSourceResolvable for this tag. * Accepts a direct MessageSourceResolvable instance as well as a JSP * expression language String that points to a MessageSourceResolvable. * <p>If a MessageSourceResolvable is specified, it effectively overrides * any code, arguments or text specified on this tag. */ public void setMessage(Object message) { this.message = message; } /** * Set the message code for this tag. */ public void setCode(String code) { this.code = code; } /** * Set optional message arguments for this tag, as a comma-delimited * String (each String argument can contain JSP EL), an Object array * (used as argument array), or a single Object (used as single argument). */ public void setArguments(Object arguments) { this.arguments = arguments; } /** * Set the separator to use for splitting an arguments String. * Default is a comma (","). * @see #setArguments */ public void setArgumentSeparator(String argumentSeparator) { this.argumentSeparator = argumentSeparator; } /** * Set the message text for this tag. */ public void setText(String text) { this.text = text; } /** * Set PageContext attribute name under which to expose * a variable that contains the resolved message. * @see #setScope * @see javax.servlet.jsp.PageContext#setAttribute */ public void setVar(String var) { this.var = var; } /** * Set the scope to export the variable to. * Default is SCOPE_PAGE ("page"). * @see #setVar * @see org.springframework.web.util.TagUtils#SCOPE_PAGE * @see javax.servlet.jsp.PageContext#setAttribute */ public void setScope(String scope) { this.scope = scope; } /** * Set JavaScript escaping for this tag, as boolean value. * Default is "false". */ public void setJavaScriptEscape(String javaScriptEscape) throws JspException { this.javaScriptEscape = ExpressionEvaluationUtils.evaluateBoolean("javaScriptEscape", javaScriptEscape, pageContext); } /** * Resolves the message, escapes it if demanded, * and writes it to the page (or exposes it as variable). * @see #resolveMessage() * @see org.springframework.web.util.HtmlUtils#htmlEscape(String) * @see org.springframework.web.util.JavaScriptUtils#javaScriptEscape(String) * @see #writeMessage(String) */ @Override protected final int doStartTagInternal() throws JspException, IOException { try { // Resolve the unescaped message. String msg = resolveMessage(); // HTML and/or JavaScript escape, if demanded. msg = isHtmlEscape() ? HtmlUtils.htmlEscape(msg) : msg; msg = this.javaScriptEscape ? JavaScriptUtils.javaScriptEscape(msg) : msg; // Expose as variable, if demanded, else write to the page. String resolvedVar = ExpressionEvaluationUtils.evaluateString("var", this.var, pageContext); if (resolvedVar != null) { String resolvedScope = ExpressionEvaluationUtils.evaluateString("scope", this.scope, pageContext); pageContext.setAttribute(resolvedVar, msg, TagUtils.getScope(resolvedScope)); } else { writeMessage(msg); } return EVAL_BODY_INCLUDE; } catch (NoSuchMessageException ex) { throw new JspTagException(getNoSuchMessageExceptionDescription(ex)); } } /** * Resolve the specified message into a concrete message String. * The returned message String should be unescaped. */ protected String resolveMessage() throws JspException, NoSuchMessageException { MessageSource messageSource = getMessageSource(); if (messageSource == null) { throw new JspTagException("No corresponding MessageSource found"); } // Evaluate the specified MessageSourceResolvable, if any. MessageSourceResolvable resolvedMessage = null; if (this.message instanceof MessageSourceResolvable) { resolvedMessage = (MessageSourceResolvable) this.message; } else if (this.message != null) { String expr = this.message.toString(); resolvedMessage = (MessageSourceResolvable) ExpressionEvaluationUtils.evaluate("message", expr, MessageSourceResolvable.class, pageContext); } if (resolvedMessage != null) { // We have a given MessageSourceResolvable. return messageSource.getMessage(resolvedMessage, getRequestContext().getLocale()); } String resolvedCode = ExpressionEvaluationUtils.evaluateString("code", this.code, pageContext); String resolvedText = ExpressionEvaluationUtils.evaluateString("text", this.text, pageContext); if (resolvedCode != null || resolvedText != null) { // We have a code or default text that we need to resolve. Object[] argumentsArray = resolveArguments(this.arguments); if (resolvedText != null) { return messageSource.getMessage(resolvedCode, argumentsArray, resolvedText, getLocale()); } else { return messageSource.getMessage(resolvedCode, argumentsArray, getLocale()); } } // All we have is a specified literal text. return resolvedText; } private Locale getLocale() { Cookie cookie = WebUtils.getCookie((HttpServletRequest) pageContext.getRequest(), "locale"); if (cookie != null) { return StringUtils.parseLocaleString(cookie.getValue()); } else { return Locale.ENGLISH; } } /** * Resolve the given arguments Object into an arguments array. * @param arguments the specified arguments Object * @return the resolved arguments as array * @throws JspException if argument conversion failed * @see #setArguments */ protected Object[] resolveArguments(Object arguments) throws JspException { if (arguments instanceof String) { String[] stringArray = StringUtils.delimitedListToStringArray((String) arguments, this.argumentSeparator); if (stringArray.length == 1) { Object argument = ExpressionEvaluationUtils.evaluate("argument", stringArray[0], pageContext); if (argument != null && argument.getClass().isArray()) { return ObjectUtils.toObjectArray(argument); } else { return new Object[] { argument }; } } else { Object[] argumentsArray = new Object[stringArray.length]; for (int i = 0; i < stringArray.length; i++) { argumentsArray[i] = ExpressionEvaluationUtils.evaluate("argument[" + i + "]", stringArray[i], pageContext); } return argumentsArray; } } else if (arguments instanceof Object[]) { return (Object[]) arguments; } else if (arguments instanceof Collection) { return ((Collection) arguments).toArray(); } else if (arguments != null) { // Assume a single argument object. return new Object[] { arguments }; } else { return null; } } /** * Write the message to the page. * <p>Can be overridden in subclasses, e.g. for testing purposes. * @param msg the message to write * @throws IOException if writing failed */ protected void writeMessage(String msg) throws IOException { pageContext.getOut().write(String.valueOf(msg)); } /** * Use the current RequestContext's application context as MessageSource. */ protected MessageSource getMessageSource() { return getRequestContext().getMessageSource(); } /** * Return default exception message. */ protected String getNoSuchMessageExceptionDescription(NoSuchMessageException ex) { return ex.getMessage(); } }