要理解SSH三大框架，那么最好是用SSH三大框架做一个项目啦

这是一个模仿天猫的练手项目

1. 项目演示地址

前台： http://how2j.cn/tmall后台： http://how2j.cn/tmall/admin

2. 在本地跑起来看看效果

2.1 本地演示

上一步的演示地址是在别人的网站上的，最好呢，能在自己机器上也把这个项目跑起来，在本机看到效果。

为了方便同学在本机观看演示效果，特意准备了一个无需安装JDK,无需配置TOMCAT,无需安装配置数据库的可运行演示。

下载tomcat_with_jdk_hsqldb_tmall_ssh.rar

解压后运行 bin目录里的 startup.bat，就可以马上在本机看到和上述演示地址一样的效果：

2.2 使用Eclipse的Dynamic Web Project风格演示

上述的做法是为了方便同学们在本地看到效果，而特意把很多细节都封装起来了。 而这一步呢，会按照真正做一个SSH项目那样，创建一个Dynamic Web Project风格的项目，自己动手导入SQL语句，导入项目，在Eclipse中启动Tomcat，然后再访问地址，用这种风格在本地演示出项目的效果来。

由于演示数据较多：

tmall_ssh.sql 包含17个分类，每种分类下5个产品，总计85件产品。 每个产品下有20余张图片，总计1777张图片，以及属性和属性值等信息。

如果使用某些mysql工具导入，当数据量大的时候，会容易出错，所以提供了一个命令行格式以及指导，确保成功地导入数据：

相关下载里的 tmall_ssh_altogether.rar里包含了这个tmall_ssh项目。同样的，对于某些不太熟练的同学，也提供了一个说明，用于引导如何成功地导入这个项目到eclipse中，以便顺利地按照开发一个真实项目的方式，在本地演示起来。

如此这般，便可以自己也搭建一个模仿天猫的SSH项目，在自己的机器上看到效果，确认项目本身是可用的。

3. 学习风格

3.1 视频讲解

在关键功能部分，都是有视频讲解的，但是视频讲解有几个缺陷

• 看着老师敲代码很拖沓，速度慢，效率低，有时候自己都睡着了
• 有的视频较长，很难坚持一直全神贯注地听课。 有些关键部分，一走神没有听到，自己可能恰恰就卡在这里了
• 哪里有疑问，得回头再翻视频，得一点点再从头听，才能找到自己要的答案，花费时间较长，效率颇低
• 没有代码，或者只给出了最后的代码，中间步骤代码没有，自己即便照着视做，也常常卡壳

考虑到视频讲解确实存在这些问题，这个SSH项目的学习风格，不太一样：

3.2 学习建立在细节度很高的步骤截图和代码上

每一个步骤都进行了截图和文字讲解

每个步骤都给出了完整的代码，易于复制粘贴，便于使用

对关键方法都有非常细致的讲解

在大部分时候，甚至仅仅通过这个图文讲解，照着做，就可以把项目功能做出来了，甚至都不需要观看视频

3.3 先动手自己做，做的过程碰到问题了，再回头看视频，这样就是带着问题看视频了，有目标性，针对性强，学习效率高

3.4 每个项目的功能学习，都采用“先运行，看到效果，再学习的风格”

为了便于理解和消化，这个SSH项目，拆成了132个知识点和535个开发步骤。每个功能相关的知识点，右上角都有当前进度的可运行项目。

这样做有什么好处呢？

• 第一，确保按照这些步骤学习，是可以跑出来的，建立对教程的信心，巩固自己学习下去的信心。
• 第二，这种反向学习的方式，在看到效果之后，再来学习做了哪些步骤，这样更容易理解每个步骤的含义
• 第三，自己按照步骤，动手做。 即便是做错了，心里也有底，因为手里有个“正确答案”，对比与“正确答案”的区别，可以非常快速的定位问题代码所在，纠正错误。 其实学习编程啊，就是要犯很多错，不犯错，自己是不会有深刻印象的。 而采用这种方式，即便是犯错，也会以较快的方式定位到错在哪里，加快学习的效率。
• 第四，提供了一个在线代码比较器,方便定位问题所在

第五，自己做了一遍，犯了错误，再去比较“正确答案”，自己通过思考和探索找到问题所在，还有比这样更有效的学习吗？

4. 项目学习思路

这个用SSH框架做的模仿天猫内容还是比较丰富的，要想吸收和消化这个教程的内容也不容易，为了协助同学们步步为营，稳扎稳打地把这个项目吃掉，设计了如下的学习思路

4.1 由浅入深，从零开始

要说各种J2EE,SSH,SSM项目那是一抓一大把，git, 度娘， csdn上随便一搜，都是各种各样的。 可是拿到手的，都是别人现成的，做好了的项目了，即不便于阅读，也很难消化和理解。 这个教程呢，就从零开始，从无到有，一步一步地演示一个典型的项目是怎么做出来的。

• 从需求分析开始，明确要做哪些功能。
• 然后分析表结构，确定什么样的表结构，表关系，可以支撑需求中的业务功能。
• 接着准备界面原型，明确视图部分要做成什么样子
• 最后才开始进行前后台功能的具体开发
• 随着功能的开发，会逐渐察觉到SSH的不足之处，接着又实用重构的思路来解决和优化这些问题

4.2 分析要做什么（项目目标）

开始做项目之前，首先要确定要做成什么样子。

4.3 表结构设计

表结构设计是非常重要的，如果这一步没有做正确，将无法支持业务功能的需求，所以放在第一步来做。 在这部分列出了表与表之间的关系，建表的SQL语句等等。 值得一提的是，因为表比较多，为了便于理解每张表的作用，特意把表和前台页面截图做了对应，从感性上理解这些表都是干什么用的。

比如这个产品表与产品页面的截图，这样表的每个字段在界面上分别对应什么样的显示数据，对于这个表有什么用，心里就会有底很多。

4.4 后台第一个功能开发

在功能开发环节，比如后台功能，通常来说，大部分后台功能是比较接近的，主要是业务数据的CRUD操作。 而做第一个的时候，不仅需要规范化，对于不熟悉的同学，也会略感吃力。 所以在讲解如何做后台第一个分类管理功能的时候，把其拆的特别细，碾碎到很小的颗粒，这样消化起来就容易多了。

4.5 项目重构

随着使用SSH框架把分类管理的完成，不仅感受到SSH框架的便利性，同样对其存在的弊端也有所察觉了。 这个时候，就需要一个有多年工作经验，并且对这类问题有丰富解决手段的同志：我（脸红一秒） 来提出一个如何看待这些问题的角度，以及解决办法了。

而重构本身确实需要建立在相当的功力基础之上的，为了让同学们在重构这个环节尽可能多的收获更多，把重构行为的学习作成了一下几个部分以便消化。

• 首先提出当前存在的问题

• 接着需要重构的行为，拆成容易理解的知识点

• 并且每个重构知识点里，都采用由终至始的方式，先看重构的效果，然后再说怎么重构，最后再次通过比较，观察因为重构带来的好处。

• 持续重构

重构不是一蹴而就的，伴随这项目的进行，后续还会进行多次重构, 这些都是宝贵的项目经验积累，很宝贵的哦

4.6 其他后台

在完成了第一个后台管理之后，其他的后台管理也就比较容易掌握了

4.7 前台第一个功能

与后台一样，前台的第一个功能：首页，也会拿出来精讲

4.8 前台其他功能

首页做好了之后，就可以开始做前台的其他功能了：

5. SSH某些用法不熟悉怎么办？

既然学习SSH项目，自然是对SSH各种基本用法有一定了解的。 不过SSH内容确实较为丰富，难免有些地方即便是学习了，到用的时候，也记不起来了。 那怎么办呢？

当然是缺什么，学什么啦~ 这个时候，自己是处于饥饿状态，其实是对知识很好的吸收和消化的。 所以也提供了Hiberante,Spring,Struts ,SSH整合思路的免费教程：

做项目期间，哪里二麻二麻了，就回头看看相关教程，即巩固了SSH的基础，也让项目的学习流畅度更好

6. 可期待的收获

看上去这个项目也不短嘛，那么真正学完这个项目后，能够得到什么呢？

6.1 典型业务场景的掌握

所谓的典型业务场景就是各种商业项目里，都会有类似或者接近的功能。 在这个项目里你掌握了这些业务场景的开发，去工作之后，做类似的就能驾轻就熟。 那么都有哪些业务场景呢？

6.2 设计模式的掌握

设计模式的书和文章有很多，从我自己学习和工作的经验来看，如果一种设计模式，我只是在书上看过，却没有在实际工作中运用的话，那么犹如无根之树，打一把dota就忘记了，即无法深入理解其中的原理，也不能在真正工作的时候，灵活地运用到他们。

7. 教程地址：how2j.cn/t/59

教程由个人完成，局限于个人的经验和视野，有诸多不足之处，请各位多多指点，谢谢。

收藏的同学，请记得点个赞~

SSH框架一般指的是Struts、Spring、Hibernate，后来Struts2代替了Struts。最近5年，Struts2已经被Spring MVC代替，而Hibernate基本也被iBatis/MyBatis代替。

所以你真正需要了解的是Spring，Spring你需要了解两个概念AOP和IOC，更进一步就是Spring的核心技术“动态代理”。

持久层框架看看Hibernate/iBatis/MyBatis，研究一下Spring的数据库事务管理，各个持久层框架式如何实现ORM的，了解至少一种缓存框架，知道什么是数据库连接池。和数据库的交互最核心的不是ORM，而是掌握和数据库相关的能力，比如数据库编程、SQL优化、对范式的理解。

现在许许多多的初学者和程序员，都在趋之若鹜地学习Web开发的宝典级框架：Struts2，Spring，Hibernate。似乎这些框架成为了一个人是否精通Java，是否会写J2EE程序的唯一事实标准和找工作的必备基础。

然而，如果在面试的时候问这些程序员，你们为什么要学习这些框架？这些框架的本质到底是什么？似乎很少很少有人能够给我非常满意的答复。因为他们都在为了学习而学习，为了工作而学习，而不是在真正去深入了解一个框架。其实所有的人都应该思考这样的问题：为什么要学习框架？框架到底给我带来了什么？接下来，我们以登录作为一个最简单的例子，来看看不同的年代，我们是怎么写Web程序的。

后来，我们放弃了在页面上写逻辑。

后来，程序写得越来越多，我们发现，这种在HTML代码中编写Java代码来完成逻辑的方式存在着不少问题

1. Java代码由于混杂在一个HTML环境中而显得混乱不堪，可读性非常差。JSP文件有时候会变成几十K，甚至上百K。要找一段逻辑，经常无法位
   

2. 编写代码时非常困惑，不知道代码到底应该写在哪里，也不知道别人是不是已经曾经实现过类似的功能，到哪里去引用。

3. 突然之间，某个需求发生了变化。于是，每个人蒙头开始全程替换，还要小心翼翼的，生怕把别人的逻辑改了。

4. 逻辑处理程序需要自己来维护生命周期，对于类似数据库事务、日志等众多模块无法统一支持。

在这个时候，如果有一个产品，它能够将页面上的那些Java代码抽取出来，让页面上尽量少出现Java代码，该有多好。于是许多人开始使用servlet来处理那些业务逻辑。

1.public class LoginServlet extends HttpServlet {
2./* (non-Javadoc)
3.* @see javax.servlet.http.HttpServlet#doPost(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
4.*/
5.@Override
6.protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
7.String message = null;
8.RequestDispatcher dispatcher = req.getRequestDispatcher("/result.jsp");
9.String name = req.getParameter("name");
10.String password = req.getParameter("password");
11.UserHandler userHandler = new UserHandler();
12.if(userHandler.authenticate(name, password)) {
13.message = "恭喜你，登录成功";
14.} else {
15.message = "对不起，登录失败";
16.}
17.req.setAttribute("message", message);
18.dispatcher.forward(req, resp);
19.}
20.}

在这里，我们需要在web.xml中为这个servlet配置url的请求关系。

1.<servlet>
2.<servlet-name>Login</servlet-name>
3.<servlet-class>
4.com.demo2do.servlet.LoginServlet
5.</servlet-class>
6.</servlet>
7.<servlet-mapping>
8.<servlet-name>Login</servlet-name>
9.<url-pattern>
10./Login
11.</url-pattern>
12.</servlet-mapping>

代码重构到这里，我们发现，其实我们的工作量本身并没有减少，只是代码从JSP移动到了Servlet，使得整个流程看上去稍微清楚了一些。然而，为了这么点干净，我们付出的代价是什么？为每个servlet都在web.xml里面去做一个url的请求配置！

在很多年前，我们这么写程序的。

很多年前，那是一个贫苦的年代，如果我们要使用Java在网页上做一些动态的交互功能。很多人会告诉你一个技术，叫做JSP。在我还对Java非常困惑的时候，就有人告诉我，JSP是个好东西，它可以在HTML代码里面写Java代码来完成逻辑。

1.<%
2.String name = request.getParameter("name");
3.String password = request.getParameter("password");
4.UserHandler userHandler = new UserHandler();
5.if(userHandler.authenticate(name, password)) {
6.%>
7.<p>恭喜你，登录成功</p>
8.<%
9.} else {
10.%>
11.<p>对不起，登录失败</p>
12.<%
13.}
14.%>

作为一张JSP，它可以接收从别的JSP发送过来的登录请求，并进行处理。这样，我们不需要任何额外的配置文件，也不需要任何框架的帮忙，就能完成逻辑。

再后来，出现框架。

时代进一步发展，人们发现简单的JSP和Servlet已经很难满足人们懒惰的要求了。于是，人们开始试图总结一些公用的Java类，来解决Web开发过程中碰到的问题。这时，横空出世了一个框架，叫做struts。它非常先进地实现了MVC模式，成为了广大程序员的福音。

truts的代码示例我就不贴了，网上随便搜搜你可以发现一堆一堆的。在一定程度上，struts能够解决web开发中的职责分配问题，使得显示与逻辑分开。不过在很长一段时间内，使用struts的程序员往往无法分别我们到底需要web框架帮我们做什么，我们到底需要它完成点什么功能？

我们到底要什么？

在回顾了我们写代码的历史之后，我们回过头来看看，我们到底要什么？

无论是使用JSP，还是使用Struts1，或是Struts2，我们至少都需要一些必须的元素（如果没有这些元素，或许我还真不知道这个程序会写成什么样子）：

1. 数据

在这个例子中，就是name和password。他们共同构成了程序的核心载体。事实上，我们往往会有一个User类来封装name和password，这样会使得我们的程序更加OO。无论怎么说，数据会穿插在这个程序的各处，成为程序运行的核心。

2.页面展示

在这个例子中，就是login.jsp。没有这个页面，一切的请求、验证和错误展示也无从谈起。在页面上，我们需要利用HTML，把我们需要展现的数据都呈现出来。同时我们也需要完成一定的页面逻辑，例如，错误展示，分支判断等等。

3.处理具体业务的场所

在这里，不同阶段，处理具体业务的场所就不太一样。原来用JSP和Servlet，后来用Struts1或者Struts2的Action。

上面的这些必须出现的元素，在不同的年代，被赋予了不同的表现形式，有的受到时代的束缚，其表现形式非常落后，有的已经不再使用。但是拨开这些外在的表现形式，我们就可以发现，这不就是我们已经熟门熟路的MVC嘛？

数据 —— Model

页面展示 —— View

处理具体业务的场所 —— Control

所以，框架不重要，概念是王道。只要能够深刻理解MVC的概念，框架对你来说，只是一个jar包而已。

MVC的概念其实就那么简单，这些概念其实早已深入我们的内心，而我们所缺乏的是将其本质挖掘出来。我们来看看下面这幅图，这是一副流行了很多年的讲述MVC模型的图：

在这幅图中，MVC三个框框各司其职，结构清晰明朗。不过我觉得这幅图忽略了一个问题，就是数据是动的，数据在View和Control层一旦动起来，就会产生许多的问题：

1. 数据从View层传递到Control层，如何使得一个个扁平的字符串，转化成一个个生龙活虎的Java对象。

2. 数据从View层传递到Control层，如何方便的进行数据格式和内容的校验？

3. 数据从Control层传递到View层，一个个生龙活虎的Java对象，又如何在页面上以各种各样的形式展现出来。

4.如果你试图将数据请求从View层发送到Control层，你如何才能知道你要调用的究竟是哪个类，哪个方法？一个Http的请求，又如何与Control层的Java代码建立起关系来？

除此之外，Control层似乎也没有想象中的那么简单，因为它作为一个控制器，至少还需要处理以下的问题：

1. 作为调用逻辑处理程序的facade门面，如果逻辑处理程序发生了异常，我们该如何处理？

2. 对于逻辑处理的结果，我们需要做怎么样的处理才能满足丰富的前台展示需要？

这一个又一个问题的提出，都基于对MVC的基本概念的挖掘。所以，这些问题都需要我们在写程序的时候去一一解决。说到这里，这篇文章开头所提的问题应该可以有答案了：框架是为了解决一个又一个在Web开发中所遇到的问题而诞生的。不同的框架，都是为了解决不同的问题，但是对于程序员而言，他们只是jar包而已。框架的优缺点的评论，也完全取决于其对问题解决程度和解决方式的优雅性的评论。所以，千万不要为了学习框架而学习框架，而是要为了解决问题而学习框架，这才是一个程序员的正确学习之道。

深入浅出的理解框架（Struts2、Hibernate、Spring）与 MVC 设计模式

推荐一本书，写得非常好《Struts2+技术内幕——深入解析Struts2架构设计与实现原理》——孔夫子网有卖的

.net和J2EE两大平台诞生之后，组件化编程技术盛极一时，Web技术的发展开始了一段框架横飞的年代，各种辅助Web开发的技术框架层出不穷。虽然脚本语言大大提高了应用开发效率，但是试想一个复杂的大型Web应用，访问各种功能的URL地址纷繁复杂，涉及到的Web页面多种多样，同时还管理着大量的后台数据，因此我们需要在架构层面上解决维护性和扩展性等问题。这个时候，MVC的概念被引入到Web开发中来了。2004年出现的Struts就是当时非常流行的Java Web开发的MVC框架。MVC早在1978年就作为Smalltalk的一种设计模式被提出来了，应用到Web应用上，模型Model用于封装与业务逻辑相关的数据和数据处理方法，视图View是数据的HTML展现，控制器Controller负责响应请求，协调Model和View。Model，View和Controller的分开，是一种典型的关注点分离的思想，不仅使得代码复用性和组织性更好，使得Web应用的配置性和灵活性更好。这是Spring MVC的示意图，典型的MVC架构。

此外，数据访问也逐渐通过面向对象的方式来替代直接的SQL访问，出现了ORM（Object Relation Mapping）的概念，2001年出现的Hibernate就是其中的佼佼者，已经成为Java持久层的规范JPA的主要参考和实现。更多的全栈框架开始出现，比如2003年出现的Java开发框架Spring，同时更多的动态语言也被加入到Web编程语言的阵营中，2004年出现的Ruby开发框架Rails，2005出现的Python开发框架Django，都提供了全栈开发框架，或者自身提供Web开发的各种组件，或者可以方便的集成各种组件。比如Spring基于IoC和AOP思想可以方便得整合出全套Web开发组件，SSH（Struts+Spring+Hibernate）一度成为Java Web开发的标配。值得一提的时Rails这个MVC框架，26岁的丹麦大神David Heinemeier Hansson在开发著名项目管理软件BaseCamp的过程中形成，Ruby语言本身在快速开发上的优势，加上Rails诸如崇尚DRY（Don't）Repeat Yourself)原则, 约定优于配置，拥抱REST等特性，使其迅速成为一个极其流行的Web开发框架。

我想从非科班零基础自学的新手角度，结合画图谈谈我对框架学习的理解。主要面向和我一样的零基础小白，有基础的朋友请不要浪费时间在我这个回答上，哈哈。

5个月前，我看视频自学到了框架，顺序是ssh，ssm。网上能找到的框架视频都讲得不是很好，要么没讲清楚为什么用这个框架，要么连怎么用都讲不清楚。当时上知乎关注了这个话题，看了很多答案，都讲得很不错。有些观点一针见血指出了框架的本质，让我后来学习框架时不至于分不清重点。

一个概念：工具类和框架的区别？

小白刚开始学习框架时，肯定都想过：框架和之前学的commons下的beanUtils之类的工具类有什么区别？就是大一点吗？笼统地讲，框架确实可以理解为“很大很全”的工具类。但是有一点很不一样。

我们在自己的代码中调用工具类，提高开发效率。此时工具类就像钥匙，是工具，我们用它开门；
而框架呢？我们写好自己的代码被框架调用。框架就像房子，我们的代码是窗户，窗户是嵌在房子里的。

零基础小白如何学习框架？

对于一路看视频自学的小白来说，叫他去看书是不负责任的。就像你推荐小白去看《Java编程思想》一样。很多人根本无法体会小白装好Eclipse后，面对那么多视窗却不知道点哪里的绝望。

虽然视频没有书本讲的深刻，学完也初步能干活了。但是没有方法还是学不好框架。在我看来，学习框架时，心里至少要带着下面的疑问：

• 这个框架是负责哪一块的，用在哪一层？
• 没有它之前，前辈们如何解决，又什么缺点？
• 它的出现解决了哪些痛点？
• 它是否也有什么缺点？（这个暂时不作要求）

下面以MyBatis举例，讲讲非科班零基础小白如何学习框架才能形成自己的理解。学一样东西，能形成自己的理解，至少说明你学得不糊涂。

我打算按照答题的形式，通过逐一解答上面的提问来理解MyBatis：

• MyBatis是对JDBC的封装，负责和数据库打交道，我们在dao层会用到它。

MyBatis出现之前，我们可以用Hibernate框架，一个非常优秀的ORM框架。

但是在Hibernate更早更早之前的上古时代，我们的程序猿祖先就用JDBC。

• 但是JDBC的缺点也十分明显：

所以后来我们都很少在dao层手写JDBC，而是用封装了JDBC的框架，比如轻量而优秀的MyBatis。

这里顺便简单对比下Hibernate和MyBatis。因为同为dao层框架，它们总是被人拿来比较：

• MyBatis解决了JDBC的哪些痛点呢：

按照这样自问自答式的学习方法，基本上，一遍视频撸下来，就能形成对框架的感性认识。为后期深入学习打下基础。

另外，Spring最核心的概念就两个：AOP（切面编程）和DI（依赖注入）。DI又依赖IoC。

这里不打算详细说，就简单画个图，只介绍DI和IoC。

简而言之，原先创建对象以及注入对象都是采取“人盯人”战术，一个咬着一个。有了Spring以后，通过IoC，所有的对象都可以从Spring容器中得到。每个对象由Spring注入到它应该去的地方。这种由原先对象管理切换到Spring管理的方式，就是所谓的IoC（控制反转），因为创建、管理对象的角色反过来了，有每个对象自主管理变为Spring统一管理。

而且，只有通过IoC先由Spring创建对象后，才能进行下一步对象注入（DI），所以说DI依赖IoC。

上面有说错的地方，请斧正。

另外，上面MyBatis的画图只是我学习笔记的一部分，这里是MyBatis的完整笔记，就一张图：

链接：https://pan.baidu.com/s/1c4febEK 密码：md4u

最后，这是作为小白的我的学习路线：

黄孙挺：零基础Java学习路线zhuanlan.zhihu.com

还ssh，多少年前啊！知识要更新啊

现在没有strut了，用spring谁会用stuct呢？

好好理解spring的ioc，aop的原理，思想，实现方式，bean的作用域的使用实现，spring的各种扩展点，这些才是重要的。

我们知道，传统的Java Web应用程序是采用JSP+Servlet+Javabean来实现的，这种模式实现了最基本的MVC分层，使的程序结构分为几层，有负责前台展示的 JSP、负责流程逻辑控制的Servlet以及负责数据封装的Javabean。但是这种结构仍然存在问题：如JSP页面中需要使用符号嵌入很多的 Java代码，造成页面结构混乱，Servlet和Javabean负责了大量的跳转和运算工作，耦合紧密，程序复用度低等等。

Struts

为了解决这些问题，出现了Struts框架，它是一个完美的MVC实现，它有一个中央控制类(一个 Servlet)，针对不同的业务，我们需要一个Action类负责页面跳转和后台逻辑运算，一个或几个JSP页面负责数据的输入和输出显示，还有一个 Form类负责传递Action和JSP中间的数据。JSP中可以使用Struts框架提供的一组标签，就像使用HTML标签一样简单，但是可以完成非常复杂的逻辑。从此JSP页面中不需要出现一行包围的Java代码了。

可是所有的运算逻辑都放在Struts的Action里将使得 Action类复用度低和逻辑混乱，所以通常人们会把整个Web应用程序分为三层，Struts负责显示层，它调用业务层完成运算逻辑，业务层再调用持久层完成数据库的读写。

使用JDBC连接来读写数据库，我们最常见的就是打开数据库连接、使用复杂的SQL语句进行读写、关闭连接，获得的数据又需要转换或封装后往外传，这是一个非常烦琐的过程。

Hibernate

这时出现了 Hibernate框架，它需要你创建一系列的持久化类，每个类的属性都可以简单的看做和一张数据库表的属性一一对应，当然也可以实现关系数据库的各种表件关联的对应。当我们需要相关操作是，不用再关注数据库表。我们不用再去一行行的查询数据库，只需要持久化类就可以完成增删改查的功能。使我们的软件开发真正面向对象，而不是面向混乱的代码。

现在我们有三个层了，可是每层之间的调用是怎样的呢?比如显示层的Struts需要调用一个业务类，就需要new一个业务类出来，然后使用;业务层需要调用持久层的类，也需要new一个持久层类出来用。通过这种new的方式互相调用就是软件开发中最糟糕设计的体现。简单的说，就是调用者依赖被调用者，它们之间形成了强耦合，如果我想在其他地方复用某个类，则这个类依赖的其他类也需要包含。程序就变得很混乱，每个类互相依赖互相调用，复用度极低。如果一个类做了修改，则依赖它的很多类都会受到牵连。为此，出现Spring框架。

Spring

Spring的作用就是完全解耦类之间的依赖关系，一个类如果要依赖什么，那就是一个接口。至于如何实现这个接口，这都不重要了。只要拿到一个实现了这个接口的类，就可以轻松的通过xml配置文件把实现类注射到调用接口的那个类里。所有类之间的这种依赖关系就完全通过配置文件的方式替代了。所以 Spring框架最核心的就是所谓的依赖注射和控制反转。

现在的结构是，Struts负责显示层，Hibernate负责持久层，Spring负责中间的业务层，另外，由于Spring使用的依赖注射以及AOP(面向方面编程)，所以它的这种内部模式非常优秀，以至于Spring自己也实现了一个使用依赖注射的MVC框架，叫做Spring MVC，同时为了很好的处理事物，Spring集成了Hibernate，使事物管理从Hibernate的持久层提升到了业务层，使用更加方便和强大。

&amp;lt;img src=&quot;https://pic2.zhimg.com/50/v2-96eb7b4c1fec5837210d564f2baa5da2_hd.jpg&quot; data-rawwidth=&quot;1751&quot; data-rawheight=&quot;803&quot; class=&quot;origin_image zh-lightbox-thumb&quot; width=&quot;1751&quot; data-original=&quot;https://pic2.zhimg.com/v2-96eb7b4c1fec5837210d564f2baa5da2_r.jpg&quot;&amp;gt;

要理解三大框架，先要理解JavaEE三层架构。

web层之前的事情是由servlet来处理，之后出现了Struts2，它把servlet这部分的事情取代了。

而dao层，负责的是数据的操作。你之前可能用过自己配置的连接池或者c3p0、DBUtils这样的工具，但那些还不够面向对象。于是出现了hibernate这样的ORM（object relational mapping）框架，对底层的数据库操作进行封装，持久化数据。

service层的业务由JavaBean负责。而spring的IoC、AOP这些高级特性可以帮你更好地管理对象。

作为一名多年的老程序员。建议楼主看看Nutz这个框架。它号称是ssh之外的另一个选择。

这个框架的的体积比较小。但是功能一点也不弱。基本上你能用到的大多数功能它都能很好的完成。代码比较简约。注释和文档比较齐全。研究它比研究ssh却更加轻。初学者花一周左右的时间就能明白了大概。如果是资深程序员，一两天就能完全上手。

因为Nutz比较简单，通过研究它，你可以更快的了解MVC, ORM, AOP, Ioc 等概念。在这些概念被你充分了解之后，翻回头再学 Spring，往往会事半功倍，获得更好的学习效果。

说下我的理解，讲最主要的。

SpringMVC，将大型项目明确为层次的概念，前端，控制端，服务端，dao。其实大企业往往分得更细，biz业务层，core核心服务层。方便大型项目的快去迭代开发和新人去理解项目（互联网流动率太大，一个项目不同的人同时在开发不同的功能）

Mybatis，Hibernate，将对数据库的操作的思维转向对对象操作的思维。这样思维就统一了，你的点一直聚焦在对象和业务上，不用去关注单纯的数据而导致和业务割裂。

Spring，一切可注入，可拦截，可事务，各种标准组件。这样每个bean，每个接口都活了，可以各种拼装，各种组合而不用在代码层面改变，只需要在配置或者注解层面实施。

赶紧改行

如果你还不具备通过阅读官方文档/教程学习一个开发框架使用的能力的话

运用唯物主义辩证法思想，这个世界的每个物体都是独立统一而又互相联系的，我们的JAVAWEB开发也一样。

大型项目，如果不分层编写代码，很容易导致逻辑混乱，也不适合团队开发与维护。于是就出现了MVC的分层思想。

为了让MVC的思想更加彻底，以及编程自动化（我发明的词），于是发明了SSH。

具体来说，Hibernate解决了SQL语句与面向对象编程的冲突，Struts解决了页面跳转问题采用过滤器实现，Spring通过面向接口实现了action层、service层与DAO层的解耦，SSH框架通过XML文档（注解）来实现各个模块的联系。

我们知道，传统的Java Web应用程序是采用JSP+Servlet+Javabean来实现的，这种模式实现了最基本的MVC分层，使的程序结构分为几层，有负责前台展示的 JSP、负责流程逻辑控制的Servlet以及负责数据封装的Javabean。但是这种结构仍然存在问题：如JSP页面中需要使用符号嵌入很多的 Java代码，造成页面结构混乱，Servlet和Javabean负责了大量的跳转和运算工作，耦合紧密，程序复用度低等等。

Struts

为了解决这些问题，出现了Struts框架，它是一个完美的MVC实现，它有一个中央控制类(一个 Servlet)，针对不同的业务，我们需要一个Action类负责页面跳转和后台逻辑运算，一个或几个JSP页面负责数据的输入和输出显示，还有一个 Form类负责传递Action和JSP中间的数据。JSP中可以使用Struts框架提供的一组标签，就像使用HTML标签一样简单，但是可以完成非常复杂的逻辑。从此JSP页面中不需要出现一行包围的Java代码了。

可是所有的运算逻辑都放在Struts的Action里将使得 Action类复用度低和逻辑混乱，所以通常人们会把整个Web应用程序分为三层，Struts负责显示层，它调用业务层完成运算逻辑，业务层再调用持久层完成数据库的读写。

使用JDBC连接来读写数据库，我们最常见的就是打开数据库连接、使用复杂的SQL语句进行读写、关闭连接，获得的数据又需要转换或封装后往外传，这是一个非常烦琐的过程。

Hibernate

这时出现了 Hibernate框架，它需要你创建一系列的持久化类，每个类的属性都可以简单的看做和一张数据库表的属性一一对应，当然也可以实现关系数据库的各种表件关联的对应。当我们需要相关操作是，不用再关注数据库表。我们不用再去一行行的查询数据库，只需要持久化类就可以完成增删改查的功能。使我们的软件开发真正面向对象，而不是面向混乱的代码。

现在我们有三个层了，可是每层之间的调用是怎样的呢?比如显示层的Struts需要调用一个业务类，就需要new一个业务类出来，然后使用;业务层需要调用持久层的类，也需要new一个持久层类出来用。通过这种new的方式互相调用就是软件开发中最糟糕设计的体现。简单的说，就是调用者依赖被调用者，它们之间形成了强耦合，如果我想在其他地方复用某个类，则这个类依赖的其他类也需要包含。程序就变得很混乱，每个类互相依赖互相调用，复用度极低。如果一个类做了修改，则依赖它的很多类都会受到牵连。为此，出现Spring框架。

Spring

Spring的作用就是完全解耦类之间的依赖关系，一个类如果要依赖什么，那就是一个接口。至于如何实现这个接口，这都不重要了。只要拿到一个实现了这个接口的类，就可以轻松的通过xml配置文件把实现类注射到调用接口的那个类里。所有类之间的这种依赖关系就完全通过配置文件的方式替代了。所以 Spring框架最核心的就是所谓的依赖注射和控制反转。

现在的结构是，Struts负责显示层，Hibernate负责持久层，Spring负责中间的业务层，另外，由于Spring使用的依赖注射以及AOP(面向方面编程)，所以它的这种内部模式非常优秀，以至于Spring自己也实现了一个使用依赖注射的MVC框架，叫做Spring
MVC，同时为了很好的处理事物，Spring集成了Hibernate，使事物管理从Hibernate的持久层提升到了业务层，使用更加方便和强大。

现在的多的还是：Spring MVC、SSM,Spring Boot。

个人浅见：

1.不跳出ssh的框框，就无法理解ssh框架。刚入手web开发工作/学习，就试图去理解SSH，个人观点，这是被培训机构带偏了。

2.SSH本身的意义不是为了程序员，而是为了老板，虽然这种尝试不一定成功。其根本目的是为了“web开发傻瓜化”——降低人力成本。

3.就我所知，似乎并没有招聘的技术考官会在意对方对SSH的掌控程度。

顺便附一条链接，这是我很早以前写的一个系列，目的是为了“怼”我team里面的“唯框架至上”思想，非广告推广：） 希望对你有用。

WEB开发那些事儿

现在在学框架呢，怎么说呢。Struts2MVC其实理解起来比较简单吧 。

就是jsp（前台） 然后是通过action———sturts2.xml————Action（java servlet处理表单数据）————jsp。感觉有瑕疵写的有点问题。struts2方面之处就是讲各种复杂的表单显示什么的（radio，checkbox）变成了一个个<s:>标签。

spring的话现在在学源码。