`
yangyangmyself
  • 浏览: 232969 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类
最新评论

设计模式之模板方法

    博客分类:
  • Java
阅读更多
引用
模板类


/*
 * Copyright 2002-2007 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.
 */

package org.springframework.web.servlet.mvc;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.support.WebContentGenerator;
import org.springframework.web.util.WebUtils;

/**
 * <p>Convenient superclass for controller implementations, using the Template
 * Method design pattern.</p>
 * 
 * <p>As stated in the {@link org.springframework.web.servlet.mvc.Controller Controller}
 * interface, a lot of functionality is already provided by certain abstract
 * base controllers. The AbstractController is one of the most important
 * abstract base controller providing basic features such as the generation
 * of caching headers and the enabling or disabling of
 * supported methods (GET/POST).</p>
 *
 * <p><b><a name="workflow">Workflow
 * (<a href="Controller.html#workflow">and that defined by interface</a>):</b><br>
 * <ol>
 *  <li>{@link #handleRequest(HttpServletRequest,HttpServletResponse) handleRequest()}
 *      will be called by the DispatcherServlet</li>
 *  <li>Inspection of supported methods (ServletException if request method
 *      is not support)</li>
 *  <li>If session is required, try to get it (ServletException if not found)</li>
 *  <li>Set caching headers if needed according to the cacheSeconds property</li>
 *  <li>Call abstract method {@link #handleRequestInternal(HttpServletRequest,HttpServletResponse) handleRequestInternal()}
 *      (optionally synchronizing around the call on the HttpSession),
 *      which should be implemented by extending classes to provide actual
 *      functionality to return {@link org.springframework.web.servlet.ModelAndView ModelAndView} objects.</li>
 * </ol>
 * </p>
 *
 * <p><b><a name="config">Exposed configuration properties</a>
 * (<a href="Controller.html#config">and those defined by interface</a>):</b><br>
 * <table border="1">
 *  <tr>
 *      <td><b>name</b></th>
 *      <td><b>default</b></td>
 *      <td><b>description</b></td>
 *  </tr>
 *  <tr>
 *      <td>supportedMethods</td>
 *      <td>GET,POST</td>
 *      <td>comma-separated (CSV) list of methods supported by this controller,
 *          such as GET, POST and PUT</td>
 *  </tr>
 *  <tr>
 *      <td>requireSession</td>
 *      <td>false</td>
 *      <td>whether a session should be required for requests to be able to
 *          be handled by this controller. This ensures that derived controller
 *          can - without fear of null pointers - call request.getSession() to
 *          retrieve a session. If no session can be found while processing
 *          the request, a ServletException will be thrown</td>
 *  </tr>
 *  <tr>
 *      <td>cacheSeconds</td>
 *      <td>-1</td>
 *      <td>indicates the amount of seconds to include in the cache header
 *          for the response following on this request. 0 (zero) will include
 *          headers for no caching at all, -1 (the default) will not generate
 *          <i>any headers</i> and any positive number will generate headers
 *          that state the amount indicated as seconds to cache the content</td>
 *  </tr>
 *  <tr>
 *      <td>synchronizeOnSession</td>
 *      <td>false</td>
 *      <td>whether the call to <code>handleRequestInternal</code> should be
 *          synchronized around the HttpSession, to serialize invocations
 *          from the same client. No effect if there is no HttpSession.
 *      </td>
 *  </tr>
 * </table>
 *
 * @author Rod Johnson
 * @author Juergen Hoeller
 * @see WebContentInterceptor
 */
public abstract class AbstractController extends WebContentGenerator implements Controller {

	private boolean synchronizeOnSession = false;


	/**
	 * Set if controller execution should be synchronized on the session,
	 * to serialize parallel invocations from the same client.
	 * <p>More specifically, the execution of the <code>handleRequestInternal</code>
	 * method will get synchronized if this flag is "true". The best available
	 * session mutex will be used for the synchronization; ideally, this will
	 * be a mutex exposed by HttpSessionMutexListener.
	 * <p>The session mutex is guaranteed to be the same object during
	 * the entire lifetime of the session, available under the key defined
	 * by the <code>SESSION_MUTEX_ATTRIBUTE</code> constant. It serves as a
	 * safe reference to synchronize on for locking on the current session.
	 * <p>In many cases, the HttpSession reference itself is a safe mutex
	 * as well, since it will always be the same object reference for the
	 * same active logical session. However, this is not guaranteed across
	 * different servlet containers; the only 100% safe way is a session mutex.
	 * @see org.springframework.web.servlet.mvc.AbstractController#handleRequestInternal
	 * @see org.springframework.web.util.HttpSessionMutexListener
	 * @see org.springframework.web.util.WebUtils#getSessionMutex(javax.servlet.http.HttpSession)
	 */
	public final void setSynchronizeOnSession(boolean synchronizeOnSession) {
		this.synchronizeOnSession = synchronizeOnSession;
	}

	/**
	 * Return whether controller execution should be synchronized on the session.
	 */
	public final boolean isSynchronizeOnSession() {
		return this.synchronizeOnSession;
	}


	public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response)
			throws Exception {

		// Delegate to WebContentGenerator for checking and preparing.
		checkAndPrepare(request, response, this instanceof LastModified);

		// Execute handleRequestInternal in synchronized block if required.
		if (this.synchronizeOnSession) {
			HttpSession session = request.getSession(false);
			if (session != null) {
				Object mutex = WebUtils.getSessionMutex(session);
				synchronized (mutex) {
					return handleRequestInternal(request, response);
				}
			}
		}
		
		return handleRequestInternal(request, response);
	}

	/**
	 * Template method. Subclasses must implement this.
	 * The contract is the same as for <code>handleRequest</code>.
	 * @see #handleRequest
	 */
	protected abstract ModelAndView handleRequestInternal(HttpServletRequest request, HttpServletResponse response)
	    throws Exception;

}


引用
子类

/*
 * 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.
 */

package org.springframework.web.servlet.mvc.multiaction;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;


public class MultiActionController extends AbstractController {


	//-----------------------------------
	// Implementation of AbstractController
	//----------------------------------

	/**
	 * Determine a handler method and invoke it.
	 * @see MethodNameResolver#getHandlerMethodName
	 * @see #invokeNamedMethod
	 * @see #handleNoSuchRequestHandlingMethod
	 */
	@Override
	protected ModelAndView handleRequestInternal(HttpServletRequest request, HttpServletResponse response)
			throws Exception {
		try {
			String methodName = this.methodNameResolver.getHandlerMethodName(request);
			return invokeNamedMethod(methodName, request, response);
		}
		catch (NoSuchRequestHandlingMethodException ex) {
			return handleNoSuchRequestHandlingMethod(ex, request, response);
		}
	}


}
分享到:
评论

相关推荐

    设计模式之模板方法模式

    模板方法模式是面向对象设计模式中的行为模式之一,它在Java等面向对象编程语言中有着广泛的应用。模板方法模式的主要思想是在一个抽象类中定义一个算法的骨架,而将一些步骤延迟到子类中实现。这样,子类可以重写...

    深入浅出设计模式之模板方法模式

    ### 深入浅出设计模式之模板方法模式 #### 一、模板方法模式概述 设计模式是软件工程中一种非常重要的技术手段,它能够帮助我们解决常见的编程问题,并提高代码的可重用性、可扩展性和可维护性。模板方法模式是一...

    Java设计模式之模板方法模式Java认证考试.pdf

    Java设计模式之模板方法模式Java认证考试 Java设计模式之模板方法模式是Java认证考试中的一种重要的设计模式,它通过使用继承关系来定义一个操作中的算法骨架,而将一些步骤延迟到子类中,使得子类可以不改变一个...

    设计模式之模板方法测试代码

    在这个场景下,"设计模式之模板方法测试代码"指的是一个用于验证模板方法模式实现的C++代码示例。 模板方法模式的核心思想是封装不变的部分,定义可变的行为。这种模式通常用于当有多个类实现了相同算法的不同部分...

    Android编程设计模式之模板方法模式详解

    本文实例讲述了Android编程设计模式之模板方法模式。分享给大家供大家参考,具体如下: 一、介绍 在面向对象开发过程中,通常会遇到这样的一个问题,我们知道一个算法所需的关键步骤,并确定了这些步骤的执行顺序,...

    Java设计模式之模板方法模式.rar

    模板方法模式是面向对象设计模式中的行为模式之一,它在Java编程中有着广泛的应用。这种模式定义了一个操作中的算法骨架,而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定...

    设计模式之模板方法模式Java实现和类设计图

    模板方法模式是软件设计模式中的一种行为模式,它在面向对象设计中扮演着重要的角色,尤其是在代码复用和保持代码结构整洁方面。该模式定义了一个操作中的算法骨架,而将一些步骤延迟到子类中。使得子类可以不改变一...

    设计模式-模板方法模式ppt

    ### 设计模式之模板方法模式解析 #### 一、引言 在软件开发过程中,我们经常面临这样的场景:有一些步骤是固定的,而某些步骤则可能因具体实现而异。为了解决这类问题,设计模式中引入了一种叫做“模板方法模式”的...

    设计模式之模板方法(Template)

    模板方法设计模式是一种行为设计模式,它...模板方法设计模式是设计模式中的基础模式之一,理解并正确使用它可以提高软件的灵活性、可维护性和扩展性。在实际开发中,我们应该根据需求灵活运用,以达到最佳的设计效果。

    Java设计模式之模板方法模式.docx

    模板方法模式是一种行为设计模式,它允许在抽象类中定义算法框架,而将具体步骤的实现推迟到子类中。这种模式通常用于那些算法的骨架已经固定,但部分步骤可以根据具体环境有所不同的情况。 在Java中,模板方法模式...

    Python设计模式之模板方法模式实例详解

    本文实例讲述了Python设计模式之模板方法模式。分享给大家供大家参考,具体如下: 模板方法模式(Template Method Pattern):定义一个操作中的算法骨架,将一些步骤延迟至子类中.模板方法使得子类可以不改变一个算法的...

    java设计模式之模板方法模式详解

    "java设计模式之模板方法模式详解" 模板方法模式是一种行为设计模式,主要用于定义一个操作中的算法的骨架,而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。...

    Java经典设计模式之模板方法模式定义与用法示例

    Java经典设计模式之模板方法模式定义与用法示例 模板方法模式(Template Method Pattern)是一种行为设计模式,它定义了一个操作中的算法骨架,而将一些步骤延迟到子类中去执行。模板方法模式使得子类可以不改变一...

    设计模式的模板方法模式的例子

    模板方法模式是设计模式中行为模式的一种,它在软件工程中扮演着重要的角色,尤其是在创建算法框架时。这种模式允许我们在抽象类中定义一个算法的骨架,而将一些步骤延迟到子类中实现,使得子类可以不改变算法的结构...

    设计模式--模板方法模式java例子

    模板方法模式是设计模式中行为型模式的一种,它在软件工程中扮演着非常重要的角色,尤其是在Java编程中。模板方法模式定义了一个操作中的算法骨架,而将一些步骤延迟到子类中。它允许子类不改变一个算法的结构即可重...

    Head First 设计模式 (八) 模板方法模式(Template Method pattern) C++实现

    模板方法模式是设计模式中的一种行为模式,它在软件工程中扮演着重要的角色,尤其是在C++这样的面向对象编程语言中。这种模式定义了一个操作中的算法骨架,而将一些步骤延迟到子类中。使得子类可以不改变一个算法的...

    策略模式结合模板方法模式

    策略模式结合模板方法模式的设计思路 策略模式结合模板方法模式是策略模式的一种变形,目的是为了解决策略模式中的一些共性问题。在策略模式中,经常会出现这样一种情况,就是发现这一系列算法的实现上存在公共功能...

    C++设计模式之模板方法模式(TemplateMethod)

    模板方法模式是面向对象设计模式中的一种,它属于行为模式,主要用来定义对象间的一系列操作顺序,而将一些步骤的实现延迟到子类中。这样可以使得子类不改变算法的结构即可重定义该算法的某些特定步骤,从而实现多态...

Global site tag (gtag.js) - Google Analytics