sshjsplistSSH和SSM的差别抽丝剥茧由内到外给你讲清晰

SSM 则指的是 SpringMVC 做前端掌握器，Spring 管理各层的组件，MyBatis 卖力持久化层。

共同之处是都利用了Spring的依赖注入DI来管理各层的组件，利用了面向切面编程AOP来实现日志管理，权限认证，事务等通用功能的切入。

不同之处是 Struts2 和 SpringMVC 做前端掌握器的差异，以及 Hibernate 和 MyBatis 做持久化时的差异。
但是，Struts2 也可以和 MyBatis 搭配利用，SpringMVC 也可以和 Hibernate 搭配利用。
本文为了简化比拟，指定 Struts2 要和 Hibernate 搭配，SpringMVC 要和 MyBatis 搭配。

sshjsplistSSH和SSM的差别抽丝剥茧由内到外给你讲清晰 CSS

1.1. SSH 和 SSM 的实现事理差异

所在分层SSHSSM页面层(View)JSPJSP掌握器层(Controller)Struts2SpringMVC业务层(Service)JavaJava持久层(DAO)HibernateMyBatis数据库层(DB)MySQL/OracleMySQL/Oracle组件管理(Bean)SpringSpring

(1) Struts2 的事理

一个要求在Struts2框架中的处理大概分为以下几个步骤：

1、客户端初始化一个指向Servlet容器（例如Tomcat）的要求

2、这个要求经由一系列的过滤器（Filter）（这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器，这个过滤器对付Struts2和其他框架的集成很有帮助，例如：SiteMesh Plugin）

3、接着FilterDispatcher被调用，FilterDispatcher讯问ActionMapper来决定这个要求是否须要调用某个Action

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); } }

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

第六步：Handler实行完成给适配器返回ModelAndView

第七步：处理器适配器向前端掌握器返回ModelAndViewModelAndView是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创建SqlSessionSqlSession 是一个面向用户接口（供应操作数据库方法），实现工具是线程不屈安的，建议sqlSession运用处地点方法体内。

4、调用 sqlSession 的方法去操作数据。
如果须要提交事务，须要实行 SqlSession 的 commit() 方法。

5、开释资源，关闭SqlSession

1.2. 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

<servlet> <servlet-name>springmvc_rest</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  <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>

SpringMVC利用Servlet嵌入自己的框架。

（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再对做事器相应进行后处理。

1.3. Struts2 和 SpringMVC 处理用户要求的不同

Struts2和SpringMVC的核心都是接管用户的要求，办理传统Servlet开拓过于繁琐，重用性不高的问题。

Struts2和SpringMVC都有表明和配置文件两种匹配用户要求URL的办法。

Struts2表明办法匹配URL

首先须要将架包(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; } }

Struts2配置办法匹配URL

<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>

SpringMVC表明办法匹配URL

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")@Controllerpublic 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"; }}

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; }}

<bean id="itemsController1" name="/queryItems.action" class="cn.itcast.ssm.controller.ItemsController1" />

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利用，并担保线程安全，以是在原则上，是比较耗费内存的。

1.4. Struts2 和 SpringMVC 实现 RESTful 的不同

实现上面这个链接，个中localhost是域名，jpkc是项目名。

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实现办法

@Controllerpublic 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/item/id1这种链接，Struts2实现RESTful风格须要在代码中调用ServletActionContext.getActionMapping().getName()获取ActionName。
SpringMVC直接将链接映射到方法参数里去了。

如果类似于http://localhost/jpkc/id2/id1这种链接，Struts2要进一步剖析链接得到id1和id2。
SpringMVC依然可以将id2映射到方法参数上。
从调用的角度来看SpringMVC要方便一些。
但是如果将Struts2获取办法封装一下，也可以得到同样的效果。

1.5. 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; }}

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.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")@Controllerpublic 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; }}

Struts2单个方法可以处理一个request，吸收参数Account须要定义一个成员变量，Struts2会自动将对应的参数调用成员变量的set方法设置进去。
处理方法可以在方法内获取到。
用完还存在request级别Map中。

SpringMVC的单个方法也对应于一个request，吸收参数Account须要定义一个方法参数，SpringMVC会自动将对应的参数设置到方法参数中去。
处理方法可以在方法内获取到。
用完即销毁。

可以看出两种框架都可以实现参数的自动转换。
Struts2定义一个成员变量，其他方法都是可以共享的，不用重新定义。
SpringMVC每个方法都是独立的，方法参数是每一个方法独享的。

各有利弊。

成员变量共享可以避免重复定义，但是方法一多，用到的成员变量原来越多，全体Action类会惨不忍睹，由于你不知道个中一个方法具体会用到哪几个成员变量。
而且用不到的成员变量也被存储到request级别Map中了。
造成内存的摧残浪费蹂躏。

方法参数是方法独享的。
则不能复用到其他方法，但是对付当前方法来说有哪些参数足够明确，而且不用和其他方法搅合，干脆利落。

从JVM角度来说，Struts2成员变量会被分配到堆中。
SpringMVC方法参数则会存在于方法栈中，一样平常认为栈比堆更轻量一些，方法结束，用完参数即回收。
堆须要垃圾回收触发时才能统一回收。

1.6. Struts2 和 SpringMVC 限定访问办法GET和POST的不同

在上例中，表单提交有密码，须要指定只接管POST提交办法。

Struts2指定POST办法

public String login_do() { String method = getRequest().getMethod(); if (method.toUpperCase().equals("GET")) { return "404"; } }

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乐意往前多走一小步。

1.7. 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(); }}

Struts2还供应了很多默认的拦截器供用户调用。

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办法。
都可以实现在前后进行拦截。

1.8. Struts2 和 SpringMVC 支持 JSON 的不同

有时我们界面的一些操作，是通过 Ajax 调用后台的做事，获取做事器返回的 json 数据，进行后续的操作。

Struts2 实现JSON数据返回的办法

<action name="login_do" class="com.jpkc.action.AccountAction" method="login_do"> <result name="success" type="json">  <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。

另一种是利用@ResponseBody表明办法。

@RequestMapping(value = "/login_do", method = { RequestMethod.POST }) public @ResponseBody Map<String, Object> login_do(ModelAndView model, HttpServletRequest request, HttpServletResponse response, HttpSession session, Account account) throws Exception { 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); return json; } session.setAttribute("accountSession", account); json.put("success", true); return json; }

可以看出，Struts2 和 SpringMVC 都可以实现 Ajax 要求返回 JSON。
实现办法上，Struts2在配置文件配置返回类型为JSON。
SpringMVC在方法上加一个@ResponseBody表明即可返回对应类型转成的JSON字符串。
都是对返回数据转成JSON，但是不得不说SpringMVC的写法方便太多了。

1.9. Hibernate 和 MyBatis 在 ORM 侧重点的不同

Hibernate对数据库构造供应了较为完全的封装，Hibernate的O/R Mapping实现了POJO 和数据库表之间的映射，以及SQL 的自动天生和实行。
程序员每每只需定义好了POJO 到数据库表的映射关系，即可通过Hibernate 供应的方法完成持久层操作。
程序员乃至不须要对SQL 的闇练节制， Hibernate/OJB 会根据指定的存储逻辑，自动天生对应的SQL 并调用JDBC 接口加以实行。

MyBatis 的着力点，则在于POJO 与SQL之间的映射关系。
然后通过映射配置文件，将SQL所需的参数，以及返回的结果字段映射到指定POJO。
相对Hibernate“O/R”而言，MyBatis 是一种“Sql Mapping”的ORM实现。

SQL语句支持：Hibernate可以完备不用手写SQL语句，MyBatis手动掩护SQL语句。
Hibernate修正优化SQL语句困难，MyBatis由于SQL语句自己掌握，优化非常方便。

开拓速率：Hibernate的真正节制要比Mybatis来得难些。
Mybatis框架相对大略很随意马虎上手，但也相对简陋些。

开拓社区：Hibernate 与Mybatis都是盛行的持久层开拓框架，但Hibernate开拓社区相对多热闹些，支持的工具也多，更新也快。
而Mybatis相对沉着，工具较少。

开拓事情量：Hibernate和MyBatis都有相应的代码天生工具。
可以天生大略基本的DAO层方法。

针对高等查询，Mybatis须要手动编写SQL语句，以及ResultMap。
而Hibernate有良好的映射机制，开拓者无需关心SQL的天生与结果映射，可以更专注于业务流程。

1.10. Hibernate 和 MyBatis 在调优方面的不同制订合理的缓存策略；只管即便利用延迟加载特性；采取合理的Session管理机制；

SQL优化方面

Hibernate的查询会将表中的所有字段查询出来，这一点会有性能花费。
Hibernate也可以自己写SQL来指定须要查询的字段，但这样就毁坏了Hibernate开拓的简洁性。
而Mybatis的SQL是手动编写的，以是可以按需求指定查询的字段。

Hibernate HQL语句的调优须要将SQL打印出来，而Hibernate的SQL被很多人嫌弃由于太丑了。
MyBatis的SQL是自己手动写的以是调度方便。
但Hibernate具有自己的日志统计。
Mybatis本身不带日志统计，利用Log4j进行日志记录。

扩展性方面

Hibernate与详细数据库的关联只需在XML文件中配置即可，所有的HQL语句与详细利用的数据库无关，移植性很好。
MyBatis项目中所有的SQL语句都是依赖所用的数据库的，以是不同数据库类型的支持不好。

1.11. Hibernate 和 MyBatis 在工具管理与抓取策略的不同

工具管理

Hibernate 是完全的工具/关系映射办理方案，它供应了工具状态管理（state management）的功能，使开拓者不再须要理会底层数据库系统的细节。
也便是说，相对付常见的 JDBC/SQL 持久层方案中须要管理 SQL 语句，Hibernate采取了更自然的面向工具的视角来持久化 Java 运用中的数据。

换句话说，利用 Hibernate 的开拓者该当总是关注工具的状态（state），不必考虑 SQL 语句的实行。
这部分细节已经由 Hibernate 掌管妥当，只有开拓者在进行系统性能调优的时候才须要进行理解。

而MyBatis在这一块没有文档解释，用户须要对工具自己进行详细的管理。
当调用sqlSession.commit()方法时才会进行真正的提交。

抓取策略

Hibernate对实体关联工具的抓取有着良好的机制。
对付每一个关联关系都可以详细地设置是否延迟加载，并且供应关联抓取、查询抓取、子查询抓取、批量抓取四种模式。
它是详细配置和处理的。

而Mybatis的延迟加载是全局配置的，在resultMap中利用association中的select指定延迟加载去实行的statement的id。

<resultMap type="cn.itcast.mybatis.po.Orders" id="OrdersUserLazyLoadingResultMap">  <id column="id" property="id"/> <result column="user_id" property="userId"/> <result column="number" property="number"/> <result column="createtime" property="createtime"/> <result column="note" property="note"/> <association property="user" javaType="cn.itcast.mybatis.po.User" select="cn.itcast.mybatis.mapper.UserMapper.findUserById" column="user_id">  </association> </resultMap>1.12. Hibernate 和 MyBatis 在缓存机制的不同

Hibernate缓存Hibernate一级缓存是Session缓存，利用好一级缓存就须要对Session的生命周期进行管理好。
建议在一个Action操作中利用一个Session。
一级缓存须要对Session进行严格管理。

Hibernate二级缓存是SessionFactory级的缓存。
SessionFactory的缓存分为内置缓存和外置缓存。
内置缓存中存放的是SessionFactory工具的一些凑集属性包含的数据(映射元素据及预定SQL语句等),对付运用程序来说,它是只读的。
外置缓存中存放的是数据库数据的副本,其浸染和一级缓存类似.二级缓存除了以内存作为存储介质外,还可以选用硬盘等外部存储设备。
二级缓存称为进程级缓存或SessionFactory级缓存，它可以被所有session共享，它的生命周期伴随着SessionFactory的生命周期存在和消亡。

MyBatis缓存MyBatis 包含一个非常强大的查询缓存特性,它可以非常方便地配置和定制。
MyBatis 3 中的缓存实现的很多改进都已经实现了,使得它更加强大而且易于配置。

一级缓存是SqlSession级别的缓存，二级缓存是mapper(命名空间)级别的缓存，默认情形下是没有开启二级缓存的。

要开启二级缓存,你须要在你的 SQL 映射文件中添加一行: <cache/>

字面上看便是这样。
这个大略语句的效果如下:

映射语句文件中的所有 select 语句将会被缓存。
映射语句文件中的所有 insert,update 和 delete 语句会刷新缓存。
缓存会利用 Least Recently Used(LRU,最近最少利用的)算法来收回。
根据韶光表(比如 no Flush Interval,没有刷新间隔), 缓存不会以任何韶光顺序来刷新。
缓存会存储列表凑集或工具(无论查询方法返回什么)的 1024 个引用。
缓存会被视为是 read/write(可读/可写)的缓存,意味着工具检索不是共享的,而且可以安全地被调用者修正,而不滋扰其他调用者或线程所做的潜在修正。
所有的这些属性都可以通过缓存元素的属性来修正。

比如: <cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/>

这个更高等的配置创建了一个 FIFO 缓存,并每隔 60 秒刷新,存数结果工具或列表的 512 个引用,而且返回的工具被认为是只读的,因此在不同线程中的调用者之间修正它们会导致冲突。
可用的收回策略有, 默认的是 LRU:

LRU – 最近最少利用的:移除最永劫光不被利用的工具。
FIFO – 前辈先出:按工具进入缓存的顺序来移除它们。
SOFT – 软引用:移除基于垃圾回收器状态和软引用规则的工具。
WEAK – 弱引用:更积极地移除基于垃圾网络器状态和弱引用规则的工具。
flushInterval(刷新间隔)可以被设置为任意的正整数,而且它们代表一个合理的毫秒形式的韶光段。
默认情形是不设置,也便是没有刷新间隔,缓存仅仅调用语句时刷新。

size(引用数目)可以被设置为任意正整数,要记住你缓存的工具数目和你运行环境的可用内存资源数目。
默认值是1024。

readOnly(只读)属性可以被设置为 true 或 false。
只读的缓存会给所有调用者返回缓存工具的相同实例。
因此这些工具不能被修正。
这供应了很主要的性能上风。
可读写的缓存会返回缓存工具的拷贝(通过序列化) 。
这会慢一些,但是安全,因此默认是 false。

相同点Hibernate和Mybatis的二级缓存除了采取系统默认的缓存机制外，都可以通过实现你自己的缓存或为其他第三方缓存方案，创建适配器来完备覆盖缓存行为。

不同点Hibernate的二级缓存配置在SessionFactory天生的配置文件中进行详细配置，然后再在详细的表-工具映命中配置是那种缓存。

MyBatis的二级缓存配置都是在每个详细的表-工具映命中进行详细配置，这样针对不同的表可以自定义不同的缓存机制。
并且Mybatis可以在命名空间中共享相同的缓存配置和实例，通过Cache-ref来实现。

两者比较由于Hibernate对查询工具有着良好的管理机制，用户无需关心SQL。
以是在利用二级缓存时如果涌现脏数据，系统会报出错误并提示。

而MyBatis在这一方面，利用二级缓存时须要特殊小心。
如果不能完备确定数据更新操作的波及范围，避免Cache的盲目利用。
否则，脏数据的涌现会给系统的正常运行带来很大的隐患。

1.13. Hibernate 和 MyBatis 比拟总结

两者相同点

Hibernate与MyBatis都可以是通过SessionFactoryBuider由XML配置文件天生SessionFactory，然后由SessionFactory 天生Session，末了由Session来开启实行事务和SQL语句。
个中SessionFactoryBuider，SessionFactory，Session的生命周期都是差不多的。

Hibernate和MyBatis都支持JDBC和JTA事务处理。

Mybatis上风

MyBatis可以进行更为细致的SQL优化，可以减少查询字段。

MyBatis随意马虎节制，而Hibernate门槛较高。

Hibernate上风

Hibernate的DAO层开拓比MyBatis大略，Mybatis须要掩护SQL和结果映射。

Hibernate对工具的掩护和缓存要比MyBatis好，对增编削查的工具的掩护要方便。

Hibernate数据库移植性很好，MyBatis的数据库移植性不好，不同的数据库须要写不同SQL。

Hibernate有更好的二级缓存机制，可以利用第三方缓存。
MyBatis本身供应的缓存机制不佳，更新操作不能指定刷新指定记录，会清空全体表，但是也可以利用第三方缓存。

Hibernate 封装性好，屏蔽了数据库差异，自动天生SQL语句，应对数据库变革能力较弱，SQL语句优化困难。

MyBatis仅实现了SQL语句和工具的映射，须要针对详细的数据库写SQL语句，应对数据库变革能力较强，SQL语句优化较为方便。

1.14. SSH 和 SSM 比拟总结