SSM與SSH的區別
## ssm與ssh
SSH 通常指的是 Struts2 做前端控制器，Spring 管理各層的元件，Hibernate 負責持久化層。
SSM 則指的是 SpringMVC 做前端控制器，Spring 管理各層的元件，MyBatis 負責持久化層。
共同之處是都使用了Spring的依賴注入DI來管理各層的元件，使用了面向切面程式設計AOP來實現日誌管理，許可權認證，事務等通用功能的切入。
不同之處是 Struts2 和 SpringMVC 做前端控制器的區別，以及 Hibernate 和 MyBatis 做持久化時的區別。但是，Struts2 也可以和 MyBatis 搭配使用，SpringMVC 也可以和 Hibernate 搭配使用。本文為了簡化對比，指定 Struts2 要和 Hibernate 搭配，SpringMVC 要和 MyBatis 搭配。
SSH 和 SSM 的實現原理區別
所在分層 SSH SSM
頁面層(View) JSP JSP
控制器層(Controller) Struts2 SpringMVC
業務層(Service) Java Java
持久層(DAO) Hibernate MyBatis
資料庫層(DB) MySQL/Oracle MySQL/Oracle
元件管理(Bean) Spring Spring
--------------------------------------------------------------------------------
(1) Struts2 的原理
一個請求在Struts2框架中的處理大概分為以下幾個步驟：
1、客戶端初始化一個指向Servlet容器（例如Tomcat）的請求
2、這個請求經過一系列的過濾器（Filter）（這些過濾器中有一個叫做ActionContextCleanUp的可選過濾器，這個過濾器對於Struts2和其他框架的整合很有幫助，例如：SiteMesh Plugin）
FilterDispatcher是控制器的核心，就是mvc中c控制層的核心。下面粗略的分析下FilterDispatcher工作流程和原理：FilterDispatcher進行初始化並啟用核心doFilter。
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
showDeprecatedWarning();
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) res;
ServletContext servletContext = getServletContext();
String timerKey = "FilterDispatcher_doFilter: ";
try {
// FIXME: this should be refactored better to not duplicate work with the action invocation
ValueStack stack = dispatcher.getContainer().getInstance(ValueStackFactory.class).createValueStack();
ActionContext ctx = new ActionContext(stack.getContext());
ActionContext.setContext(ctx);
UtilTimerStack.push(timerKey);
request = prepareDispatcherAndWrapRequest(request, response);
ActionMapping mapping;
try {
//在這裡找到Action的對映器
mapping = actionMapper.getMapping(request, dispatcher.getConfigurationManager());
} catch (Exception ex) {
log.error("error getting ActionMapping", ex);
dispatcher.sendError(request, response, servletContext, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, ex);
return;
}
//沒有此Action的話,就去查詢靜態資源
if (mapping == null) {
// there is no action in this request, should we look for a static resource?
String resourcePath = RequestUtils.getServletPath(request);
if ("".equals(resourcePath) && null != request.getPathInfo()) {
resourcePath = request.getPathInfo();
}
if (staticResourceLoader.canHandle(resourcePath)) {
staticResourceLoader.findStaticResource(resourcePath, request, response);
} else {
// this is a normal request, let it pass through
chain.doFilter(request, response);
}
// The framework did its job here
return;
}
//有此Action的話則把控制權交給ActionProxy
dispatcher.serviceAction(request, response, servletContext, mapping);
} finally {
dispatcher.cleanUpRequest(request);
try {
ActionContextCleanUp.cleanUp(req);
} finally {
UtilTimerStack.pop(timerKey);
}
devModeOverride.remove();
}
}
●
4、如果ActionMapper決定需要呼叫某個Action，FilterDispatcher把請求的處理交給ActionProxy
public void serviceAction(HttpServletRequest request, HttpServletResponse response, ServletContext context,
ActionMapping mapping) throws ServletException {
Map<String, Object> extraContext = createContextMap(request, response, mapping, context);
// If there was a previous value stack, then create a new copy and pass it in to be used by the new Action
ValueStack stack = (ValueStack) request.getAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY);
boolean nullStack = stack == null;
if (nullStack) {
ActionContext ctx = ActionContext.getContext();
if (ctx != null) {
stack = ctx.getValueStack();
}
}
if (stack != null) {
extraContext.put(ActionContext.VALUE_STACK, valueStackFactory.createValueStack(stack));
}
String timerKey = "Handling request from Dispatcher";
try {
UtilTimerStack.push(timerKey);
String namespace = mapping.getNamespace();
String name = mapping.getName();
String method = mapping.getMethod();
//獲取配置檔案
Configuration config = configurationManager.getConfiguration();
//根據配置檔案找到此Action並生成ActionProxy
ActionProxy proxy = config.getContainer().getInstance(ActionProxyFactory.class).createActionProxy(
namespace, name, method, extraContext, true, false);
request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, proxy.getInvocation().getStack());
// if the ActionMapping says to go straight to a result, do it!
if (mapping.getResult() != null) {
Result result = mapping.getResult();
//ActionProxy建立一個ActionInvocation的例項
result.execute(proxy.getInvocation());
} else {
proxy.execute();
}
// If there was a previous value stack then set it back onto the request
if (!nullStack) {
request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, stack);
}
} catch (ConfigurationException e) {
logConfigurationException(request, e);
sendError(request, response, context, HttpServletResponse.SC_NOT_FOUND, e);
} catch (Exception e) {
if (handleException || devMode) {
sendError(request, response, context, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e);
} else {
throw new ServletException(e);
}
} finally {
UtilTimerStack.pop(timerKey);
}
}
● 1
5、ActionProxy通過Configuration Manager詢問框架的配置檔案，找到需要呼叫的Action類
6、ActionProxy建立一個ActionInvocation的例項。
7、ActionInvocation例項使用命名模式來呼叫，在呼叫Action的過程前後，涉及到相關攔截器（Intercepter）的呼叫。
8、一旦Action執行完畢，ActionInvocation負責根據struts.xml中的配置找到對應的返回結果。返回結果通常是（但不總是，也可 能是另外的一個Action鏈）一個需要被表示的JSP或者FreeMarker的模版。
9、將處理結果返回給客戶端
(2) SpringMVC 的原理
執行步驟:
第一步：發起請求到前端控制器(DispatcherServlet)
第二步：前端控制器請求HandlerMapping查詢 Handler
可以根據xml配置、註解進行查詢
第三步：處理器對映器HandlerMapping向前端控制器返回Handler
第四步：前端控制器呼叫處理器介面卡去執行Handler
第六步：Handler執行完成給介面卡返回ModelAndView
第七步：處理器介面卡向前端控制器返回ModelAndView
ModelAndView是SpringMVC框架的一個底層物件，包括 Model和view
第八步：前端控制器請求檢視解析器去進行檢視解析
根據邏輯檢視名解析成真正的檢視(jsp)
第九步：檢視解析器向前端控制器返回View
第十步：前端控制器進行檢視渲染
檢視渲染將模型資料(在ModelAndView物件中)填充到request域
第十一步：前端控制器向用戶響應結果
(3) Hibernate 的原理
1.通過Configuration().configure();讀取並解析hibernate.cfg.xml配置檔案
2.由hibernate.cfg.xml中的<mapping resource="com/xx/User.hbm.xml"/>讀取並解析對映資訊
3.通過config.buildSessionFactory();//建立SessionFactory
4.sessionFactory.openSession();//開啟Sesssion
5.session.beginTransaction();//建立事務Transation
6.persistent operate持久化操作
7.session.getTransaction().commit();//提交事務
8.關閉Session
9.關閉SesstionFactory
(4) MyBatis原理
MyBatis框架執行過程：
1、配置MyBatis的配置檔案，SqlMapConfig.xml（名稱不固定）
2、通過配置檔案，載入MyBatis執行環境，建立SqlSessionFactory會話工廠
SqlSessionFactory 在實際使用時按單例方式。
3、通過SqlSessionFactory建立SqlSession
SqlSession 是一個面向使用者介面（提供操作資料庫方法），實現物件是執行緒不安全的，建議sqlSession應用場合在方法體內。
4、呼叫 sqlSession 的方法去操作資料。
如果需要提交事務，需要執行 SqlSession 的 commit() 方法。
5、釋放資源，關閉SqlSession
Struts2 和 SpringMVC 在 web.xml 中配置的不同
(1) Struts2
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
<init-param>
<param-name>filterConfig</param-name>
<param-value>classpath:struts2/struts.xml</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
●
Struts2使用Filter嵌入自己的框架。配置檔案載入順序為：default.properties -> struts-default.xml -> struts-plugins.xml -> struts.xml -> struts.locale。
載入順序可以參考這篇文章的原始碼分析瞭解更多。https://my.oschina.net/gschen/blog/121433
(2) SpringMVC
<!-- springmvc前端控制器，rest配置 -->
<servlet>
<servlet-name>springmvc_rest</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- contextConfigLocation配置springmvc載入的配置檔案（配置處理器對映器、介面卡等等） 如果不配置contextConfigLocation，預設載入的是/WEB-INF/servlet名稱-serlvet.xml（springmvc-servlet.xml） -->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring/springmvc.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>springmvc_rest</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
●
（3）web.xml不同之處
SpringMVC的入口是Servlet，而Struts2是Filter（這裡要指出，Filter和Servlet是不同的。以前認為filter是servlet的一種特殊），這就導致了二者的機制不同，這裡就牽涉到Servlet和Filter的區別了。但是這只是接管使用者請求的兩種不同方式而已，控制權被Struts2和SpringMVC掌握之後，想做什麼事都是可以做到的。
Servlet
servlet是一種執行伺服器端的java應用程式，具有獨立於平臺和協議的特性，並且可以動態的生成web頁面，它工作在客戶端請求與伺服器響應的中間層。最早支援 Servlet 技術的是 JavaSoft 的 Java Web Server。此後，一些其它的基於 Java 的 Web Server 開始支援標準的 Servlet API。Servlet 的主要功能在於互動式地瀏覽和修改資料，生成動態 Web 內容。這個過程為：
1) 客戶端傳送請求至伺服器端；
2) 伺服器將請求資訊傳送至 Servlet；
3) Servlet 生成響應內容並將其傳給伺服器。響應內容動態生成，通常取決於客戶端的請求；
4) 伺服器將響應返回給客戶端。
在 Web 應用程式中，一個 Servlet 在一個時刻可能被多個使用者同時訪問。這時 Web 容器將為每個使用者建立一個執行緒來執行 Servlet。如果 Servlet 不涉及共享資源的問題，不必關心多執行緒問題。但如果 Servlet 需要共享資源，需要保證 Servlet 是執行緒安全的。
為了簡化開發流程，Servlet 3.0 引入了註解（annotation），這使得 web 部署描述符 web.xml 不再是必須的選擇。
Filter：Filter是一個可以複用的程式碼片段，可以用來轉換HTTP請求、響應和頭資訊。Filter不像Servlet，它不能產生一個請求或者響應，它只是修改對某一資源的請求，或者修改從某一的響應。Servlet中的過濾器Filter是實現了javax.servlet.Filter介面的伺服器端程式，主要的用途是過濾字元編碼、做一些業務邏輯判斷等。其工作原理是，只要你在web.xml檔案配置好要攔截的客戶端請求，它都會幫你攔截到請求，此時你就可以對請求或響應(Request、Response)統一設定編碼，簡化操作；同時還可進行邏輯判斷，如使用者是否已經登陸、有沒有許可權訪問該頁面等等工作。它是隨你的web應用啟動而啟動的，只初始化一次，以後就可以攔截相關請求，只有當你的web應用停止或重新部署的時候才銷燬。Filter可認為是Servlet的一種“變種”，它主要用於對使用者請求進行預處理，也可以對HttpServletResponse進行後處理，是個典型的處理鏈。它與Servlet的區別在於：它不能直接向用戶生成響應。完整的流程是：Filter對使用者請求進行預處理，接著將請求交給Servlet進行處理並生成響應，最後Filter再對伺服器響應進行後處理。
Servlet與Filter的區別可以從這篇文章瞭解更多。http://www.cnblogs.com/doit8791/p/4209442.html
Struts2 和 SpringMVC 處理使用者請求的不同
Struts2和SpringMVC的核心都是接管使用者的請求，解決傳統Servlet開發過於繁瑣，重用性不高的問題。
Struts2和SpringMVC都有註解和配置檔案兩種匹配使用者請求URL的方式。
Struts2註解方式匹配URL
參考網址：http://struts.apache.org/docs/convention-plugin.html
首先需要將架包(struts2-convention-plugin-xxx.jar)匯入工程中
示例
package com.example.actions;
import com.opensymphony.xwork2.ActionSupport;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Actions;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.Results;
@Results({
@Result(name="failure", location="fail.jsp")
})
public class HelloWorld extends ActionSupport
{
@Action(value="/different/url",
results={@Result(name="success", location="http://struts.apache.org", type="redirect")}
)
public String execute()
{
return SUCCESS;
}
@Action("/another/url")
public String doSomething()
{
return SUCCESS;
}
}
●
<package name="package" namespace="/different" extends="struts-default">
<global-results>
<result name="failure">/fail.jsp</result>
</global-results>
<action name="url" class="com.example.actions.HelloWorld" method="execute">
<result name="success" type="redirect">http://struts.apache.org</result>
</action>
</package>
<package name="package2" namespace="/another" extends="struts-default">
<global-results>
<result name="failure">/fail.jsp</result>
</global-results>
<action name="url" class="com.example.actions.HelloWorld" method="doSomething">
</action>
</package>
● 9
package com.jpkc.controller;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
@RequestMapping("/admin")
@Controller
public class LoginController
{
@RequestMapping("/admin_home")
public String admin_home() throws Exception
{
return "forward:/shop/index.jsp";
}
@RequestMapping("/exit")
public String logout(ModelAndView model, HttpSession session) throws Exception
{
session.invalidate();
return "redirect:/manager/login.jsp";
}
}
● 28
SpringMVC配置方式匹配URL
public class ItemsController1 implements Controller
{
@Override
public ModelAndView handleRequest(HttpServletRequest request,
HttpServletResponse response) throws Exception
{
//呼叫Service查詢 資料庫，查詢商品列表，這裡使用靜態資料模擬
List<Items> itemsList = new ArrayList<Items>();
//向list中填充靜態資料
Items items_1 = new Items();
items_1.setName("聯想筆記本");
items_1.setPrice(6000f);
items_1.setDetail("ThinkPad T430 聯想膝上型電腦！");
Items items_2 = new Items();
items_2.setName("蘋果手機");
items_2.setPrice(5000f);
items_2.setDetail("iphone6蘋果手機！");
itemsList.add(items_1);
itemsList.add(items_2);
//返回ModelAndView
ModelAndView modelAndView = new ModelAndView();
//相當 於request的setAttribut，在jsp頁面中通過itemsList取資料
modelAndView.addObject("itemsList", itemsList);
//指定檢視
modelAndView.setViewName("/WEB-INF/jsp/items/itemsList.jsp");
return modelAndView;
}
}
● 7
<!-- 配置Handler -->
<bean id="itemsController1" name="/queryItems.action" class="cn.itcast.ssm.controller.ItemsController1" />
● 1
● 2
--------------------------------------------------------------------------------
1、Struts2是類級別的攔截， 一個類對應一個request上下文，SpringMVC是方法級別的攔截，一個方法對應一個request上下文，而方法同時又跟一個url對應,所以說從架構本身上SpringMVC就容易實現restful url,而struts2的架構實現起來要費勁，因為Struts2中Action的一個方法可以對應一個url，而其類屬性卻被所有方法共享，這也就無法用註解或其他方式標識其所屬方法了。
2、由上邊原因，SpringMVC的方法之間基本上獨立的，獨享request response資料，請求資料通過引數獲取，處理結果通過ModelMap交回給框架，方法之間不共享變數，而Struts2搞的就比較亂，雖然方法之間也是獨立的，但其所有Action變數是共享的，這不會影響程式執行，卻給我們編碼 讀程式時帶來麻煩，每次來了請求就建立一個Action，一個Action物件對應一個request上下文。
3、由於Struts2需要針對每個request進行封裝，把request，session等servlet生命週期的變數封裝成一個一個Map，供給每個Action使用，並保證執行緒安全，所以在原則上，是比較耗費記憶體的。
Struts2 和 SpringMVC 實現 RESTful 的不同
http://localhost/jpkc/item/1609032329404095427579225
Struts2實現方式
<package name="course_info_package" namespace="/item" extends="struts-default">
<action name="*" class="com.jpkc.action.CourseAction" method="get_course_info">
<result name="success">/story/story_02.jsp</result>
</action>
</package>
●
public class CourseAction extends ActionSupport
{
public String get_course_info()
{
String actionName = ServletActionContext.getActionMapping().getName();
CourseInfo courseInfoFromDB = courseInfoDAO.findById(actionName);
if (courseInfoFromDB == null)
{
return "404";
}
Course courseFromDB = courseDAO.findById(actionName);
if (courseFromDB == null)
{
return "404";
}
setCourseInfo(courseInfoFromDB);
setCourse(courseFromDB);
return SUCCESS;
}
}
●
SpringMVC實現方式
@Controller
public class CourseController
{
@RequestMapping("/item/{id}")
public ModelAndView get_course_info(ModelAndView model, @PathVariable("id") String id)
{
if (CM.validIsEmptyWithTrim(id))
{
model.addObject("message", "沒有找到此視訊頁面");
model.setViewName("/WEB-INF/jsp/error");
return model;
}
CourseInfo courseInfoFromDB=null;
try
{
courseInfoFromDB = courseInfoService.selectByPrimaryKey(id);
}
catch (Exception e1)
{
System.out.println("沒有找到課程資訊");
}
if (courseInfoFromDB == null)
{
model.addObject("message", "沒有找到此視訊頁面");
model.setViewName("/WEB-INF/jsp/error");
return model;
}
Course courseFromDB = null;
try
{
courseFromDB = courseService.selectByPrimaryKey(id);
}
catch (Exception e)
{
System.out.println("沒有查詢到課程");
}
if (courseFromDB == null)
{
model.addObject("message", "沒有找到此視訊頁面");
model.setViewName("/WEB-INF/jsp/error");
return model;
}
model.addObject("courseInfo", courseInfoFromDB);
model.addObject("course", courseFromDB);
model.setViewName("/story/story_02");
return model;
}
}
●
--------------------------------------------------------------------------------
如果類似於http://localhost/jpkc/id2/id1這種連結，Struts2要進一步分析連結得到id1和id2。SpringMVC依然可以將id2對映到方法引數上。從呼叫的角度來看SpringMVC要方便一些。但是如果將Struts2獲取方式封裝一下，也可以得到同樣的效果。
Struts2 和 SpringMVC 獲取 request 引數的不同
前臺頁面有一個表單需要提交。
Struts2 接收 request 引數
<form class="login-form" action="/login_do" method="post">
<h3 class="form-title">登入系統</h3>
<div class="alert alert-danger display-hide">
<button class="close" data-close="alert"></button>
<span> 請輸入使用者名稱和密碼 </span>
</div>
<div class="form-group">
<label class="control-label visible-ie8 visible-ie9">使用者名稱</label>
<div class="input-icon">
<i class="fa fa-user"></i>
<input class="form-control placeholder-no-fix" type="text" autocomplete="off" placeholder="使用者名稱" name="account.id" />
</div>
</div>
<div class="form-group">
<label class="control-label visible-ie8 visible-ie9">密碼</label>
<div class="input-icon">
<i class="fa fa-lock"></i>
<input class="form-control placeholder-no-fix" type="password" autocomplete="off" placeholder="密碼" name="account.password" />
</div>
</div>
<div class="form-actions">
<button type="submit" class="btn green pull-right">
登入 <i class="m-icon-swapright m-icon-white"></i>
</button>
</div>
</form
package com.jpkc.pojo;
import java.io.Serializable;
public class Account implements Serializable
{
private String id;
private String password;
private String name;
public Account()
{
super();
// TODO Auto-generated constructor stub
}
public String getId()
{
return id;
}
public void setId(String id)
{
this.id = id;
}
public String getPassword()
{
return password;
}
public void setPassword(String password)
{
this.password = password;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
}
●
package com.jpkc.action;
import java.util.HashMap;
import java.util.Map;
import com.jpkc.common.CM;
import com.jpkc.pojo.Account;
public class AccountAction extends BaseAction
{
private Account account;
public String login_do()
{
String method = getRequest().getMethod();
if (method.toUpperCase().equals("GET"))
{
return "404";
}
if (account == null || CM.validIsEmpty(account.getId()) || CM.validIsEmpty(account.getPassword()))
{
return ERROR;
}
getSession().setAttribute("accountSession", account);
return SUCCESS;
}
public Account getAccount()
{
return account;
}
public void setAccount(Account account)
{
this.account = account;
}
}
● 7
SpringMVC 接收 request 引數
<form class="login-form" action="admin/login_do" method="post">
<h3 class="form-title">登入系統</h3>
<div class="alert alert-danger display-hide">
<button class="close" data-close="alert"></button>
<span> 請輸入使用者名稱和密碼 </span>
</div>
<div class="form-group">
<label class="control-label visible-ie8 visible-ie9">使用者名稱</label>
<div class="input-icon">
<i class="fa fa-user"></i>
<input class="form-control placeholder-no-fix" type="text" autocomplete="off" placeholder="使用者名稱" name="id" />
</div>
</div>
<div class="form-group">
<label class="control-label visible-ie8 visible-ie9">密碼</label>
<div class="input-icon">
<i class="fa fa-lock"></i>
<input class="form-control placeholder-no-fix" type="password" autocomplete="off" placeholder="密碼" name="password" />
</div>
</div>
<div class="form-actions">
<button type="submit" class="btn green pull-right">
登入 <i class="m-icon-swapright m-icon-white"></i>
</button>
</div>
</form>
●
package com.jpkc.pojo;
import java.io.Serializable;
public class Account implements Serializable
{
private String id;
private String password;
private String name;
public Account()
{
super();
// TODO Auto-generated constructor stub
}
public String getId()
{
return id;
}
public void setId(String id)
{
this.id = id;
}
public String getPassword()
{
return password;
}
public void setPassword(String password)
{
this.password = password;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
}
●
package com.jpkc.controller;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.codehaus.jackson.map.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
import com.jpkc.common.CM;
import com.jpkc.exception.CustomException;
import com.jpkc.mapper.CourseInfoMapper;
import com.jpkc.pojo.Account;
import com.jpkc.pojo.CourseInfo;
import com.jpkc.service.LoginService;
@RequestMapping("/admin")
@Controller
public class LoginController
{
@Autowired
LoginService loginService;
@RequestMapping(value = "/login_do", method = { RequestMethod.POST })
public void login_do(ModelAndView model, HttpServletRequest request, HttpServletResponse response, HttpSession session, Account account) throws Exception
{
response.setCharacterEncoding("utf-8");
response.setContentType("application/json;charset=utf-8");
Map<String, Object> json = new HashMap<String, Object>();
String info;
if (account == null || CM.validIsEmpty(account.getId()) || CM.validIsEmpty(account.getPassword()))
{
info = "使用者名稱、密碼都是必填項。";
json.put("success", false);
json.put("info", info);
response.getWriter().write(new ObjectMapper().writeValueAsString(json));
return;
}
session.setAttribute("accountSession", account);
json.put("success", true);
response.getWriter().write(new ObjectMapper().writeValueAsString(json));
return;
}
}
●
● 9
--------------------------------------------------------------------------------
Struts2單個方法可以處理一個request，接收引數Account需要定義一個成員變數，Struts2會自動將對應的引數呼叫成員變數的set方法設定進去。處理方法可以在方法內獲取到。用完還存在request級別Map中。
SpringMVC的單個方法也對應於一個request，接收引數Account需要定義一個方法引數，SpringMVC會自動將對應的引數設定到方法引數中去。處理方法可以在方法內獲取到。用完即銷燬。
可以看出兩種框架都可以實現引數的自動轉換。Struts2定義一個成員變數，其他方法都是可以共享的，不用重新定義。SpringMVC每個方法都是獨立的，方法引數是每一個方法獨享的。
各有利弊。
成員變數共享可以避免重複定義，但是方法一多，用到的成員變數原來越多，整個Action類會慘不忍睹，因為你不知道其中一個方法具體會用到哪幾個成員變數。而且用不到的成員變數也被儲存到request級別Map中了。造成記憶體的浪費。
方法引數是方法獨享的。則不能複用到其他方法，但是對於當前方法來說有哪些引數足夠明確，而且不用和其他方法攪合，乾脆利落。
從JVM角度來說，Struts2成員變數會被分配到堆中。SpringMVC方法引數則會存在於方法棧中，一般認為棧比堆更輕量一些，方法結束，用完引數即回收。堆需要垃圾回收觸發時才能統一回收。
Struts2 和 SpringMVC 限制訪問方式GET和POST的不同
在上例中，表單提交有密碼，需要指定只接受POST提交方式。
Struts2指定POST方式
public String login_do()
{
String method = getRequest().getMethod();
if (method.toUpperCase().equals("GET"))
{
return "404";
}
}
● 3
SpringMVC指定POST方式
@RequestMapping(value = "/login_do", method = { RequestMethod.POST })
public void login_do(ModelAndView model, HttpServletRequest request, HttpServletResponse response, HttpSession session, Account account) throws Exception
{
response.setCharacterEncoding("utf-8");
response.setContentType("application/json;charset=utf-8");
Map<String, Object> json = new HashMap<String, Object>();
String info;
if (account == null || CM.validIsEmpty(account.getId()) || CM.validIsEmpty(account.getPassword()))
{
info = "使用者名稱、密碼都是必填項。";
json.put("success", false);
json.put("info", info);
response.getWriter().write(new ObjectMapper().writeValueAsString(json));
return;
}
session.setAttribute("accountSession", account);
json.put("success", true);
response.getWriter().write(new ObjectMapper().writeValueAsString(json));
return;
}
●
--------------------------------------------------------------------------------
Struts2限制只能通過POST方式訪問，是通過呼叫request的getMethod方法來得到當前訪問方式。然後手工的去判斷。
SpringMVC也可以呼叫request的getMethod方法來判斷，但是框架本身提供了方便的內建判斷。使用註解即可。
Struts2通過攔截器設定好訪問方式的程式碼後，也可以通過註解的方式指定攔截器得到同樣的效果。本身不是太難的事情，兩個框架都可以實現，Struts2需要手工實現，SpringMVC預設提供了。即使SpringMVC不提供，呼叫SpringMVC的攔截器也能和Struts2的攔截器的效果一樣。在GET和POST訪問限制方面，並沒有誰優誰劣，都可以實現。只是SpringMVC願意往前多走一小步。
Struts2 和 SpringMVC 攔截器的不同
後臺頁面需要登入，我們可以使用攔截器限制未登入的使用者訪問。
Struts2實現攔截器的方式
public class ManagerLoginInterceptor extends AbstractInterceptor
{
@Override
public String intercept(ActionInvocation invocation) throws Exception
{
String actionName = ServletActionContext.getActionMapping().getName();
// 如果是登入、註冊、退出的話就不要攔截了
if (actionName.equals("exit") || actionName.equals("login") || actionName.equals("login_do") || actionName.equals("regist")
|| actionName.equals("regist_do"))
{
return invocation.invoke();
}
// 如果不是管理員就不能進入
Manager managerTemp = (Manager) ServletActionContext.getRequest().getSession().getAttribute("managerSession");
if (managerTemp == null)
{
return "manager_login";
}
//驗證成功，放行。
return invocation.invoke();
}
}
●
<interceptors>
<interceptor name="LoginManagerValidate" class="com.example.interceptor.ManagerLoginInterceptor">
</interceptor>
<!-- 自定義攔截器棧-攔截未登入的管理員- -->
<interceptor-stack name="LoginManagerValidateStack">
<interceptor-ref name="LoginManagerValidate"></interceptor-ref>
<interceptor-ref name="defaultStack"></interceptor-ref>
</interceptor-stack>
</interceptors>
<action name="m_*" class="com.example.action.ManagerAction" method="m_{1}">
<interceptor-ref name="LoginManagerValidateStack"></interceptor-ref>
<result name="success" type="json">
<param name="root">json</param>
</result>
</action>
</package>6
●
Struts2還提供了很多預設的攔截器供使用者呼叫。
<interceptors>
<interceptor name="alias"class="com.opensymphony.xwork2.interceptor.AliasInterceptor"/>
<interceptor name="autowiring"class="com.opensymphony.xwork2.spring.interceptor.ActionAutowiringInterceptor"/>
<interceptor name="chain"class="com.opensymphony.xwork2.interceptor.ChainingInterceptor"/>
<interceptor name="conversionError"class="org.apache.struts2.interceptor.StrutsConversionErrorInterceptor"/>
<interceptor name="clearSession"class="org.apache.struts2.interceptor.ClearSessionInterceptor"/>
<interceptor name="createSession"class="org.apache.struts2.interceptor.CreateSessionInterceptor"/>
<interceptor name="debugging"class="org.apache.struts2.interceptor.debugging.DebuggingInterceptor"/>
<interceptor name="externalRef"class="com.opensymphony.xwork2.interceptor.ExternalReferencesInterceptor"/>
<interceptor name="execAndWait"class="org.apache.struts2.interceptor.ExecuteAndWaitInterceptor"/>
<interceptor name="exception"class="com.opensymphony.xwork2.interceptor.ExceptionMappingInterceptor"/>
<interceptor name="fileUpload"class="org.apache.struts2.interceptor.FileUploadInterceptor"/>
<interceptor name="i18n"class="com.opensymphony.xwork2.interceptor.I18nInterceptor"/>
<interceptor name="logger"class="com.opensymphony.xwork2.interceptor.LoggingInterceptor"/>
<interceptor name="modelDriven"class="com.opensymphony.xwork2.interceptor.ModelDrivenInterceptor"/>
<interceptor name="scopedModelDriven"class="com.opensymphony.xwork2.interceptor.ScopedModelDrivenInterceptor"/>
<interceptor name="params"class="com.opensymphony.xwork2.interceptor.ParametersInterceptor"/>
<interceptor name="actionMappingParams"class="org.apache.struts2.interceptor.ActionMappingParametersInteceptor"/>
<interceptor name="prepare"class="com.opensymphony.xwork2.interceptor.PrepareInterceptor"/>
<interceptor name="staticParams"class="com.opensymphony.xwork2.interceptor.StaticParametersInterceptor"/>
<interceptor name="scope"class="org.apache.struts2.interceptor.ScopeInterceptor"/>
<interceptor name="servletConfig"class="org.apache.struts2.interceptor.ServletConfigInterceptor"/>
<interceptor name="sessionAutowiring"class="org.apache.struts2.spring.interceptor.SessionContextAutowiringInterceptor"/>
<interceptor name="timer"class="com.opensymphony.xwork2.interceptor.TimerInterceptor"/>
<interceptor name="token"class="org.apache.struts2.interceptor.TokenInterceptor"/>
<interceptor name="tokenSession"class="org.apache.struts2.interceptor.TokenSessionStoreInterceptor"/>
<interceptor name="validation"class="org.apache.struts2.interceptor.validation.AnnotationValidationInterceptor"/>
<interceptor name="workflow"class="com.opensymphony.xwork2.interceptor.DefaultWorkflowInterceptor"/>
<interceptor name="store"class="org.apache.struts2.interceptor.MessageStoreInterceptor"/>
<interceptor name="checkbox"class="org.apache.struts2.interceptor.CheckboxInterceptor"/>
<interceptor name="profiling"class="org.apache.struts2.interceptor.ProfilingActivationInterceptor"/>
<interceptor name="roles"class="org.apache.struts2.interceptor.RolesInterceptor"/>
<interceptor name="jsonValidation"class="org.apache.struts2.interceptor.validation.JSONValidationInterceptor"/>
<interceptornameinterceptorname="annotationWorkflow"class="com.opensymphony.xwork2.interceptor.annotations.AnnotationWorkflowInterceptor"/>
●
SpringMVC實現攔截器的方式
public class LoginInterceptor implements HandlerInterceptor
{
// 進入 Handler方法之前執行
// 用於身份認證、身份授權
// 比如身份認證，如果認證通過表示當前使用者沒有登陸，需要此方法攔截不再向下執行
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception
{
// 獲取請求的url
String url = request.getRequestURI();
// 判斷url是否是公開 地址（實際使用時將公開 地址配置配置檔案中）
// 這裡公開地址是登陸提交的地址
if (url.indexOf("login") >= 0 || url.indexOf("exit") >= 0)
{
// 如果進行登陸提交，放行
return true;
}
// 判斷session
HttpSession session = request.getSession();
// 從session中取出使用者身份資訊
Account account = (Account) session.getAttribute("accountSession");
if (account != null)
{
// 身份存在，放行
return true;
}
// 執行這裡表示使用者身份需要認證，跳轉登陸頁面
request.getRequestDispatcher("/manager/login.jsp").forward(request, response);
// return false表示攔截，不向下執行
// return true表示放行
return false;
}
// 進入Handler方法之後，返回modelAndView之前執行
// 應用場景從modelAndView出發：將公用的模型資料(比如選單導航)在這裡傳到檢視，也可以在這裡統一指定檢視
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception
{
System.out.println("HandlerInterceptor1...postHandle");
}
// 執行Handler完成執行此方法
// 應用場景：統一異常處理，統一日誌處理
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception
{
System.out.println("HandlerInterceptor1...afterCompletion");
}
}
●
<!--攔截器 -->
<mvc:interceptors>
<!--多個攔截器,順序執行 -->
<!-- 登入認證攔截器 -->
<mvc:interceptor>
<mvc:mapping path="/admin/**" />
<bean class="com.jpkc.interceptor.LoginInterceptor"></bean>
</mvc:interceptor>
</mvc:interceptors>
●
--------------------------------------------------------------------------------
攔截器實現機制上，Struts2有自己的interceptor機制，SpringMVC用的是獨立的AOP方式。都可以實現在前後進行攔截。
Struts2 和 SpringMVC 支援 JSON 的不同
有時我們介面的一些操作，是通過 Ajax 呼叫後臺的服務，獲取伺服器返回的 json 資料，進行後續的操作。
Struts2 實現JSON資料返回的方式
<action name="login_do" class="com.jpkc.action.AccountAction" method="login_do">
<result name="success" type="json">
<!-- 這裡指定將被Struts2序列化的屬性，該屬性在action中必須有對應的getter方法 -->
<param name="root">json</param>
</result>
</action>
●
public class AccountAction extends BaseAction
{
// 常用變數
private Map<String, Object> json;// 返回到前臺的map物件
private Account account;
public AccountAction()
{
json = new HashMap<String, Object>();
}
public String login_do()
{
if (account == null || CM.validIsEmpty(account.getId()) || CM.validIsEmpty(account.getPassword()))
{
info = "使用者名稱、密碼都是必填項。";
json.put("success", false);
json.put("info", info);
return SUCCESS;
}
getSession().setAttribute("accountSession", account);
json.put("success", true);
return SUCCESS;
}
}
●
$.post("login_do", $(".login-form").serialize(), function(json)
{
if (json.success == true)
{
window.location.href="shop/index.jsp";
}
else
{
alert("操作失敗：" + json.info);
}
}, "json");
●
SpringMVC 實現JSON資料返回的方式
<!--註解介面卡 -->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
<property name="messageConverters">
<list>
<bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"></bean>
</list>
</property>
</bean>
$.post("login_do", $(".login-form").serialize(), function(json)
{
if (json.success == true)
{
window.location.href="shop/index.jsp";
}
else
{
alert("操作失敗：" + json.info);
}
}, "json");
●
SpringMVC在控制器中返回json有兩種方式。
一種是使用response返回json。
@RequestMapping(value = "/login_do", method = { RequestMethod.POST })
public void login_do(ModelAndView model, HttpServletRequest request, HttpServletResponse response, HttpSession session, Account account) throws Exception
{
response.setCharacterEncoding("utf-8");
response.setContentType("application/json;charset=utf-8");
Map<String, Object> json = new HashMap<String, Object>();
String info;
if (account == null || CM.validIsEmpty(account.getId()) || CM.validIsEmpty(account.getPassword()))
{
info = "使用者名稱、密碼都是必填項。";
json.put("success", false);
json.put("info", info);
response.getWriter().write(new ObjectMapper().writeValueAsString(json));
return;
}
session.setAttribute("accountSession", account);
json.put("success", true);
response.getWriter().write(new ObjectMapper().writeValueAsString(json));
return;
}
另一種是使用@ResponseBody註解方式。
@RequestMapping(value = "/login_do", method = { RequestMethod.POST })
public @ResponseBody Map<String, Object> login_do(ModelAndView model, HttpServletRequest requ