前后端分离开发_前后端分离开发 但是没有分离部署 算前后端分离吗 - CSDN
精华内容
参与话题
  • 一、前言 ”前后端分离“已经成为互联网项目开发的业界标杆,通过Tomcat+Ngnix(也可以中间有个Node.js),有效地进行解耦。并且前后端分离会为以后的大型分布式架构、弹性计算架构、微服务架构、多端化服务(多种...

    一、前言

    ”前后端分离“已经成为互联网项目开发的业界标杆,通过Tomcat+Ngnix(也可以中间有个Node.js),有效地进行解耦。并且前后端分离会为以后的大型分布式架构、弹性计算架构、微服务架构、多端化服务(多种客户端,例如:浏览器,车载终端,安卓,IOS等等)打下坚实的基础。

    前后端分离(解耦)的核心思想是:前端Html页面通过Ajax调用后端的RestFul API并使用Json数据进行交互。

    注:

    【在互联网架构中,web服务器:一般指像nginx,apache这类的服务器,他们一般只能解析静态资源。

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

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

    二、为什么前后端分离

    一般公司后端开发人员直接兼顾前端的工作,一边实现API接口,一边开发页面,两者互相切换着做,而且根据不同的url动态拼接页面,这也导致后台的开发压力大大增加。前后端工作分配不均。不仅仅开发效率慢,而且代码难以维护。而前后端分离的话,则可以很好的解决前后端分工不均的问题,将更多的交互逻辑分配给前端来处理,而后端则可以专注于其本职工作,比如提供API接口,进行权限控制以及进行运算工作。而前端开发人员则可以利用nodejs来搭建自己的本地服务器,直接在本地开发,然后通过一些插件来将api请求转发到后台,这样就可以完全模拟线上的场景,并且与后台解耦。前端可以独立完成与用户交互的整一个过程,两者都可以同时开工,不互相依赖,开发效率更快,而且分工比较均衡。

    三、从MVC到前后端分离

    MVC 是一种经典的设计模式,全名为 Model-View-Controller,即 模型-视图-控制器

    其中,模型 是用于封装数据的载体,例如,在 Java 中一般通过一个简单的 POJO(Plain Ordinary Java Object)来表示,其本质是一个普通的 Java Bean,包含一系列的成员变量及其 getter/setter 方法。对于 视图 而言,它更加偏重于展现,也就是说,视图决定了界面到底长什么样子,在 Java 中可通过 JSP 来充当视图,或者通过纯 HTML 的方式进行展现,而后者才是目前的主流。模型和视图需要通过 控制器 来进行粘合,例如,用户发送一个 HTTP 请求,此时该请求首先会进入控制器,然后控制器去获取数据并将其封装为模型,最后将模型传递到视图中进行展现。

    综上所述,MVC 的交互过程如下图所示:

    图1 - 经典 MVC 模式

    也就是说,我们输入的是 AJAX 请求,输出的是 JSON 数据,市面上有这样的技术来实现这个功能吗?答案是 REST。

    REST 全称是 Representational State Transfer(表述性状态转移),它是 Roy Fielding 博士在 2000 年写的一篇关于软件架构风格的论文,此文一出,威震四方!国内外许多知名互联网公司纷纷开始采用这种轻量级的 Web 服务,大家习惯将其称为 RESTful Web Services,或简称 REST 服务。

    如果将浏览器这一端视为前端,而服务器那一端视为后端的话,可以将以上改进后的 MVC 模式简化为以下前后端分离模式:

    图3 - 前后端分离

    可见,有了 REST 服务,前端关注界面展现,后端关注业务逻辑,分工明确,职责清晰。

    四、认识Rest架构

    REST 本质上是使用 URL 来访问资源种方式。众所周知,URL 就是我们平常使用的请求地址了,其中包括两部分:请求方式请求路径,比较常见的请求方式是 GET 与 POST,但在 REST 中又提出了几种其它类型的请求方式,汇总起来有六种:GET、POST、PUT、DELETE、HEAD、OPTIONS。尤其是前四种,正好与CRUD(Create-Retrieve-Update-Delete,增删改查)四种操作相对应,例如,GET(查)、POST(增)、PUT(改)、DELETE(删),这正是 REST 与 CRUD 的异曲同工之妙!需要强调的是,REST 是“面向资源”的,这里提到的资源,实际上就是我们常说的领域对象,在系统设计过程中,我们经常通过领域对象来进行数据建模。

    REST 是一个“无状态”的架构模式,因为在任何时候都可以由客户端发出请求到服务端,最终返回自己想要的数据,当前请求不会受到上次请求的影响。也就是说,服务端将内部资源发布 REST 服务,客户端通过 URL 来访问这些资源,这不就是 SOA 所提倡的“面向服务”的思想吗?所以,REST 也被人们看做是一种“轻量级”的 SOA 实现技术,因此在企业级应用与互联网应用中都得到了广泛应用。

    下面我们举几个例子对 REST 请求进行简单描述:

    REST 请求描述
    GET:/advertisers获取所有的广告主
    GET:/advertiser/1获取 ID 为 1 的广告主
    PUT:/advertiser/1更新 ID 为 1 的广告主
    DELETE:/advertiser/1删除 ID 为 1 的广告主
    POST:/advertiser创建广告主

    可见,请求路径相同,但请求方式不同,所代表的业务操作也不同,例如,/advertiser/1 这个请求,带有 GET、PUT、DELETE 三种不同的请求方式,对应三种不同的业务操作。

    虽然 REST 看起来还是很简单的,实际上我们往往需要提供一个 REST 框架,让其实现前后端分离架构,让开发人员将精力集中在业务上,而并非那些具体的技术细节。

    五、前后端分离意义大吗?

    1、该网站前端变化远比后端变化频繁,则意义大。

    2、该网站尚处于原始开发模式,数据逻辑与表现逻辑混杂不清,则意义大。

    3、该网站前端团队和后端团队分属两个领导班子,技能点差异很大,则意义大。

    4、该网站前端效果绚丽/跨设备兼容要求高,则意义大。

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

    以前的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多线程,模块化,面向切面编程,设计模式,浏览器兼容性,性能优化等等。
    前端追求的是:页面表现,速度流畅,兼容性,用户体验等等。


    七、耦合时代

    几曾何时,我们的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。
    前端只需要关注页面的样式与动态数据的解析&渲染,而后端专注于具体业务逻辑。

    转载自:https://blog.csdn.net/weixin_37539378/article/details/79956760
    展开全文
  • 前后端分离及项目开发流程

    千次阅读 2020-08-31 09:51:47
    前后端分离开发流程 新框架前后端完全分离,后端基于SpringBoot提供 ResultFul的接口服务,前端是基于Layui的全静态页面,这样就对我们的开发流程提出新的要求。 后端人员:按照约定提供经过单元测试的Restful API...

    前后端分离开发流程

    新框架前后端完全分离,后端基于SpringBoot提供 ResultFul的接口服务,前端是基于Layui的全静态页面,这样就对我们的开发流程提出新的要求。
    后端人员:按照约定提供经过单元测试的Restful API接口,使后端更关注业务逻辑的实现。

    前端人员:按界面要求完成页面的展现开发和逻辑跳转,使前端更关注页面的布局样式和交互。

    开发流程规范:

    1、共同约定接口、并维护至DOCLever

    前后端人员和项目相关成员,在设计完成后,根据页面和数据库进行梳理,确定调用接口个数和功能,在DOCLever上维护要开发的接口,包括入参和出参。
    接口约定是前后端人员后续联调开发的基础,如在开发过程中接口发生变化要及时调整,并告知对方。
    DOCLever 使用地址:http://114.112.193.6:32500/html/web/controller/index/index.html

    2、前端开发页面,并使用模拟数据调试

    前端人员根据页面设计,参考Demo,进行开发页面
    使用NodeJS,模拟请求DOCLever服务端Mock生成的数据,进行调试和页面跳转测试(DOCLever的Mock使用指南请点击查看)

    3、后端开发服务端、并进行单元测试

    服务端人员开发 entity、dao、service、controller 编写业务逻辑。(可使用代码生成工具生成,进行修改,具体使用方法请点击查看)
    使用MockMvc 编写单元测试,对开发功能进行测试。(具体使用方法,请点击查看)

    4、前后端本地联调

    使用NodeJS,代理转发请求到后端开发人员机器进行联调
    直接连开发机器联调,需要修改前台net.js中sysRoot=后台接口api地址/contextPath值,后台需要检查是否开启跨域(regie.isCorsOpen=true)

    5、Nginx部署联调

    将开发的服务端,打包部署到服务器
    将开发的页面,打包部署到Nginx,并配置转换地址进行联调。

    项目开发的一般流程:

    ->需求会议

    • 产品经理宣讲项目需求内容,有任何疑问会上及时提出,会后自己估算工作量与开发工期。

    ->排期会议

    • 根据自己估算的工作量给出相应排期时间,排期时间分为开发时间 + 联调时间。
    • 开发时间为自己开发用时,联调时间为所有开发共同调试时间,此时需在测试环境接入接口调试。
    • 联调之前需将绝大部分开发工作完成,部分需要在联调阶段才能完成的工作可在联调时间内完成。 开发之前
    • 通常在开发之前后端开发会先给出协议文档,文档内容为会用到的接口,与接口大致返回的数据,拿到协议文档,先看一遍,哪里不对或者缺少什么字段及时向后端提出并修改。

    ->项目开发

    • 从 master 分支拉开发分支,并根据要求的分支命名格式进行命名

    ->项目联调

    • 环境分支一般分为: dev(开发)、stg(联调、测试)、pre(测试)、gra(灰度环境)、prd(线上环境)。

    • 联调通常在 stg 上进行,后端代码发布 stg 环境后,前端可在本地环境调试 stg 环境接口。

    ->showcase会议(向测试人员展示开发的功能。)

    • 通常在联调最后一天的下午会进行,向测试人员展示开发的功能。
    • showcase 上的发现问题会后需要及时修改,如有严重阻塞主流程的问题,项目会被测试同学打回,showcase
      失败。需在修改完成后重新进行 showcase。

    ->项目提测

    • showcase 中的问题修改完后由项目开发负责人写提测邮件提测。

    ->项目debug
    项目debug需要在相关平台上进行展示出来并设置其重要程度和需花费的时间

    ->项目发布

    • 发布对应环境代码时,将自己的开发分支合并到对应环境分支,发 stg 代码则合并到 stg 分支,发 pre、gra、prd 环境都是合并到release 分支,master 分支存放线上运行稳定代码。
    • 环境发布顺序为:stg->pre->gra->prd,一般按照此顺序发布,前面环境测试通过后才可发布到下一个环境。代码发布线上确认运行稳定后将分支合并到master 分支。
    展开全文
  • 前后端分离架构概述

    万次阅读 多人点赞 2020-04-17 09:59:20
    前后端分离已成为互联网项目开发的业界标准使用方式,通过nginx+tomcat的方式(也可以中间加一个nodejs)有效的进行解耦,并且前后端分离会为以后的大型分布式架构、弹性计算架构、微服务架构、多端化服务(多种...

    1、背景

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

          核心思想是前端HTML页面通过AJAX调用后端的RESTFUL API接口并使用JSON数据进行交互

          Web服务器:一般指像Nginx,Apache这类的服务器,他们一般只能解析静态资源;

          应用服务器:一般指像Tomcat,Jetty,Resin这类的服务器可以解析动态资源也可以解析静态资源,但解析静态资源的能力没有web服务器好;

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

          以前的Java Web项目大多数都是Java程序员又当爹又当妈,又搞前端,又搞后端。随着时代的发展,渐渐的许多大中小公司开始把前后端的界限分的越来越明确,前端工程师只管前端的事情,后端工程师只管后端的事情。正所谓术业有专攻,一个人如果什么都会,那么他毕竟什么都不精。大中型公司需要专业人才,小公司需要全才,但是对于个人职业发展来说,前后端需要分离。

    2、未分离时代(各种耦合)

          早期主要使用MVC框架,Jsp+Servlet的结构图如下:

    640?wx_fmt=jpeg

          大致就是所有的请求都被发送给作为控制器的Servlet,它接受请求,并根据请求信息将它们分发给适当的JSP来响应。同时,Servlet还根据JSP的需求生成JavaBeans的实例并输出给JSP环境。JSP可以通过直接调用方法或使用UseBean的自定义标签得到JavaBeans中的数据。需要说明的是,这个View还可以采用 Velocity、Freemaker 等模板引擎。使用了这些模板引擎,可以使得开发过程中的人员分工更加明确,还能提高开发效率。

          那么,在这个时期,开发方式有如下两种:

    方式一 640?wx_fmt=png 方式二 640?wx_fmt=jpeg

          方式二已经逐渐淘汰。主要原因有两点:
          1)前端在开发过程中严重依赖后端,在后端没有完成的情况下,前端根本无法干活;
          2)由于趋势问题,会JSP,懂velocity,freemarker等模板引擎的前端越来越少;

          因此,方式二逐渐不被采用。然而,不得不说一点,方式一,其实很多小型传统软件公司至今还在使用。那么,方式一和方式二具有哪些共同的缺点呢?

           1、前端无法单独调试,开发效率低;

           2、 前端不可避免会遇到后台代码,例如:

    <body>
       <%
           request.setCharacterEncoding("utf-8")
           String name=request.getParameter("username");
           out.print(name);
       %>
    </body>
    

          这种方式耦合性太强。那么,就算你用了freemarker等模板引擎,不能写Java代码。那前端也不可避免的要去重新学习该模板引擎的模板语法,无谓增加了前端的学习成本。正如我们后端开发不想写前端一样,你想想如果你的后台代码里嵌入前端代码,你是什么感受?因此,这种方式十分不妥。

          3、JSP本身所导致的一些其他问题 比如,JSP第一次运行的时候比较缓慢,因为里头包含一个将JSP翻译为Servlet的步骤。再比如因为同步加载的原因,在JSP中有很多内容的情况下,页面响应会很慢。

    3、半分离时代

          前后端半分离,前端负责开发页面,通过接口(Ajax)获取数据,采用Dom操作对页面进行数据绑定,最终是由前端把页面渲染出来。这也就是Ajax与SPA应用(单页应用)结合的方式,其结构图如下:

    640?wx_fmt=jpeg

          步骤如下:
    (1)浏览器请求,CDN返回HTML页面;
    (2)HTML中的JS代码以Ajax方式请求后台的Restful接口;
    (3)接口返回Json数据,页面解析Json数据,通过Dom操作渲染页面;

          后端提供的都是以JSON为数据格式的API接口供Native端使用,同样提供给WEB的也是JSON格式的API接口。

          那么意味着WEB工作流程是:
          1、打开web,加载基本资源,如CSS,JS等;
          2、发起一个Ajax请求再到服务端请求数据,同时展示loading;
          3、得到json格式的数据后再根据逻辑选择模板渲染出DOM字符串;
          4、将DOM字符串插入页面中web view渲染出DOM结构;

          这些步骤都由用户所使用的设备中逐步执行,也就是说用户的设备性能与APP的运行速度联系的更紧换句话说就是如果用户的设备很低端,那么APP打开页面的速度会越慢。

          为什么说是半分离的?因为不是所有页面都是单页面应用,在多页面应用的情况下,前端因为没有掌握controller层,前端需要跟后端讨论,我们这个页面是要同步输出呢,还是异步Json渲染呢?而且,即使在这一时期,通常也是一个工程师搞定前后端所有工作。因此,在这一阶段,只能算半分离。

          首先,这种方式的优点是很明显的。前端不会嵌入任何后台代码,前端专注于HTML、CSS、JS的开发,不依赖于后端。自己还能够模拟Json数据来渲染页面。发现Bug,也能迅速定位出是谁的问题。

          然而,在这种架构下,还是存在明显的弊端的。最明显的有如下几点:
          1)JS存在大量冗余,在业务复杂的情况下,页面的渲染部分的代码,非常复杂;
          2)在Json返回的数据量比较大的情况下,渲染的十分缓慢,会出现页面卡顿的情况;
          3)SEO( Search Engine Optimization,即搜索引擎优化)非常不方便,由于搜索引擎的爬虫无法爬下JS异步渲染的数据,导致这样的页面,SEO会存在一定的问题;
          4)资源消耗严重,在业务复杂的情况下,一个页面可能要发起多次HTTP请求才能将页面渲染完毕。可能有人不服,觉得PC端建立多次HTTP请求也没啥。那你考虑过移动端么,知道移动端建立一次HTTP请求需要消耗多少资源么?

          正是因为如上缺点,我们才亟需真正的前后端分离架构。

    4、分离时代

          大家一致认同的前后端分离的例子就是SPA(Single-page application),所有用到的展现数据都是后端通过异步接口(AJAX/JSONP)的方式提供的,前端只管展现。从某种意义上来说,SPA确实做到了前后端分离,但这种方式存在两个问题:

    • WEB服务中,SPA类占的比例很少。很多场景下还有同步/同步+异步混合的模式,SPA不能作为一种通用的解决方案;
    • 现阶段的SPA开发模式,接口通常是按照展现逻辑来提供的,而且为了提高效率我们也需要后端帮我们处理一些展现逻辑,这就意味着后端还是涉足了view层的工作,不是真正的前后端分离。

          SPA式的前后端分离,从物理层做区分(认为只要是客户端的就是前端,服务器端就是后端)这种分法已经无法满足前后端分离的需求,我们认为从职责上划分才能满足目前的使用场景:

    • 前端负责view和controller层
    • 后端只负责model层,业务处理与数据持久化等

          controller层与view层对于目前的后端开发来说,只是很边缘的一层,目前的java更适合做持久层、model层的业务。

          在前后端彻底分离这一时期,前端的范围被扩展,controller层也被认为属于前端的一部分。在这一时期:
          前端:负责View和Controller层。
          后端:只负责Model层,业务/数据处理等。

          可是服务端人员对前端HTML结构不熟悉,前端也不懂后台代码呀,controller层如何实现呢?这就是node.js的妙用了,node.js适合运用在高并发、I/O密集、少量业务逻辑的场景。最重要的一点是,前端不用再学一门其他的语言了,对前端来说,上手度大大提高。

    640?wx_fmt=jpeg

          可以就把Nodejs当成跟前端交互的api。总得来说,NodeJs的作用在MVC中相当于C(控制器)。Nodejs路由的实现逻辑是把前端静态页面代码当成字符串发送到客户端(例如浏览器),简单理解可以理解为路由是提供给客户端的一组api接口,只不过返回的数据是页面代码的字符串而已

          用NodeJs来作为桥梁架接服务器端API输出的JSON。后端出于性能和别的原因,提供的接口所返回的数据格式也许不太适合前端直接使用,前端所需的排序功能、筛选功能,以及到了视图层的页面展现,也许都需要对接口所提供的数据进行二次处理。这些处理虽可以放在前端来进行,但也许数据量一大便会浪费浏览器性能。因而现今,增加Node中间层便是一种良好的解决方案

    ![这里写图片描述](https://img-blog.csdn.net/20180811200234841?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Z1emhvbmdtaW4wNQ==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)

          浏览器(webview)不再直接请求JSP的API,而是:
          1)浏览器请求服务器端的NodeJS;
          2)NodeJS再发起HTTP去请求JSP;
          3)JSP依然原样API输出JSON给NodeJS;
          4)NodeJS收到JSON后再渲染出HTML页面;
          5)NodeJS直接将HTML页面flush到浏览器;

          这样,浏览器得到的就是普通的HTML页面,而不用再发Ajax去请求服务器了。

          淘宝的前端团队提出的中途岛(Midway Framework)的架构如下图所示:

    这里写图片描述

          增加node.js作为中间层,具体有哪些好处呢?

          (1)适配性提升;我们其实在开发过程中,经常会给PC端、mobile、app端各自研发一套前端。其实对于这三端来说,大部分端业务逻辑是一样的。唯一区别就是交互展现逻辑不同。如果controller层在后端手里,后端为了这些不同端页面展示逻辑,自己维护这些controller,模版无法重用,徒增和前端沟通端成本。 如果增加了node.js层,此时架构图如下:

    640?wx_fmt=jpeg

          在该结构下,每种前端的界面展示逻辑由node层自己维护。如果产品经理中途想要改动界面什么的,可以由前端自己专职维护,后端无需操心。前后端各司其职,后端专注自己的业务逻辑开发,前端专注产品效果开发。

          (2)响应速度提升;我们有时候,会遇到后端返回给前端的数据太简单了,前端需要对这些数据进行逻辑运算。那么在数据量比较小的时候,对其做运算分组等操作,并无影响。但是当数据量大的时候,会有明显的卡顿效果。这时候,node中间层其实可以将很多这样的代码放入node层处理、也可以替后端分担一些简单的逻辑、又可以用模板引擎自己掌握前台的输出。这样做灵活度、响应度都大大提升。

           举个例子,即使做了页面静态化之后,前端依然还是有不少需要实时从后端获取的信息,这些信息都在不同的业务系统中,所以需要前端发送5、6个异步请求来。有了NodeJs之后,前端可以在NodeJs中去代理这5个异步请求。还能很容易的做bigpipe,这块的优化能让整个渲染效率提升很多。在PC上你觉得发5、6个异步请求也没什么,但是在无线端,在客户手机上建立一个http请求开销很大。有了这个优化,性能一下提升好几倍。

          (3)性能得到提升;大家应该都知道单一职责原则。从该角度来看,我们,请求一个页面,可能要响应很多个后端接口,请求变多了,自然速度就变慢了,这种现象在mobile端更加严重。采用node作为中间层,将页面所需要的多个后端数据,直接在内网阶段就拼装好,再统一返回给前端,会得到更好的性能。

          (4)异步与模板统一;淘宝首页就是被几十个HTML片段(每个片段一个文件)拼装成,之前PHP同步include这几十个片段,一定是串行的,Node可以异步,读文件可以并行,一旦这些片段中也包含业务逻辑,异步的优势就很明显了,真正做到哪个文件先渲染完就先输出显示。前端机的文件系统越复杂,页面的组成片段越多,这种异步的提速效果就越明显。前后端模板统一在无线领域很有用,PC页面和WIFI场景下的页面适合前端渲染(后端数据Ajax到前端),2G、3G弱网络环境适合后端渲染(数据随页面吐给前端),所以同样的模板,在不同的条件下走不同的渲染渠道,模板只需一次开发。

          增加NodeJS中间层后的前后端职责划分:

    这里写图片描述

    5、总结

          从经典的JSP+Servlet+JavaBean的MVC时代,到SSM(Spring + SpringMVC + Mybatis)和SSH(Spring + Struts + Hibernate)的Java 框架时代,再到前端框架(KnockoutJS、AngularJS、vueJS、ReactJS)为主的MV*时代,然后是Nodejs引领的全栈时代,技术和架构一直都在进步。虽然“基于NodeJS的全栈式开发”模式很让人兴奋,但是把基于Node的全栈开发变成一个稳定,让大家都能接受的东西还有很多路要走。创新之路不会止步,无论是前后端分离模式还是其他模式,都是为了更方便得解决需求,但它们都只是一个“中转站”。前端项目与后端项目是两个项目,放在两个不同的服务器,需要独立部署,两个不同的工程,两个不同的代码库,不同的开发人员。前端只需要关注页面的样式与动态数据的解析及渲染,而后端专注于具体业务逻辑。

          参考:淘宝前后端分离解决方案

          参考:从分布式之的角度告诉你前后端分离架构的必要性!

          参考:浅谈前后端分离技术

    展开全文
  • 前后端分离项目初体验——手把手教程+实例Demo

    万次阅读 热门讨论 2020-01-07 12:44:59
    Web开发发展至今,前后端分离已经成为一种大趋势。今天我就以JavaWeb为示例来讲解一下前后端分离项目的构建、运行与开发。 示例项目的技术: 前端–Vue.js 后端–SpringBoot2.0 + SSM框架 使用Nginx解决请求转接与...

    Web开发发展至今,前后端分离已经成为一种大趋势。今天我就以JavaWeb为示例来讲解一下前后端分离项目的构建、运行与开发。

    示例项目的技术:

    • 前端–Vue.js
    • 后端–SpringBoot2.0 + SSM框架
    • 使用Nginx解决请求转接与跨域问题

    项目源码地址:springboot-examples/ssm_vue

    注:由于最近在调整Git上的项目,导致本节指向的示例项目暂时不可以访问了。

    有关前后端分离的一些思考(此部分可略过)

    首先我们需要理解一个东西:一个常见的项目被启动后,通常是占用一个特定的端口号的,比如说8080。而如果项目被划分成前端项目与后端项目时,它们是如何划分的呢?占用的还是一个端口么?前端项目又是如何被启动的?

    下面由我细细道来。
    首先,前后端划分的标准很简单,所有页面部分(html,js,css)这些东西归前端,其他部分归后端。

    就项目启动看,以npm为基础的vue.js项目,前端项目启动后同样是绑定在某个端口上的(这个端口号可以不指定,由系统从8080开始自动进行赋值)。前后端会分别占用操作系统的一个端口。

    还有一个问题,前后端项目都启动后,我要如何从前端去请求我的后端接口呢?我要把后端端口号也配置在前端里面以便它去访问?而由此而来的还有一个问题,这就相当于在一个网站中调用另一个网站的内容(注意,这里的第二个网站指的是后端项目),这将导致跨域问题,使得请求失败。
    有关这一点,我需要通过某种手段、工具,来让前端去正确地访问后端接口,最好还不需要前端知道我的后端端口号是什么。Nginx可以较为完美地解决以上问题。

    下面,让我们来一步步地实现一个简单的前后端分离项目。


    构建后端项目——SpringBoot + SSM

    参考我的另一篇博客:SpringBoot项目创建与第一个SSM项目示例

    这篇博客详细描述了如何使用STS(springtoolsuite,一个eclipse的变种)来构建一个SpringBoot下的SSM项目。使用IDEA创建的步骤也基本一致。

    启动这个项目,控制台如下:
    在这里插入图片描述

    下面我们来创建一个vue.js项目作为独立的前端项目。


    构建前端项目——Vue.js

    参考我的另一篇博客:vue.js环境配置到项目创建与第一个示例

    这篇博客主要描述了如何从零开始去创建一个vue.js项目并启动运行它。为了方便测试,添加一个登录页面到项目中——详细代码到我的Git仓库查看:

    你可以使用npm命令行创建该项目,也可以使用如webstorm之类的开发工具来创建。

    打开浏览器,输入localhost:8080,界面如下:
    在这里插入图片描述

    这表示我们的前端项目已经成功启动了。

    下面我们还差一个步骤,如何让我们的前端项目能够访问到后端接口呢。
    我使用nginx代理来解决这个问题,同时,使用nginx还能避免跨域问题的出现。


    让前端访问后端接口&Nginx解决跨域问题

    习惯于前后端统一开发的人可能很少遇到跨域问题,可以先看看这篇博客:什么是跨域?怎么解决跨域问题?

    简单来说呢,跨域就是在一个网站里,直接地去访问另外一个网站的数据,由于域名、IP、端口的不同,根据浏览器的安全策略,产生了跨域问题,这将导致你是无法直接用前端去调用后端接口的,控制台将产生如下错误:

    No 'Access-Control-Allow-Origin' header is present on the requested resource.
    

    然后来看一下如何使用Nginx代理转发前端请求和后端请求:Nginx配置前后端分离项目代理–解决跨域问题

    比如对于我的示例项目,是如下配置的:

    server {
        listen       8988;
        server_name  127.0.0.1;
    
        location / {
            proxy_pass http://127.0.0.1:8090;
        }
    	
    	location /api {
    	    proxy_pass http://127.0.0.1:8181;
    		proxy_set_header Host $http_host;
    	}
    }
    

    配置完成后,启动nginx。在浏览器中输入nginx监听的端口:localhost:8988,界面如下:

    在这里插入图片描述

    可以看到这个界面和上面直接使用localhost:8080访问前端项目的效果相同。输入数据库中对应的账户信息,点击登录,可以看到成功跳转至首页:

    在这里插入图片描述

    在这里插入图片描述

    至此,我们已经成功创建了一个前后端分离的项目,并且使用代理解决了前后端请求的问题。


    一个完整的Demo与源码地址

    项目源码地址:springboot-examples/ssm_vue

    目录下分为ssm_demovue_demo两个项目,另附一份nginx.conf配置文件。

    若要启动该示例,首先需要建立ssm_demo数据库,导入项目下的user.sql表。
    然后分别启动ssm_demovue_demo两个项目,再启动nginx即可。
    配置Nginx,使用Nginx配置中监听的端口(如示例中的8888)进行访问。


    加入微信群

    添加我的个人微信,备注 加群 即可。欢迎大家加入,一起分享学习和开发中遇到的问题!

    file

    关注公众号

    关注公众号:猿生物语。每周分享干货技术文章。
    可免费获取云盘学习资料。

    如果大家想要实时关注我的文章和分享动态的话,可以关注一下!

    file

    展开全文
  • 前后端分离开发规范

    千次阅读 2019-05-27 14:41:35
    一、为什么要前后端分离 前后端可以身心愉快地专注于各自擅长的领域 避免后端写前端代码(基本上1天时间,20%写后端代码,80%写页面...) 前端配置后端代码运行环境(简直是要疯... 装一堆环境,而且有些开发环境...
  • 1.前后端分离开发模式

    千次阅读 2018-04-11 21:00:08
    2018/4/10 今天是一个特殊的日子,我做为一个实习...2.前后端分离 2.1交互形式 2.2代码的组织方式 2.3开发模式 2.4接口规范流程 3.线上部署 4.总结 1.为什么分离 这个问题就涉及到web应用的发展历史了...
  • 前后端分离的优缺点

    万次阅读 2018-07-26 16:50:55
    WEB 前后端分离三个最大的优点在于:1:最大的好处就是前端JS可以做很大部分的数据处理工作,对服务器的压力减小到最小2:后台错误不会直接反映到前台,错误接秒较为友好3:由于后台是很难去探知前台页面的分布情况...
  • 浅谈前后端分离开发模式

    万次阅读 2019-06-13 11:14:10
    为什么要前后端分离? 什么是前后端分离前后端分离的优缺点? 为什么要前后端分离? 以Java Web项目为例,在传统的开发模式中,前端代码(Html、js、css)写在JSP中,甚至JSP中嵌入Java代码。当用户访问网站...
  • 前后端分离开发具体实现

    千次阅读 2019-10-25 12:31:57
    前后端分离开发具体实现 1 Visual Studio Code开发工具的安装 双击安装,即可成功 3.1.2 Visual Studio Code开发工具的配置 3.1.2.1、设置中文环境 设置中文环境 安装完毕后,vscode全部都是英文版本的,需要把...
  • 前后端分离实践的架构设计

    万次阅读 2019-01-08 20:25:59
    前后端分离的项目开发策略已经不是什么新鲜东西了,网上介绍这方面的文章非常多。我自己是在14年的时候接触到的,对这种开发策略一直爱不释手,不管新老项目都会首先用前后端分离的思维先去思考一番。从14年到现在在...
  • 一、前后端分离的概念 前后端分离 前后端分离是一种架构模式,说通俗点就是后端项目里面看不到页面(JSP | HTML),后端给前端提供接口,前端调用后端提供的 REST 风格接口就行,前端专注写页面(html|jsp)和...
  • Django实现前后端分离开发

    千次阅读 2019-07-12 16:17:45
    前后端分离开发 在传统的Web应用开发中,大多数的程序员会将浏览器作为前后端的分界线。将浏览器中为用户进行页面展示的部分称之为前端,而将运行在服务器,为前端提供业务逻辑和数据准备的所有代码统称为后端。所谓...
  • 微信公众号支付java前后端分离开发

    千次阅读 2019-07-24 18:47:57
    微信公众号支付java前后端分离开发 欢迎使用Markdown编辑器 你好! 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章,了解一下Markdown的基本语法知识...
  • 什么是前后端分离开发

    千次阅读 2018-01-16 00:00:11
    实现前后端分离的心得 对目前的web来说,前后端分离已经变得越来越流行了,越来越多的企业/网站都开始往这个方向靠拢。那么,为什么要选择前后端分离呢?前后端分离对实际开发有什么好处呢? 为什么选择前后端分离 ...
  • 前后端分离开发

    千次阅读 2018-03-11 00:14:33
    步入编程行业之初,记得公司的传统项目开发都是采用模块化,就是各自开发自己的模块,前后端代码一起撸,当时觉得这种方式还是挺好的,页面样式,业务逻辑分析,调试代码等等都是自己一个人写,这样子比起联调,或许...
  • 前后端分离开发入门 在传统的Web应用开发中,大多数的程序员会将浏览器作为前后端的分界线。将浏览器中为用户进行页面展示的部分称之为前端,而将运行在服务器,为前端提供业务逻辑和数据准备的所有代码统称为后端。...
  • 一、前端架构选型:Vue+iView 1.基于Vue-Cli 2.主要main组件框架基于iView-admin 3.其他 Vue、Vue Router、Vuex、vue-i18n:国际化、iview-area:城市级联组件、wangeditor:轻量富文本编辑器、vue-stomp、vue-...
  • 概要介绍:历经两三个星期的时间,Debug亲自撸的 “SpringBoot2.x前后端分离开发之用户身份认证实战(后端实现)” 终于完成了。正如字面意思,本课程讲解的是在当前微服务、分布式系统架构时代,前后端在进行接口...
  • 用SpringMVC开发主要是要要会导入spingmvc文件,然后就是编写接口 package com.imooc.controller; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.Request...
  • 点击上方“后端技术精选”,选择“置顶公众号”技术文章第一时间送达!作者:山人行cnblogs.com/shanrengo/p/6397734.html推荐阅读(点击即可跳...
1 2 3 4 5 ... 20
收藏数 49,209
精华内容 19,683
关键字:

前后端分离开发