精华内容
下载资源
问答
  • 前后端分离已成为互联网项目开发的业界标准使用方式,通过nginx+tomcat的方式(也可以中间加一个nodejs)有效的进行解耦, 并且前后端分离以后的大型分布式架构、弹性计算架构、微服务架构、多端化服务(多种...

    前言

     
    前后端分离已成为互联网项目开发的业界标准使用方式,通过nginx+tomcat的方式(也可以中间加一个nodejs)有效的进行解耦,
    并且前后端分离会为以后的大型分布式架构、弹性计算架构、微服务架构、多端化服务(多种客户端,例如:浏览器,车载终端,安卓,IOS等等)打下坚实的基础。
    这个步骤是系统架构从猿进化成人的必经之路。
     
    核心思想是前端html页面通过ajax调用后端的restuful api接口并使用json数据进行交互。
     
    名词解释:
    在互联网架构中,
    web服务器:一般指像nginx,apache这类的服务器,他们一般只能解析静态资源。
    应用服务器:一般指像tomcat,jetty,resin这类的服务器可以解析动态资源也可以解析静态资源,但解析静态资源的能力没有web服务器好。
     
    一般都是只有web服务器才能被外网访问,应用服务器只能内网访问。

    术业有专攻(开发人员分离)

     
    以前的JavaWeb项目大多数都是java程序员又当爹又当妈,又搞前端(ajax/jquery/js/html/css等等),又搞后端(java/mysql/oracle等等)。
     
    随着时代的发展,渐渐的许多大中小公司开始把前后端的界限分的越来越明确,前端工程师只管前端的事情,后端工程师只管后端的事情。
    正所谓术业有专攻,一个人如果什么都会,那么他毕竟什么都不精。
     
    大中型公司需要专业人才,小公司需要全才,但是对于个人职业发展来说,我建议是分开。
     
    对于后端java工程师:
    把精力放在java基础,设计模式,jvm原理,spring+springmvc原理及源码,linux,mysql事务隔离与锁机制,mongodb,http/tcp,多线程,分布式架构(dubbo,dubbox,spring cloud),弹性计算架构,微服务架构(springboot+zookeeper+docker+jenkins),java性能优化,以及相关的项目管理等等。
    后端追求的是:三高(高并发,高可用,高性能),安全,存储,业务等等。
     
    对于前端工程师:
    把精力放在html5,css3,jquery,angularjs,bootstrap,reactjs,vuejs,webpack,less/sass,gulp,nodejs,Google V8引擎,javascript多线程,模块化,面向切面编程,设计模式,浏览器兼容性,性能优化等等。
    前端追求的是:页面表现,速度流畅,兼容性,用户体验等等。
     
    杨明翰原创文章,禁止转载,版权必究。
     
    术业有专攻,这样你的核心竞争力才会越来越高,正所谓你往生活中投入什么,生活就会反馈给你什么。
    并且两端的发展都越来越高深,你想什么都会,那你毕竟什么都不精。
     
    通过将team分成前后端team,让两边的工程师更加专注各自的领域,独立治理,然后构建出一个全栈式的精益求精的team。

    原始人时代(各种耦合)

     
    几曾何时,我们的JavaWeb项目都是使用了若干后台框架,springmvc/struts + spring + spring jdbc/hibernate/mybatis 等等。
     
    大多数项目在java后端都是分了三层,控制层(controller/action),业务层(service/manage),持久层(dao)。
    控制层负责接收参数,调用相关业务层,封装数据,以及路由&渲染到jsp页面。
    然后jsp页面上使用各种标签(jstl/el/struts标签等)或者手写java表达式(<%=%>)将后台的数据展现出来,玩的是MVC那套思路。
     
    我们先看这种情况:需求定完了,代码写完了,测试测完了,然后呢?要发布了吧?
    你需要用maven或者eclipse等工具把你的代码打成一个war包,然后把这个war包发布到你的生产环境下的web容器(tomcat/jboss/weblogic/websphere/jetty/resin)里,对吧?
     
    发布完了之后,你要启动你的web容器,开始提供服务,这时候你通过配置域名,dns等等相关,你的网站就可以访问了(假设你是个网站)。
    那我们来看,你的前后端代码是不是全都在那个war包里?包括你的js,css,图片,各种第三方的库,对吧?
     
    好,下面在浏览器中输入你的网站域名(www.xxx.com),之后发生了什么?(这个问题也是很多公司的面试题)
    我捡干的说了啊,基础不好的童鞋请自己去搜。
     
    浏览器在通过域名通过dns服务器找到你的服务器外网ip,将http请求发送到你的服务器,在tcp3次握手之后(http下面是tcp/ip),通过tcp协议开始传输数据,你的服务器得到请求后,开始提供服务,接收参数,之后返回你的应答给浏览器,浏览器再通过content-type来解析你返回的内容,呈现给用户。
     
    那么我们来看,我们先假设你的首页中有100张图片,此时,用户的看似一次http请求,其实并不是一次,用户在第一次访问的时候,浏览器中不会有缓存,你的100张图片,浏览器要连着请求100次http请求(有人会跟我说http长连短连的问题,不在这里讨论),你的服务器接收这些请求,都需要耗费内存去创建socket来玩tcp传输(消耗你服务器上的计算资源)。
     
    杨明翰原创文章,禁止转载,版权必究。
     
    重点来了,这样的话,你的服务器的压力会非常大,因为页面中的所有请求都是只请求到你这台服务器上,如果1个人还好,如果10000个人并发访问呢(先不聊服务器集群,这里就说是单实例服务器),那你的服务器能扛住多少个tcp连接?你的带宽有多大?你的服务器的内存有多大?你的硬盘是高性能的吗?你能抗住多少IO?你给web服务器分的内存有多大?会不会宕机?
     
    这就是为什么,越是大中型的web应用,他们越是要解耦。
    理论上你可以把你的数据库+应用服务+消息队列+缓存+用户上传的文件+日志+等等都扔在一台服务器上,你也不用玩什么服务治理,也不用做什么性能监控,什么报警机制等等,就乱成一锅粥好了。
    但是这样就好像是你把鸡蛋都放在一个篮子里,隐患非常大。如果因为一个子应用的内存不稳定导致整个服务器内存溢出而hung住,那你的整个网站就挂掉了。
     
    如果出意外挂掉,而恰好这时你们的业务又处于井喷式发展高峰期,那么恭喜你,业务成功被技术卡住,很可能会流失大量用户,后果不堪设想。
    注意:技术一定是要走在业务前面的,否则你将错过最佳的发展期哟,亲~
     
    此外,你的应用全部都耦合在一起,相当于一个巨石,当服务端负载能力不足时,一般会使用负载均衡的方式,将服务器做成集群,这样其实你是在水平扩展一块块巨石,性能加速度会越来越低,
    要知道,本身负载就低的功能or模块是没有必要水平扩展的,在本文中的例子就是你的性能瓶颈不在前端,那干嘛要水平扩展前端呢???
    还有发版部署上线的时候,我明明只改了后端的代码,为什么要前端也跟着发布呢???
    (引用:《架构探险-轻量级微服务架构》,黄勇)
     
    正常的互联网架构,是都要拆开的,你的web服务器集群,你的应用服务器集群+文件服务器集群+数据库服务器集群+消息队列集群+缓存集群等等。

    JSP的痛点

     
    以前的javaWeb项目大多数使用jsp作为页面层展示数据给用户,因为流量不高,因此也没有那么苛刻的性能要求,但现在是大数据时代,对于互联网项目的性能要求是越来越高,
    因此原始的前后端耦合在一起的架构模式已经逐渐不能满足我们,因此我们需要需找一种解耦的方式,来大幅度提升我们的负载能力。
     
    1.动态资源和静态资源全部耦合在一起,服务器压力大,因为服务器会收到各种http请求,例如css的http请求,js的,图片的等等。
    一旦服务器出现状况,前后台一起玩完,用户体验极差。
     
    2.UI出好设计图后,前端工程师只负责将设计图切成html,需要由java工程师来将html套成jsp页面,出错率较高(因为页面中经常会出现大量的js代码),
    修改问题时需要双方协同开发,效率低下。
     
    3.jsp必须要在支持java的web服务器里运行(例如tomcat,jetty,resin等),无法使用nginx等(nginx据说单实例http并发高达5w,这个优势要用上),
    性能提不上来。
     
    4.第一次请求jsp,必须要在web服务器中编译成servlet,第一次运行会较慢。
     
    5.每次请求jsp都是访问servlet再用输出流输出的html页面,效率没有直接使用html高(是每次哟,亲~)。
     
    6.jsp内有较多标签和表达式,前端工程师在修改页面时会捉襟见肘,遇到很多痛点。
     
    7.如果jsp中的内容很多,页面响应会很慢,因为是同步加载。
     
    8.需要前端工程师使用java的ide(例如eclipse),以及需要配置各种后端的开发环境,你们有考虑过前端工程师的感受吗。
     
    基于上述的一些痛点,我们应该把整个项目的开发权重往前移,实现前后端真正的解耦!
    杨明翰原创文章,禁止转载,版权必究。

    开发模式

     
    以前老的方式是:
    1.产品经历/领导/客户提出需求
    2.UI做出设计图
    3.前端工程师做html页面
    4.后端工程师将html页面套成jsp页面(前后端强依赖,后端必须要等前端的html做好才能套jsp。如果html发生变更,就更痛了,开发效率低
    5.集成出现问题
    6.前端返工
    7.后端返工
    8.二次集成
    9.集成成功
    10.交付
     
     
     
    新的方式是:
    1.产品经历/领导/客户提出需求
    2.UI做出设计图
    3.前后端约定接口&数据&参数
    4.前后端并行开发(无强依赖,可前后端并行开发,如果需求变更,只要接口&参数不变,就不用两边都修改代码,开发效率高
    5.前后端集成
    6.前端页面调整
    7.集成成功
    8.交付
     
     

    请求方式

     
    以前老的方式是:
    1.客户端请求
    2.服务端的servlet或controller接收请求(后端控制路由与渲染页面,整个项目开发的权重大部分在后端
    3.调用service,dao代码完成业务逻辑
    4.返回jsp
    5.jsp展现一些动态的代码
     
     
     
    新的方式是:
    1.浏览器发送请求
    2.直接到达html页面(前端控制路由与渲染页面,整个项目开发的权重前移
    3.html页面负责调用服务端接口产生数据(通过ajax等等,后台返回json格式数据,json数据格式因为简洁高效而取代xml)
    4.填充html,展现动态效果,在页面上进行解析并操作DOM。
    (有兴趣的童鞋可以访问一下阿里巴巴等大型网站,然后按一下F12,监控一下你刷新一次页面,他的http是怎么玩的,大多数都是单独请求后台数据,
    使用json传输数据,而不是一个大而全的http请求把整个页面包括动+静全部返回过来)
     
    杨明翰原创文章,禁止转载,版权必究。
    总结一下新的方式的请求步骤:
    大量并发浏览器请求--->web服务器集群(nginx)--->应用服务器集群(tomcat)--->文件/数据库/缓存/消息队列服务器集群
    同时又可以玩分模块,还可以按业务拆成一个个的小集群,为后面的架构升级做准备。
     

    前后分离的优势

     
    1.可以实现真正的前后端解耦,前端服务器使用nginx。
    前端/WEB服务器放的是css,js,图片等等一系列静态资源(甚至你还可以css,js,图片等资源放到特定的文件服务器,例如阿里云的oss,并使用cdn加速),前端服务器负责控制页面引用&跳转&路由,前端页面异步调用后端的接口,后端/应用服务器使用tomcat(把tomcat想象成一个数据提供者),加快整体响应速度。
    (这里需要使用一些前端工程化的框架比如nodejs,react,router,react,redux,webpack)
     
    2.发现bug,可以快速定位是谁的问题,不会出现互相踢皮球的现象。
    页面逻辑,跳转错误,浏览器兼容性问题,脚本错误,页面样式等问题,全部由前端工程师来负责。
    接口数据出错,数据没有提交成功,应答超时等问题,全部由后端工程师来解决。
    双方互不干扰,前端与后端是相亲相爱的一家人。
     
    3.在大并发情况下,我可以同时水平扩展前后端服务器,比如淘宝的一个首页就需要2000+台前端服务器做集群来抗住日均多少亿+的日均pv。
    (去参加阿里的技术峰会,听他们说他们的web容器都是自己写的,就算他单实例抗10万http并发,2000台是2亿http并发,并且他们还可以根据预知洪峰来无限拓展,很恐怖,就一个首页。。。)
     
    4.减少后端服务器的并发/负载压力
    除了接口以外的其他所有http请求全部转移到前端nginx上,接口的请求调用tomcat,参考nginx反向代理tomcat。
    且除了第一次页面请求外,浏览器会大量调用本地缓存。
     
    5.即使后端服务暂时超时或者宕机了,前端页面也会正常访问,只不过数据刷不出来而已。
     
    6.也许你也需要有微信相关的轻应用,那样你的接口完全可以共用,如果也有app相关的服务,
    那么只要通过一些代码重构,也可以大量复用接口,提升效率。(多端应用)
     
    7.页面显示的东西再多也不怕,因为是异步加载。
     
    8.nginx支持页面热部署,不用重启服务器,前端升级更无缝。
     
    9.增加代码的维护性&易读性(前后端耦在一起的代码读起来相当费劲)。
     
    10.提升开发效率,因为可以前后端并行开发,而不是像以前的强依赖。
     
    11.在nginx中部署证书,外网使用https访问,并且只开放443和80端口,其他端口一律关闭(防止黑客端口扫描),
    内网使用http,性能和安全都有保障。
     
    12.前端大量的组件代码得以复用,组件化,提升开发效率,抽出来!

    注意事项

     
    1.在开需求会议的时候,前后端工程师必须全部参加,并且需要制定好接口文档,后端工程师要写好测试用例(2个维度),不要让前端工程师充当你的专职测试,
    推荐使用chrome的插件postman或soapui或jmeter,service层的测试用例拿junit写。ps:前端也可以玩单元测试吗?
     
    2.上述的接口并不是java里的interface,说白了调用接口就是调用你controler里的方法。
     
    3.加重了前端团队的工作量,减轻了后端团队的工作量,提高了性能和可扩展性。
     
    4.我们需要一些前端的框架来解决类似于页面嵌套,分页,页面跳转控制等功能。(上面提到的那些前端框架)。
     
    5.如果你的项目很小,或者是一个单纯的内网项目,那你大可放心,不用任何架构而言,但是如果你的项目是外网项目,呵呵哒。
     
    6.以前还有人在使用类似于velocity/freemarker等模板框架来生成静态页面,仁者见仁智者见智。
     
    7.这篇文章主要的目的是说jsp在大型外网java web项目中被淘汰掉,可没说jsp可以完全不学,对于一些学生朋友来说,jsp/servlet等相关的java web基础还是要掌握牢的,不然你以为springmvc这种框架是基于什么来写的?
     
    8.如果页面上有一些权限等等相关的校验,那么这些相关的数据也可以通过ajax从接口里拿。
     
    9.对于既可以前端做也可以后端做的逻辑,我建议是放到前端,为什么?
    因为你的逻辑需要计算资源进行计算,如果放到后端去run逻辑,则会消耗带宽&内存&cpu等等计算资源,你要记住一点就是
    服务端的计算资源是有限的,而如果放到前端,使用的是客户端的计算资源,这样你的服务端负载就会下降(高并发场景)。
    类似于数据校验这种,前后端都需要做!
     
    10.前端需要有机制应对后端请求超时以及后端服务宕机的情况,友好的展示给用户。
     

    扩展阅读

     
    1.其实对于js,css,图片这类的静态资源可以考虑放到类似于阿里云的oss这类文件服务器上(如果是普通的服务器&操作系统,存储在到达pb级的文件后,或者单个文件夹内的文件数量达到3-5万,
    io会有很严重的性能问题),
    再在oss上配cdn(全国子节点加速),这样你页面打开的速度像飞一样, 无论你在全国的哪个地方,并且你的nginx的负载会进一步降低。
     
    2.如果你要玩轻量级微服务架构,要使用nodejs做网关,用nodejs的好处还有利于seo优化,因为nginx只是向浏览器返回页面静态资源,而国内的搜索引擎爬虫只会抓取静态数据,不会解析页面中的js,
    这使得应用得不到良好的搜索引擎支持。同时因为nginx不会进行页面的组装渲染,需要把静态页面返回到浏览器,然后完成渲染工作,这加重了浏览器的渲染负担。
    浏览器发起的请求经过nginx进行分发,URL请求统一分发到nodejs,在nodejs中进行页面组装渲染;API请求则直接发送到后端服务器,完成响应。
     
    3.如果遇到跨域问题,spring4的CORS可以完美解决,但一般使用nginx反向代理都不会有跨域问题,除非你把前端服务和后端服务分成两个域名。
    JSONP的方式也被淘汰掉了。
     
    4.如果想玩多端应用,注意要去掉tomcat原生的session机制,要使用token机制,使用缓存(因为是分布式系统),做单点,对于token机制的安全性问题,可以搜一下jwt。
     
    5.前端项目中可以加入mock测试(构造虚拟测试对象来模拟后端,可以独立开发和测试),后端需要有详细的测试用例,保证服务的可用性与稳定性。

    总结

     
    前后端分离并非仅仅只是一种开发模式,而是一种架构模式(前后端分离架构)。
    千万不要以为只有在撸代码的时候把前端和后端分开就是前后端分离了。需要区分前后端项目
    前端项目与后端项目是两个项目,放在两个不同的服务器,需要独立部署,两个不同的工程,两个不同的代码库,不同的开发人员
    前后端工程师需要约定交互接口,实现并行开发,开发结束后需要进行独立部署,前端通过ajax来调用http请求调用后端的restful api。
    前端只需要关注页面的样式与动态数据的解析&渲染,而后端专注于具体业务逻辑。
     
    原创文章,禁止转载。
    展开全文
  • 随着互联网的高速发展以及IT开发技术的升级,前后端分离已成为...为什么前后端分离?把前端与后端独立起来去开发,放在两个不同的服务器,需要独立部署。两个不同的工程,两个不同的代码库,不同的开发人员,...

    随着互联网的高速发展以及IT开发技术的升级,前后端分离已成为互联网项目开发的业界标准使用方式。在实际工作中,前后端的接口联调对接工作量占HTML5大前端人员日常工作的30%-50%,甚至会更高。接下来千锋小编分享的广州HTML5大前端学习就给大家讲解前后端分离接口。

    为什么要前后端分离?

    把前端与后端独立起来去开发,放在两个不同的服务器,需要独立部署。两个不同的工程,两个不同的代码库,不同的开发人员,前后端工程师需要约定交互接口,实现同步开发。开发结束后需要进行独立部署,前端通过接口来调用调用后端的API,前端只需要关注页面的样式与动态数据的解析和渲染,而后端专注于具体业务逻辑。

    89555eb67eab299d7492faecdbdf185a.png

    前后端分离的优点是什么?

    1、彻底解放前端。前端不再需要向后台提供模板或是后台在前端HTML中嵌入后台代。

    2、提高工作效率,分工更加明确。前端只关注前端的事,后台只关心后台的活,两者开发可以同时进行,在后台还没有时间提供接口的时候,前端可以先将数据写死或者调用本地的JSON文件即可,页面的增加和路由的修改也不必再去麻烦后台,开发更加灵活。

    3、局部性能提升。通过前端路由的配置,我们可以实现页面的按需加载,无需一开始加载首页便加载网站的所有的资源,服务器也不再需要解析前端页面,在页面交互及用户体验上有所提升。

    c9be0bf982efdadcfe4d898228f0f474.png

    4、降低维护成本。通过目前主流的前端MVC框架,我们可以非常快速的定位及发现问题的所在,客户端的问题不再需要后台人员参与及调试,代码重构及可维护性增强。

    5、实现高内聚低耦合,减少后端(应用)服务器的并发/负载压力。

    6、即使后端服务暂时超时或者宕机了,前端页面也会正常访问,但无法提供数据。

    7、可以使后台能更好的追求高并发、高可用、高性能,使前端能更好的追求页面表现、速度流畅、兼容性、用户体验等。

    前端工程是如何调用接口?

    Ajax在浏览器与Web服务器之间使用异步数据传输(HTTP 请求),通过get或者post方法与服务器交互。

    前端和后端之所以需要对接,是因为前端页面只负责提供视图没有内容,而后端只提供内容,两者所谓的对接,就是把后端的内容放在前端页面预留出来的位置上。(虽然说是前端后端 ,但这一对接实际发生在服务器端)。

    0780f37e9337082ec201e39760806e50.png

    所以服务器端进行的交互活动如下:

    接收用户请求——》找到负责处理的程序——》处理程序找到要传输给用户的前端页面——》该前端页面留出位置——》后端到数据库取数据——》后端把数据放在前端留出来的位置上

    ——》结合成真正用户看到的HTML文件——》传输给用户。

    展开全文
  • 随着互联网的高速发展以及IT开发技术的升级,前后端分离已成为...为什么前后端分离?把前端与后端独立起来去开发,放在两个不同的服务器,需要独立部署。两个不同的工程,两个不同的代码库,不同的开发人员,...

    随着互联网的高速发展以及IT开发技术的升级,前后端分离已成为互联网项目开发的业界标准使用方式。在实际工作中,前后端的接口联调对接工作量占HTML5大前端人员日常工作的30%-50%,甚至会更高。接下来千锋小编分享的广州HTML5大前端学习就给大家讲解前后端分离接口。

    为什么要前后端分离?

    把前端与后端独立起来去开发,放在两个不同的服务器,需要独立部署。两个不同的工程,两个不同的代码库,不同的开发人员,前后端工程师需要约定交互接口,实现同步开发。开发结束后需要进行独立部署,前端通过接口来调用调用后端的API,前端只需要关注页面的样式与动态数据的解析和渲染,而后端专注于具体业务逻辑。

    19bdcb7273f417b1504053febea3cd74.png

    前后端分离的优点是什么?

    1、彻底解放前端。前端不再需要向后台提供模板或是后台在前端HTML中嵌入后台代。

    2、提高工作效率,分工更加明确。前端只关注前端的事,后台只关心后台的活,两者开发可以同时进行,在后台还没有时间提供接口的时候,前端可以先将数据写死或者调用本地的JSON文件即可,页面的增加和路由的修改也不必再去麻烦后台,开发更加灵活。

    3、局部性能提升。通过前端路由的配置,我们可以实现页面的按需加载,无需一开始加载首页便加载网站的所有的资源,服务器也不再需要解析前端页面,在页面交互及用户体验上有所提升。

    13cdff2c297d026d279950e2da49410d.png

    4、降低维护成本。通过目前主流的前端MVC框架,我们可以非常快速的定位及发现问题的所在,客户端的问题不再需要后台人员参与及调试,代码重构及可维护性增强。

    5、实现高内聚低耦合,减少后端(应用)服务器的并发/负载压力。

    6、即使后端服务暂时超时或者宕机了,前端页面也会正常访问,但无法提供数据。

    7、可以使后台能更好的追求高并发、高可用、高性能,使前端能更好的追求页面表现、速度流畅、兼容性、用户体验等。

    前端工程是如何调用接口?

    Ajax在浏览器与Web服务器之间使用异步数据传输(HTTP 请求),通过get或者post方法与服务器交互。

    前端和后端之所以需要对接,是因为前端页面只负责提供视图没有内容,而后端只提供内容,两者所谓的对接,就是把后端的内容放在前端页面预留出来的位置上。(虽然说是前端后端 ,但这一对接实际发生在服务器端)。

    3b0e7139d65801bc1355063d54568f64.png

    所以服务器端进行的交互活动如下:

    接收用户请求——》找到负责处理的程序——》处理程序找到要传输给用户的前端页面——》该前端页面留出位置——》后端到数据库取数据——》后端把数据放在前端留出来的位置上

    ——》结合成真正用户看到的HTML文件——》传输给用户。

    展开全文
  • 前后端分离已成为互联网项目开发的业界标准使用方式,通过nginx+tomcat的方式(也可以中间加一个nodejs)有效的进行解耦,并且前后端分离以后的大型分布式架构、弹性计算架构、微服务架构、多端化服务(多种...

    一、前戏

    前后端分离已成为互联网项目开发的业界标准使用方式,通过nginx+tomcat的方式(也可以中间加一个nodejs)有效的进行解耦,并且前后端分离会为以后的大型分布式架构、弹性计算架构、微服务架构、多端化服务(多种客户端,例如:浏览器,车载终端,安卓,IOS等等)打下坚实的基础。这个步骤是系统架构从猿进化成人的必经之路。

    核心思想是前端html页面通过ajax调用后端的restuful api接口并使用json数据进行交互。

    在互联网架构中,名词解释:

    Web服务器:一般指像nginx,apache这类的服务器,他们一般只能解析静态资源。

    应用服务器:一般指像tomcat,jetty,resin这类的服务器可以解析动态资源也可以解析静态资源,但解析静态资源的能力没有web服务器好。

    一般都是只有web服务器才能被外网访问,应用服务器只能内网访问。

    二、术业有专攻(开发人员分离)

    以前的JavaWeb项目大多数都是java程序员又当爹又当妈,又搞前端,又搞后端。

    随着时代的发展,渐渐的许多大中小公司开始把前后端的界限分的越来越明确,前端工程师只管前端的事情,后端工程师只管后端的事情。正所谓术业有专攻,一个人如果什么都会,那么他毕竟什么都不精。

    大中型公司需要专业人才,小公司需要全才,但是对于个人职业发展来说,我建议是分开。

    1、对于后端java工程师:

    把精力放在java基础,设计模式,jvm原理,spring+springmvc原理及源码,linux,mysql事务隔离与锁机制,mongodb,http/tcp,多线程,分布式架构,弹性计算架构,微服务架构,java性能优化,以及相关的项目管理等等。

    后端追求的是:三高(高并发,高可用,高性能),安全,存储,业务等等。

    2、对于前端工程师:

    把精力放在html5,css3,jquery,angularjs,bootstrap,reactjs,vuejs,webpack,less/sass,gulp,nodejs,Google V8引擎,javascript多线程,模块化,面向切面编程,设计模式,浏览器兼容性,性能优化等等。

    前端追求的是:页面表现,速度流畅,兼容性,用户体验等等。

    术业有专攻,这样你的核心竞争力才会越来越高,正所谓你往生活中投入什么,生活就会反馈给你什么。并且两端的发展都越来越高深,你想什么都会,那你毕竟什么都不精。

    通过将team分成前后端team,让两边的工程师更加专注各自的领域,独立治理,然后构建出一个全栈式的精益求精的team。

    三、原始人时代(各种耦合)

    几曾何时,我们的JavaWeb项目都是使用了若干后台框架,springmvc/struts + spring + spring jdbc/hibernate/mybatis 等等。

    大多数项目在java后端都是分了三层,控制层,业务层,持久层。控制层负责接收参数,调用相关业务层,封装数据,以及路由&渲染到jsp页面。然后jsp页面上使用各种标签或者手写java表达式将后台的数据展现出来,玩的是MVC那套思路。

    我们先看这种情况:需求定完了,代码写完了,测试测完了,然后呢?要发布了吧?你需要用maven或者eclipse等工具把你的代码打成一个war包,然后把这个war包发布到你的生产环境下的web容器里,对吧?

    发布完了之后,你要启动你的web容器,开始提供服务,这时候你通过配置域名,dns等等相关,你的网站就可以访问了(假设你是个网站)。那我们来看,你的前后端代码是不是全都在那个war包里?包括你的js,css,图片,各种第三方的库,对吧?

    好,下面在浏览器中输入你的网站域名(www.xxx.com),之后发生了什么?(这个问题也是很多公司的面试题)我捡干的说了啊,基础不好的童鞋请自己去搜。

    浏览器在通过域名通过dns服务器找到你的服务器外网ip,将http请求发送到你的服务器,在tcp3次握手之后(http下面是tcp/ip),通过tcp协议开始传输数据,你的服务器得到请求后,开始提供服务,接收参数,之后返回你的应答给浏览器,浏览器再通过content-type来解析你返回的内容,呈现给用户。

    那么我们来看,我们先假设你的首页中有100张图片,此时,用户的看似一次http请求,其实并不是一次,用户在第一次访问的时候,浏览器中不会有缓存,你的100张图片,浏览器要连着请求100次http请求(有人会跟我说http长连短连的问题,不在这里讨论),你的服务器接收这些请求,都需要耗费内存去创建socket来玩tcp传输(消耗你服务器上的计四、JSP的痛点

    以前的javaWeb项目大多数使用jsp作为页面层展示数据给用户,因为流量不高,因此也没有那么苛刻的性能要求,但现在是大数据时代,对于互联网项目的性能要求是越来越高,因此原始的前后端耦合在一起的架构模式已经逐渐不能满足我们,因此我们需要需找一种解耦的方式,来大幅度提升我们的负载能力。

    1、动态资源和静态资源全部耦合在一起,服务器压力大,因为服务器会收到各种http请求,例如css的http请求,js的,图片的等等。一旦服务器出现状况,前后台一起玩完,用户体验极差。

    2、UI出好设计图后,前端工程师只负责将设计图切成html,需要由java工程师来将html套成jsp页面,出错率较高(因为页面中经常会出现大量的js代码),修改问题时需要双方协同开发,效率低下。

    3、jsp必须要在支持java的web服务器里运行(例如tomcat,jetty,resin等),无法使用nginx等(nginx据说单实例http并发高达5w,这个优势要用上),性能提不上来。

    4、第一次请求jsp,必须要在web服务器中编译成servlet,第一次运行会较慢。

    5、每次请求jsp都是访问servlet再用输出流输出的html页面,效率没有直接使用html高(是每次哟,亲~)。

    6、jsp内有较多标签和表达式,前端工程师在修改页面时会捉襟见肘,遇到很多痛点。

    7、如果jsp中的内容很多,页面响应会很慢,因为是同步加载。

    8、需要前端工程师使用java的ide(例如eclipse),以及需要配置各种后端的开发环境,你们有考虑过前端工程师的感受吗。

    基于上述的一些痛点,我们应该把整个项目的开发权重往前移,实现前后端真正的解耦!

    五、开发模式

    以前老的方式是:

    1、产品经历/领导/客户提出需求

    2、UI做出设计图

    3、前端工程师做html页面

    4、后端工程师将html页面套成jsp页面(前后端强依赖,后端必须要等前端的html做好才能套jsp。如果html发生变更,就更痛了,开发效率低)

    5、集成出现问题

    6、前端返工

    7、后端返工

    8、二次集成

    9、集成成功

    10、交付

    新的方式是:

    1、产品经历/领导/客户提出需求

    2、UI做出设计图

    3、前后端约定接口&数据&参数

    4、前后端并行开发(无强依赖,可前后端并行开发,如果需求变求变更,只要接口&参数不变,就不用两边都修改代码,开发效率高)

    5、前后端集成

    6、前端页面调整

    7、集成成功

    8、交付

    六、请求方式

    以前老的方式是:

    1、客户端请求

    2、服务端的servlet或controller接收请求(后端控制路由与渲染页面,整个项目开发的权重大部分在后端)

    3、调用service,dao代码完成业务逻辑

    4、返回jsp

    5、jsp展现一些动态的代码

    新的方式是:

    1、浏览器发送请求

    2、直接到达html页面(前端控制路由与渲染页面,整个项目开发的权重前移)

    3、html页面负责调用服务端接口产生数据(通过ajax等等,后台返回json格式数据,json数据格式因为简洁高效而取代xml)

    4、填充html,展现动态效果,在页面上进行解析并操作DOM。

    总结一下新的方式的请求步骤:

    大量并发浏览器请求—>web服务器集群(nginx)—>应用服务器集群(tomcat)—>文件/数据库/缓存/消息队列服务器集群

    同时又可以玩分模块,还可以按业务拆成一个个的小集群,为后面的架构升级做准备。

    七、前后分离的优势

    1、可以实现真正的前后端解耦,前端服务器使用nginx。前端/WEB服务器放的是css,js,图片等等一系列静态资源(甚至你还可以css,js,图片等资源放到特定的文件服务器,例如阿里云的oss,并使用cdn加速),前端服务器负责控制页面引用&跳转&路由,前端页面异步调用后端的接口,后端/应用服务器使用tomcat(把tomcat想象成一个数据提供者),加快整体响应速度。(这里需要使用一些前端工程化的框架比如nodejs,react,router,react,redux,webpack)

    2、发现bug,可以快速定位是谁的问题,不会出现互相踢皮球的现象。页面逻辑,跳转错误,浏览器兼容性问题,脚本错误,页面样式等问题,全部由前端工程师来负责。接口数据出错,数据没有提交成功,应答超时等问题,全部由后端工程师来解决。双方互不干扰,前端与后端是相亲相爱的一家人。

    3、在大并发情况下,我可以同时水平扩展前后端服务器,比如淘宝的一个首页就需要2000+台前端服务器做集群来抗住日均多少亿+的日均pv。(去参加阿里的技术峰会,听他们说他们的web容器都是自己写的,就算他单实例抗10万http并发,2000台是2亿http并发,并且他们还可以根据预知洪峰来无限拓展,很恐怖,就一个首页。。。)

    4、减少后端服务器的并发/负载压力。除了接口以外的其他所有http请求全部转移到前端nginx上,接口的请求调用tomcat,参考nginx反向代理tomcat。且除了第一次页面请求外,浏览器会大量调用本地缓存。

    5、即使后端服务暂时超时或者宕机了,前端页面也会正常访问,只不过数据刷不出来而已。

    6、也许你也需要有微信相关的轻应用,那样你的接口完全可以共用,如果也有app相关的服务,那么只要通过一些代码重构,也可以大量复用接口,提升效率。(多端应用)

    7、页面显示的东西再多也不怕,因为是异步加载。

    8、nginx支持页面热部署,不用重启服务器,前端升级更无缝。

    9、增加代码的维护性&易读性(前后端耦在一起的代码读起来相当费劲)。

    10、提升开发效率,因为可以前后端并行开发,而不是像以前的强依赖。

    11、在nginx中部署证书,外网使用https访问,并且只开放443和80端口,其他端口一律关闭(防止黑客端口扫描),内网使用http,性能和安全都有保障。

    12、前端大量的组件代码得以复用,组件化,提升开发效率,抽出来!

    八、注意事项

    1、在开需求会议的时候,前后端工程师必须全部参加,并且需要制定好接口文档,后端工程师要写好测试用例(2个维度),不要让前端工程师充当你的专职测试,推荐使用chrome的插件postman或soapui或jmeter,service层的测试用例拿junit写。ps:前端也可以玩单元测试吗?

    2、上述的接口并不是java里的interface,说白了调用接口就是调用你controler里的方法。

    3、加重了前端团队的工作量,减轻了后端团队的工作量,提高了性能和可扩展性。

    4、我们需要一些前端的框架来解决类似于页面嵌套,分页,页面跳转控制等功能。(上面提到的那些前端框架)。

    5、如果你的项目很小,或者是一个单纯的内网项目,那你大可放心,不用任何架构而言,但是如果你的项目是外网项目,呵呵哒。

    6、 以前还有人在使用类似于velocity/freemarker等模板框架来生成静态页面,仁者见仁智者见智。

    7、这篇文章主要的目的是说jsp在大型外网java web项目中被淘汰掉,可没说jsp可以完全不学,对于一些学生朋友来说,jsp/servlet等相关的java web基础还是要掌握牢的,不然你以为springmvc这种框架是基于什么来写的?

    8、如果页面上有一些权限等等相关的校验,那么这些相关的数据也可以通过ajax从接口里拿。

    9、对于既可以前端做也可以后端做的逻辑,我建议是放到前端,为什么?因为你的逻辑需要计算资源进行计算,如果放到后端去run逻辑,则会消耗带宽&内存&cpu等等计算资源,你要记住一点就是服务端的计算资源是有限的,而如果放到前端,使用的是客户端的计算资源,这样你的服务端负载就会下降(高并发场景)。类似于数据校验这种,前后端都需要做!

    10、前端需要有机制应对后端请求超时以及后端服务宕机的情况,友好的展示给用户。

    九、扩展阅读

    1、其实对于js,css,图片这类的静态资源可以考虑放到类似于阿里云的oss这类文件服务器上(如果是普通的服务器&操作系统,存储在到达pb级的文件后,或者单个文件夹内的文件数量达到3-5万,io会有很严重的性能问题),再在oss上配cdn(全国子节点加速),这样你页面打开的速度像飞一样, 无论你在全国的哪个地方,并且你的nginx的负载会进一步降低。

    2、如果你要玩轻量级微服务架构,要使用nodejs做网关,用nodejs的好处还有利于seo优化,因为nginx只是向浏览器返回页面静态资源,而国内的搜索引擎爬虫只会抓取静态数据,不会解析页面中的js,这使得应用得不到良好的搜索引擎支持。同时因为nginx不会进行页面的组装渲染,需要把静态页面返回到浏览器,然后完成渲染工作,这加重了浏览器的渲染负担。浏览器发起的请求经过nginx进行分发,URL请求统一分发到nodejs,在nodejs中进行页面组装渲染;API请求则直接发送到后端服务器,完成响应。

    3、如果遇到跨域问题,spring4的CORS可以完美解决,但一般使用nginx反向代理都不会有跨域问题,除非你把前端服务和后端服务分成两个域名。JSONP的方式也被淘汰掉了。4、如果想玩多端应用,注意要去掉tomcat原生的session机制,要使用token机制,使用缓存(因为是分布式系统),做单点,对于token机制的安全性问题,可以搜一下jwt。

    5、前端项目中可以加入mock测试(构造虚拟测试对象来模拟后端,可以独立开发和测试),后端需要有详细的测试用例,保证服务的可用性与稳定性。

    十、总结

    前后端分离并非仅仅只是一种开发模式,而是一种架构模式(前后端分离架构)。千万不要以为只有在撸代码的时候把前端和后端分开就是前后端分离了,需要区分前后端项目。前端项目与后端项目是两个项目,放在两个不同的服务器,需要独立部署,两个不同的工程,两个不同的代码库,不同的开发人员。前后端工程师需要约定交互接口,实现并行开发,开发结束后需要进行独立部署,前端通过ajax来调用http请求调用后端的restful api。前端只需要关注页面的样式与动态数据的解析&渲染,而后端专注于具体业务逻辑。

    4、如果想玩多端应用,注意要去掉tomcat原生的session机制,要使用token机制,使用缓存(因为是分布式系统),做单点,对于token机制的安全性问题,可以搜一下jwt。

    展开全文
  • 为什么使用前后端分离? 答:前后端分离就是前端不用管后端,后端不用管前端,前后端共用一套标准来交互。前端产生的Bug不用影响到后端程序,后端产生的Bug不会影响前端程序。
  • 随着互联网的高速发展以及IT开发技术的升级,前后端分离已成为...为什么前后端分离?把前端与后端独立起来去开发,放在两个不同的服务器,需要独立部署。两个不同的工程,两个不同的代码库,不同的开发人员,...
  • 为什么前后端分离? 把前端与后端独立起来去开发,放在两个不同的服务器,需要独立部署。两个不同的工程,两个不同的代码库,不同的开发人员,前后端工程师需要约定交互接口,实现同步开发。开发结束后需要进行...
  • 前后端分离 在传统的做法里,都会在后台运行Java代码,然后在后台生成html,通过http协议传送到客户端。 这样做的问题是: 在后台运行的时候,如果信息量过大,大多数通过查询数据库,那么生成html的速度就十分...
  • 前后端分离以及token的使用为什么使用前后端分离:首先说一下jsp的工作原理:jsp实际上也是是一个继承自Servlet接口的java类,实际上它就是一个Servlet,JSP的页面渲染是在后端完成的,经过tomcat的处理后,把jsp...
  • 为什么前后端分离?

    2020-09-18 11:47:15
    如果不使用前后端分离的方式,会有哪些问题? 传统的java Web开发中,前端使用的是jsp开发,jsp不是由后端开发者来独立完成的。 前端–》HTML静态页面–》后端–》jsp 这种开发方式效率极低,可以使用前后端分离的...
  • 为什么前后端分离? 作者:偏头痛杨来源:https://blog.csdn.net/piantoutongyang一、前戏前后端分离已成为互联网项目开发的业界标准使用方式,通过nginx+tomcat的方式(也可以中间加一个nodejs)有效的进行...
  • 为什么前后端分离?各有什么优缺点?

    万次阅读 多人点赞 2018-06-15 20:27:10
    前后端分离已成为互联网项目开发的业界标准使用方式,通过nginx+tomcat的方式(也可以中间加一个nodejs)有效的进行解耦,并且前后端分离以后的大型分布式架构、弹性计算架构、微服务架构、多端化服务(多种...
  • 为什么前后端分离?各有什么优缺点? 2018年06月15日 20:27:10dream_cat_forever阅读数:34356 一、前端 前后端分离已成为互联网项目开发的业界标准使用方式,通过nginx+tomcat的方式(也可以中间加一个nodejs...
  • 为什么前后端分离

    千次阅读 2017-12-28 10:49:43
    为什么前后端分离?2.0版,为分布式架构打基础。 标签: jspjavanginxjava webajax 2017-04-12 16:32 3147人阅读 评论(2) 收藏 举报  分类: Java Web(1)  前戏 前后端分离...
  • 前后端分离以及token的使用为什么使用前后端分离:首先说一下jsp的工作原理:jsp实际上也是是一个继承自Servlet接口的java类,实际上它就是一个Servlet,JSP的页面渲染是在后端完成的,经过tomcat的处理后,把jsp...
  • 为什么前后端分离

    2019-07-12 16:17:47
    前后端分离已成为互联网项目开发的业界标准使用方式,通过nginx+tomcat的方式(也可以中间加一个nodejs)有效的进行解耦,并且前后端分离以后的大型分布式架构、弹性计算架构、微服务架构、多端化服务(多种...
  • 前后端分离已成为互联网项目开发的业界标准使用方式,通过nginx+tomcat的方式(也可以中间加一个nodejs)有效的进行解耦, 并且前后端分离以后的大型分布式架构、弹性计算架构、微服务架构、多端化服务(多种...
  • 随着互联网的高速发展以及IT开发技术的升级,前后端分离已成为...为什么前后端分离?把前端与后端独立起来去开发,放在两个不同的服务器,需要独立部署。两个不同的工程,两个不同的代码库,不同的开发人员,...
  • 前言 前后端分离已成为互联网项目开发的业界标准使用方式,通过nginx+tomcat的方式(也可以中间加一个...并且前后端分离以后的大型分布式架构、弹性计算架构、微服务架构、多端化服务(多种客户端,例如:浏...
  • 前后端分离已成为互联网项目开发的业界标准使用方式,通过nginx+tomcat的方式(也可以中间加一个nodejs)有效的进行解耦,并且前后端分离以后的大型分布式架构、弹性计算架构、微服务架构、多端化服务(多种...
  • 前后端分离已成为互联网项目开发的业界标准使用方式,通过nginx+tomcat的方式(也可以中间加一个nodejs)有效的进行解耦, 并且前后端分离以后的大型分布式架构、弹性计算架构、微服务架构、多端化服务(多种...
  • 前后端分离已成为互联网项目开发的业界标准使用方式,通过nginx+tomcat的方式(也可以中间加一个nodejs)有效的进行解耦,并且前后端分离以后的大型分布式架构、弹性计算架构、微服务架构、多端化服务(多种...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 895
精华内容 358
关键字:

为什么使用前后端分离