如何理解 ssh 三大框架

JAVA 框架 专栏收录该内容
2 篇文章 0 订阅
作者:meepo
链接:https://www.zhihu.com/question/30525693/answer/199488905
来源:知乎
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

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

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

1. 项目演示地址

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

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

2.1 本地演示

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

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

下载tomcat_with_jdk_hsqldb_tmall_ssh.rar


<img src="https://pic4.zhimg.com/50/v2-435c69f21d0f616db74c307dd4b45213_hd.jpg" data-rawwidth="454" data-rawheight="127" class="origin_image zh-lightbox-thumb" width="454" data-original="https://pic4.zhimg.com/v2-435c69f21d0f616db74c307dd4b45213_r.jpg">

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


<img src="https://pic2.zhimg.com/50/v2-060378817dd568a33aee6bc60ec0da1c_hd.jpg" data-rawwidth="994" data-rawheight="592" class="origin_image zh-lightbox-thumb" width="994" data-original="https://pic2.zhimg.com/v2-060378817dd568a33aee6bc60ec0da1c_r.jpg">



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

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


<img src="https://pic4.zhimg.com/50/v2-2ff60b82d929a1118c3291e6cb0fd1dc_hd.jpg" data-rawwidth="448" data-rawheight="165" class="origin_image zh-lightbox-thumb" width="448" data-original="https://pic4.zhimg.com/v2-2ff60b82d929a1118c3291e6cb0fd1dc_r.jpg">


由于演示数据较多:

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

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


<img src="https://pic1.zhimg.com/50/v2-868473b117d7476c8f641efefede75d1_hd.jpg" data-rawwidth="856" data-rawheight="60" class="origin_image zh-lightbox-thumb" width="856" data-original="https://pic1.zhimg.com/v2-868473b117d7476c8f641efefede75d1_r.jpg">

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


<img src="https://pic1.zhimg.com/50/v2-5c72a107073ac2777abeb729e5bc7db3_hd.jpg" data-rawwidth="819" data-rawheight="71" class="origin_image zh-lightbox-thumb" width="819" data-original="https://pic1.zhimg.com/v2-5c72a107073ac2777abeb729e5bc7db3_r.jpg">

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

3. 学习风格

3.1 视频讲解


<img src="https://pic4.zhimg.com/50/v2-ac59b1fd0bc2b0af77b6fe6c3bb57130_hd.jpg" data-rawwidth="284" data-rawheight="209" class="content_image" width="284">


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

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

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

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

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


<img src="https://pic3.zhimg.com/50/v2-6192cca2a59081e64e93f8b947907220_hd.jpg" data-rawwidth="266" data-rawheight="356" class="content_image" width="266">


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


<img src="https://pic4.zhimg.com/50/v2-ae9fa0b479b0b65e5b8ff52ba7c3a7e7_hd.jpg" data-rawwidth="641" data-rawheight="454" class="origin_image zh-lightbox-thumb" width="641" data-original="https://pic4.zhimg.com/v2-ae9fa0b479b0b65e5b8ff52ba7c3a7e7_r.jpg">


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


<img src="https://pic3.zhimg.com/50/v2-f0aa59ccd6f3b4f61dcd076454e750c9_hd.jpg" data-rawwidth="750" data-rawheight="258" class="origin_image zh-lightbox-thumb" width="750" data-original="https://pic3.zhimg.com/v2-f0aa59ccd6f3b4f61dcd076454e750c9_r.jpg">


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

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


<img src="https://pic3.zhimg.com/50/v2-fc67c979a5e9bc0eb427cc3b201eaadf_hd.jpg" data-rawwidth="625" data-rawheight="56" class="origin_image zh-lightbox-thumb" width="625" data-original="https://pic3.zhimg.com/v2-fc67c979a5e9bc0eb427cc3b201eaadf_r.jpg">


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


<img src="https://pic4.zhimg.com/50/v2-4643c59d049e191a0d82f0f68aebc9ef_hd.jpg" data-rawwidth="276" data-rawheight="110" class="content_image" width="276">

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

这样做有什么好处呢?

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


<img src="https://pic4.zhimg.com/50/v2-81e62c91c3c3d52ce7af14b9932585ad_hd.jpg" data-rawwidth="982" data-rawheight="509" class="origin_image zh-lightbox-thumb" width="982" data-original="https://pic4.zhimg.com/v2-81e62c91c3c3d52ce7af14b9932585ad_r.jpg">

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


4. 项目学习思路

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

4.1 由浅入深,从零开始

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

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


<img src="https://pic2.zhimg.com/50/v2-eed161c34c533bec57e5ac03a253a6a6_hd.jpg" data-rawwidth="164" data-rawheight="506" class="content_image" width="164">


4.2 分析要做什么(项目目标)

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


<img src="https://pic3.zhimg.com/50/v2-84372e08c8f78fa6e51705ca26704779_hd.jpg" data-rawwidth="169" data-rawheight="132" class="content_image" width="169">


4.3 表结构设计

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

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


<img src="https://pic3.zhimg.com/50/v2-c8d602aac04b9408942acfaac7e60e87_hd.jpg" data-rawwidth="720" data-rawheight="693" class="origin_image zh-lightbox-thumb" width="720" data-original="https://pic3.zhimg.com/v2-c8d602aac04b9408942acfaac7e60e87_r.jpg">


4.4 后台第一个功能开发

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


<img src="https://pic2.zhimg.com/50/v2-f56e131e0145bff511b6d15f9750fdf4_hd.jpg" data-rawwidth="177" data-rawheight="517" class="content_image" width="177">


4.5 项目重构

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

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

  • 首先提出当前存在的问题
<img src="https://pic4.zhimg.com/50/v2-b1e43990bc00b72508468c124fc2c6b3_hd.jpg" data-rawwidth="208" data-rawheight="111" class="content_image" width="208">
  • 接着需要重构的行为,拆成容易理解的知识点


<img src="https://pic4.zhimg.com/50/v2-3ea3908c302e73b6d7b3e0f8934fafbb_hd.jpg" data-rawwidth="168" data-rawheight="162" class="content_image" width="168">


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


<img src="https://pic1.zhimg.com/50/v2-222c66643ef049eb1c777cd52b2e2d22_hd.jpg" data-rawwidth="365" data-rawheight="291" class="content_image" width="365">
  • 持续重构

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


<img src="https://pic1.zhimg.com/50/v2-078b99f7631c3ed05885117ba7f7f35d_hd.jpg" data-rawwidth="171" data-rawheight="445" class="content_image" width="171">


4.6 其他后台

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


<img src="https://pic1.zhimg.com/50/v2-fb6dc62ad96c309f56285076df143798_hd.jpg" data-rawwidth="172" data-rawheight="449" class="content_image" width="172">


4.7 前台第一个功能

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


<img src="https://pic2.zhimg.com/50/v2-ff8556a152a8caaf3ac077aa03a1cdd5_hd.jpg" data-rawwidth="172" data-rawheight="343" class="content_image" width="172">


4.8 前台其他功能

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


<img src="https://pic1.zhimg.com/50/v2-44277eea59443fde4f0211896d9411c1_hd.jpg" data-rawwidth="388" data-rawheight="637" class="content_image" width="388">

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

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

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


<img src="https://pic4.zhimg.com/50/v2-43bc0e56d5054bd4a39cf13fda10a7a9_hd.jpg" data-rawwidth="997" data-rawheight="601" class="origin_image zh-lightbox-thumb" width="997" data-original="https://pic4.zhimg.com/v2-43bc0e56d5054bd4a39cf13fda10a7a9_r.jpg">


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

6. 可期待的收获

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

6.1 典型业务场景的掌握

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


<img src="https://pic2.zhimg.com/50/v2-bd91f2eff235651f6fc4cf97694e5a2b_hd.jpg" data-rawwidth="472" data-rawheight="899" class="origin_image zh-lightbox-thumb" width="472" data-original="https://pic2.zhimg.com/v2-bd91f2eff235651f6fc4cf97694e5a2b_r.jpg">




6.2 设计模式的掌握

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


<img src="https://pic2.zhimg.com/50/v2-353fde0fa903529efc5b2d6cead49747_hd.jpg" data-rawwidth="991" data-rawheight="427" class="origin_image zh-lightbox-thumb" width="991" data-original="https://pic2.zhimg.com/v2-353fde0fa903529efc5b2d6cead49747_r.jpg">

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

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

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

442 ​43 条评论
​分享
​收藏 ​感谢 收起
184 人赞同了该回答

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优化、对范式的理解。

MVC框架Struts2和Spring MVC,你需要知道他们在web.xml文件里配置了一些什么,Struts2/Spring MVC接到前台请求之后经过哪些步骤之后转到Action/Controller,return之后Struts2/Spring MVC又作了些什么。还有就是Filter、Listener和Struts2/Spring MVC的拦截器各有什么特点,适合处理什么样的问题。
184 ​18 条评论
微信二维码 ​分享
​收藏 ​感谢
345 人赞同了该回答

现在许许多多的初学者和程序员,都在趋之若鹜地学习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模型的图:

&amp;lt;img src=&quot;https://pic2.zhimg.com/50/0e02099f274960fea817acee03441d9d_hd.jpg&quot; data-rawwidth=&quot;629&quot; data-rawheight=&quot;370&quot; class=&quot;origin_image zh-lightbox-thumb&quot; width=&quot;629&quot; data-original=&quot;https://pic2.zhimg.com/0e02099f274960fea817acee03441d9d_r.jpg&quot;&amp;gt;

在这幅图中,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架构设计与实现原理》——孔夫子网有卖的

345 ​35 条评论
​分享
​收藏 ​感谢 收起
21 人赞同了该回答
你从更广更高的视角去理解,延展到整个Web应用的技术发展和架构变迁来看,你会理解得更加深刻。你能对这些内容侃侃而谈,相信对于面试有很大加分。

参考我这个回答 Web 建站技术中,HTML、HTML5、XHTML、CSS、SQL、JavaScript、PHP、ASP.NET、Web Services 是什么? - David 的回答

下面是跟SSH相关的一部分内容:

5、框架横飞的年代:MVC,ORM

.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架构。

&amp;lt;img src=&quot;https://pic3.zhimg.com/50/74d19098c5883b5c3e70b9f6c2af7507_hd.jpg&quot; data-rawwidth=&quot;800&quot; data-rawheight=&quot;513&quot; class=&quot;origin_image zh-lightbox-thumb&quot; width=&quot;800&quot; data-original=&quot;https://pic3.zhimg.com/74d19098c5883b5c3e70b9f6c2af7507_r.jpg&quot;&amp;gt;

此外,数据访问也逐渐通过面向对象的方式来替代直接的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开发框架。

&amp;lt;img src=&quot;https://pic3.zhimg.com/50/db0c9d64d4ecc29645bb12823edc083e_hd.jpg&quot; data-rawwidth=&quot;651&quot; data-rawheight=&quot;304&quot; class=&quot;origin_image zh-lightbox-thumb&quot; width=&quot;651&quot; data-original=&quot;https://pic3.zhimg.com/db0c9d64d4ecc29645bb12823edc083e_r.jpg&quot;&amp;gt; 可以看这篇文章: Web开发技术发展历史
21 ​1 条评论
​分享
​收藏 ​感谢 收起
92 人赞同了该回答

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

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




一个概念:工具类和框架的区别?

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

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




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

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

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

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

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


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

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

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

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

&amp;lt;img src=&quot;https://pic2.zhimg.com/50/v2-b0e012a4da3db8a1d50a96c909676b49_hd.jpg&quot; data-caption=&quot;&quot; data-size=&quot;normal&quot; data-rawwidth=&quot;600&quot; data-rawheight=&quot;395&quot; class=&quot;origin_image zh-lightbox-thumb&quot; width=&quot;600&quot; data-original=&quot;https://pic2.zhimg.com/v2-b0e012a4da3db8a1d50a96c909676b49_r.jpg&quot;&amp;gt;


  • 但是JDBC的缺点也十分明显:
&amp;lt;img src=&quot;https://pic3.zhimg.com/50/v2-73360105c64d92c0088d5ec4838e7857_hd.jpg&quot; data-caption=&quot;&quot; data-size=&quot;normal&quot; data-rawwidth=&quot;1239&quot; data-rawheight=&quot;680&quot; class=&quot;origin_image zh-lightbox-thumb&quot; width=&quot;1239&quot; data-original=&quot;https://pic3.zhimg.com/v2-73360105c64d92c0088d5ec4838e7857_r.jpg&quot;&amp;gt;


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

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

&amp;lt;img src=&quot;https://pic4.zhimg.com/50/v2-b146deb24aa0db96697d6ccb376d7364_hd.jpg&quot; data-caption=&quot;&quot; data-size=&quot;normal&quot; data-rawwidth=&quot;1091&quot; data-rawheight=&quot;899&quot; class=&quot;origin_image zh-lightbox-thumb&quot; width=&quot;1091&quot; data-original=&quot;https://pic4.zhimg.com/v2-b146deb24aa0db96697d6ccb376d7364_r.jpg&quot;&amp;gt;


  • MyBatis解决了JDBC的哪些痛点呢:
&amp;lt;img src=&quot;https://pic4.zhimg.com/50/v2-0b550d19c9d02d3c422e2c95ad92e8d8_hd.jpg&quot; data-caption=&quot;&quot; data-size=&quot;normal&quot; data-rawwidth=&quot;1047&quot; data-rawheight=&quot;890&quot; class=&quot;origin_image zh-lightbox-thumb&quot; width=&quot;1047&quot; data-original=&quot;https://pic4.zhimg.com/v2-0b550d19c9d02d3c422e2c95ad92e8d8_r.jpg&quot;&amp;gt;

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


另外,Spring最核心的概念就两个:AOP(切面编程)和DI(依赖注入)。DI又依赖IoC。

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

&amp;lt;img src=&quot;https://pic4.zhimg.com/50/v2-95995df0d438275afb42f044a174845b_hd.jpg&quot; data-caption=&quot;&quot; data-size=&quot;normal&quot; data-rawwidth=&quot;1057&quot; data-rawheight=&quot;899&quot; class=&quot;origin_image zh-lightbox-thumb&quot; width=&quot;1057&quot; data-original=&quot;https://pic4.zhimg.com/v2-95995df0d438275afb42f044a174845b_r.jpg&quot;&amp;gt;




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

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

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

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

链接:pan.baidu.com/s/1c4febE 密码:md4u

最后,这是作为小白的我的学习路线:

黄孙挺:零基础Java学习路线zhuanlan.zhihu.com图标
92 ​16 条评论
​分享
​收藏 ​感谢 收起
34 人赞同了该回答
自从离开北大青鸟我就没见有人谈过Java的SSH,说的都是*nix的SSH工具。
34 ​16 条评论
​分享
​收藏 ​感谢
4 人赞同了该回答

还ssh,多少年前啊!知识要更新啊

现在没有strut了,用spring谁会用stuct呢?

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

4 ​添加评论
​分享
​收藏 ​感谢
我觉得现在框架就spring,其他都是工具
0 ​添加评论
​分享
​收藏 ​感谢
13 人赞同了该回答

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


&amp;lt;img src=&quot;https://pic1.zhimg.com/50/v2-c8745e983307a44ff4b43b818421a60c_hd.jpg&quot; data-rawwidth=&quot;1008&quot; data-rawheight=&quot;525&quot; class=&quot;origin_image zh-lightbox-thumb&quot; width=&quot;1008&quot; data-original=&quot;https://pic1.zhimg.com/v2-c8745e983307a44ff4b43b818421a60c_r.jpg&quot;&amp;gt;


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的持久层提升到了业务层,使用更加方便和强大。

13 ​1 条评论
​分享
​收藏 ​感谢 收起
8 人赞同了该回答
java框架的学习有一个最基本的原则,必须是先遇到问题,然后再去学相应的框架去解决这个问题,你都没遇到过这个问题,然后去学框架,你都不知道他是干啥的,学会是不可能的,反而会觉得框架特别繁琐,没效率.
8 ​1 条评论
​分享
​收藏 ​感谢
4 人赞同了该回答
&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这些高级特性可以帮你更好地管理对象。

4 ​3 条评论
​分享
​收藏 ​感谢
4 人赞同了该回答
初学Java没有用过SSH框架,用的最多的是SSM框架,即spring,springMVC,mybatis,现在用的较多的还是这三大框架,用起来比较的简单,也很方便,我感觉用框架就是知道怎么用就行了,
最主要的是要理解使用框架的核心思想,就是要将业务逻辑和数据进行分离,提高程序的可读性和维护性,就是因为以前的方法没法保证程序的健壮性,所以框架的出现就是为了解决这一问题的,其他的我不觉得他比传统的编程好到了哪儿,要说好倒是有点儿就是以前我们做的一些觉得很繁琐的事,现在不需要我们自己来做了,全都由框架来做了,其他的我就不知道了,如果有人有更好的见解还望分享一下
4 ​1 条评论
​分享
​收藏 ​感谢
3 人赞同了该回答
去某个餐厅吃饭,服务员回给你一个菜单,然后你在菜单上勾选要吃的饭菜,填好之后把单子给服务员,然后服务员把单子给后厨,后厨里面有摘菜的,有厨师,还有很多买来的菜,厨师把摘菜阿姨阿姨的菜做成一道完整的菜,然后服务员把菜端给你,你就开吃了
3 ​添加评论
​分享
​收藏 ​感谢
2 人赞同了该回答
SSH是mvc的经典诠释,用这个锻炼mvc的思维模式,但现在公司用很少了 基本都是spring mvc 不过先掌握SSH再接触spring mvc和mybatis那些会相对容易些
2 ​添加评论
​分享
​收藏 ​感谢
2 人赞同了该回答
我到现在都是比较的迷茫!框架到底该如何学习才能理解更加深入!每出现一个新的框架,都是一堆的配置,然后开始与spring进行整合!
2 ​添加评论
​分享
​收藏 ​感谢
1 人赞同了该回答

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

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

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

祝楼主学习顺利!
1 ​添加评论
​分享
​收藏 ​感谢
1 人赞同了该回答

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

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

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

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

欢迎讨论。
1 ​添加评论
​分享
​收藏 ​感谢
1 人赞同了该回答
我是先学的ssm,后来学了ssh后感觉各有各的优缺点,也不是你所说的Struts2被springMVC取代,而且hibernate的功能很强大的,Mybatis相对来说能够更加简化开发,并没有得到取代的作用
1 ​5 条评论
​分享
​收藏 ​感谢
1 人赞同了该回答

赶紧改行

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

说明你还不适合加入这一行
1 ​添加评论
微信二维码 ​分享
​收藏 ​感谢
ssh现在也就剩下Spring了,struts2基本没人用了,大多都被SpringMvc替代了,hibernate也很大程度被myBatis替代了。
0 ​添加评论
​分享
​收藏 ​感谢

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

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

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

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

0 ​添加评论
​分享
​收藏 ​感谢

我们知道,传统的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的持久层提升到了业务层,使用更加方便和强大。

0 ​添加评论
​分享
​收藏 ​感谢 收起

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

0 ​1 条评论
​分享
​收藏 ​感谢
用纯java代码配置对初学者还是比较有帮助的。
0 ​添加评论
​分享
​收藏 ​感谢

个人浅见:

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

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

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

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

WEB开发那些事儿

0 ​1 条评论
​分享
​收藏 ​感谢

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

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

spring的话现在在学源码。

  • 5
    点赞
  • 2
    评论
  • 4
    收藏
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值