• <legend id='syu367s5'><style id='56cwza9k'><dir id='j7vid97b'><q id='1fkke7mh'></q></dir></style></legend><tfoot id='qh2kfixz'></tfoot>

      <small id='mrr0nnt8'></small><noframes id='ixw9syf2'>

        <tbody id='1bwzynrx'></tbody>
      <i id='a9vvfenw'><tr id='u7dykkwb'><dt id='g1jw5zy6'><q id='alqtk3gg'><span id='0h0epkcn'><b id='vwdcqftt'><form id='7lyqns24'><ins id='jtnsolte'></ins><ul id='aadfyt81'></ul><sub id='pcpjw3up'></sub></form><legend id='d5afa6pg'></legend><bdo id='qv0zhsag'><pre id='07n7i9dv'><center id='to1772is'></center></pre></bdo></b><th id='y69if8j0'></th></span></q></dt></tr></i><div id='u94bnzlm'><tfoot id='ycayu8z7'></tfoot><dl id='wgo4q0jw'><fieldset id='j0cmqsea'></fieldset></dl></div>

      1. 网站建设公司当前位置 : 网站建设公司 > 知识普及

        Java Web 开发发展简介

        发布时间:2021-09-16 10:58   浏览次数:次   

        远古期 - 静态页面时代

        讲Java Web开发的历史进程,不得不提Web开发的历史进程。
        在互联网刚发展的时候,那时候的网站功能是很简单的。那时候的网站还都是静态的。这里所说的静态是指,请求访问的网页都是事先编辑好的,不能改变的。

        这里先讲下当时一个请求是如何返回结果的。

        比如,你想访问新浪上的一张图片,会在浏览器键入这个图片的地址:

         

        image.png

        浏览器会根据地址像新浪服务器发送HTTP请求。新浪服务器上的HTTP Server接收到请求后,会根据路径地址/img/12345.jpg查找的这个文件,然后read文件,再把图片数据发送给客户端,客户端的浏览器就能正确展示图片了。

         

        image.png

        也就是说,这里的URL对服务器来说就是查找文件的地址,而文件必须实实在在存在于服务器中的特定目录下的。

        缺点
        很明显,访问的资源必须事先已经存在,否则访问不到。而动态展示也是没法实现的。比如:某人刚发布了一篇文章,想在首页立即看到是不可能的。只能重新手动编辑首页,把文章链接加进去

         混沌期 - CGI时代

        然而,如果页面一直是静态的额,也就不会有现在纷繁复杂的网站了。那么动态展示页面的解决方案是什么呢?是CGI!
        CGI全称是通用网关接口(Common Gateway Interface)。那么它的作用是啥呢?

         CGI是啥

        首先,要清楚CGI是啥?
        CGI是一个可执行的程序或者可运行的脚本。几乎所有语言都能写CGI,像python,C,甚至shell。

        举个例子。下面一段C代码,经过编译成可执行程序后,就是一个CGI。

        
        
        1.  
          int _tmain(int argc, _TCHAR* argv[])
        2.  
          {
        3.  
          printf("Content-type:text/html\n\n");
        4.  
          printf("%s",getenv("QUERY_STRING")); //打印get获取的信息
        5.  
          return 0;
        6.  
          }

        再或者,下面一个python脚本,也是一个CGI

        
        
        1.  
          #!/usr/bin/python
        2.  
          # -*- coding: UTF-8 -*-
        3.  
           
        4.  
          print "Content-type:text/html"
        5.  
          print # 空行,告诉服务器结束头部
        6.  
          print '<html>'
        7.  
          print '<head>'
        8.  
          print '<meta charset="utf-8">'
        9.  
          print '<title>Hello Word - 我的第一个 CGI 程序!</title>'
        10.  
          print '</head>'
        11.  
          print '<body>'
        12.  
          print '<h2>Hello Word! 我是来自菜鸟教程的第一CGI程序</h2>'
        13.  
          print '</body>'
        14.  
           
        15.  
          print '</html>'
        16.  
           
        17.  
          作者:齐晋
        18.  
          链接:https://www.jianshu.com/p/bec6736dcc3d
        19.  
          来源:简书
        20.  
          著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

        OK,知道了CGI是可执行的程序或脚本,但是怎么工作的呢?

        CGI怎么用

         

        image.png

        如上图,当浏览器发送一个CGI请求后,服务器会启动一个进程运行CGI程序或脚本,由CGI来处理数据,并将结果返回给服务器,服务器再将结果返回给浏览器。

        举个表单提交的例子:

        
        
        1.  
          <form id="form" name="form" method="post" action="http://localhost/cgi-bin/test/cgi_test.cgi">
        2.  
          <p>输入内容:
        3.  
          <input type="text" name="user" id="user" />
        4.  
          </p>
        5.  
          <p>
        6.  
          <input type="submit" name="submit" id="submit" value="提交" />
        7.  
          </p>
        8.  
          </form>

        上面是一个表单提交的html代码,展示的效果是下面这个样子:

         

        image.png

        细心的你会发现,action的值是http://localhost/cgi-bin/test/cgi_test.cgi。这里,cgi_test.cgi就是一个cgi程序。 还记得上面那段C++代码吗?

        
        
        1.  
          int _tmain(int argc, _TCHAR* argv[])
        2.  
          {
        3.  
          printf("Content-type:text/html\n\n");
        4.  
          printf("%s",getenv("QUERY_STRING")); //打印get获取的信息
        5.  
          return 0;
        6.  
          }

        cgi_test.cgi就是这段代码编译出来的可执行程序。 这段代码的作用是什么呢? 作用是将表单提交的信息直接打印出来。 如何做到的? 只有两行代码,第二行代码是关键。getenv()是C函数库中的函数,getenv("QUERY_STRING")的意思是读取环境变量QUERY_STRING的值。而QUERY_STRING的值就是表单提交的信息。 OK,这个CGI的功能就清晰了。表单提交后展示下面的结果也就不奇怪了:

         

        image.png

         

        我们再通过一个图梳理下上述流程:

         

        image.png

        综上,CGI工作模式示意图如下:

         

        image.png

         CGI的特点

        • 由Http Server唤起。常见的Http Server如Apache,Lighttpd,nginx都支持CGI
        • CGI单独启动进程,并且每次调用都会重新启动进程
        • 可以用任何语言编写,只要该语言支持标准输入、输出和环境变量

         CGI的缺点

        • 消耗资源多:每个请求都会启动一个CGI进行,进程消耗资源15M内存的话,同时到达100个请求的话,就会占用1.5G内存。如果请求更多,资源消耗是不可想象的。
        • :启动进程本身就慢。每次启动进程都需要重新初始化数据结构等,会变得更慢。

        引申

        为了解决CGI重复启动进程和初始化的问题,后来出现了FastCGI

         开荒期 - Servlet时代

        在CGI繁荣发展的时代,Java还没有发展起来。当Java开始参与历史,引领潮流的时候,也必然会借鉴和改进之前的技术和思想。

        鉴于CGI的一些缺点,Java Web在开始设计的时候就想出了一种解决方案 -- Servlet 同样,第一个问题,Servlet是啥?

         Servlet是啥?

        举个例子,网站一般都有注册功能。当用户填写好注册信息,点击“注册”按钮时,谁来处理这个请求?用户名是否重复谁来校验?用户名和密码需要写入数据库,谁来写入?是Servlet!

        Servlet是实现javax.servlet.Servlet接口的类。一般处理Web请求的Servlet还需要继承javax.servlet.http.HttpServlet

        
        
        1.  
          abstract class HttpServlet implements Servlet{
        2.  
          void doGet();
        3.  
          void doPost();
        4.  
          }

        doGet()方法处理GET请求 doPost()方法处理POST请求

        浏览器发来的请求是怎么被Servlet处理的呢?还是举表单提交的例子。 我们假设表单样式如下,只是简单提交两个数据:网址名和网址。并假设处理URL为http://localhost:8080/TomcatTest/HelloForm

         

        image.png

        浏览器工作 当表单使用GET方式提交时,浏览器会把表单数据组装成这样的URL:http://localhost:8080/TomcatTest/HelloForm?name=菜鸟教程&url=www.runoob.com

        好,现在浏览器的任务暂时告一段落,开始Java Web服务工作了。

        Java Web服务 首先,我们得指定http://localhost:8080/TomcatTest/HelloForm这个URL由谁来处理。这个映射关系需要在web.xml中配置:

        
        
        1.  
          <?xml version="1.0" encoding="UTF-8"?>
        2.  
          <web-app>
        3.  
          <servlet>
        4.  
          <servlet-name>HelloForm</servlet-name>
        5.  
          <servlet-class>com.runoob.test.HelloForm</servlet-class>
        6.  
          </servlet>
        7.  
          <servlet-mapping>
        8.  
          <servlet-name>HelloForm</servlet-name>
        9.  
          <url-pattern>/TomcatTest/HelloForm</url-pattern>
        10.  
          </servlet-mapping>
        11.  
          </web-app>

        web.xml中配置的意思是:当URI为/TomcatTest/HelloForm时,交给com.runoob.test.HelloForm处理。而HelloForm正是个Servlet。

        因此,我们需要编写HelloForm这样一个Servlet:

        
        
        1.  
          import java.io.IOException;
        2.  
          import java.io.PrintWriter;
        3.  
           
        4.  
          import javax.servlet.ServletException;
        5.  
          import javax.servlet.annotation.WebServlet;
        6.  
          import javax.servlet.http.HttpServlet;
        7.  
          import javax.servlet.http.HttpServletRequest;
        8.  
          import javax.servlet.http.HttpServletResponse;
        9.  
           
        10.  
          /**
        11.  
          * Servlet implementation class HelloForm
        12.  
          */
        13.  
          @WebServlet("/HelloForm")
        14.  
          public class HelloForm extends HttpServlet {
        15.  
          private static final long serialVersionUID = 1L;
        16.  
           
        17.  
          /**
        18.  
          * @see HttpServlet#HttpServlet()
        19.  
          */
        20.  
          public HelloForm() {
        21.  
          super();
        22.  
          // TODO Auto-generated constructor stub
        23.  
          }
        24.  
           
        25.  
          /**
        26.  
          * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
        27.  
          */
        28.  
          protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        29.  
          // 设置响应内容类型
        30.  
          response.setContentType("text/html;charset=UTF-8");
        31.  
           
        32.  
          PrintWriter out = response.getWriter();
        33.  
          String title = "使用 GET 方法读取表单数据";
        34.  
          // 处理中文
        35.  
          String name =new String(request.getParameter("name").getBytes("ISO8859-1"),"UTF-8");
        36.  
          String docType = "<!DOCTYPE html> \n";
        37.  
          out.println(docType +
        38.  
          "<html>\n" +
        39.  
          "<head><title>" + title + "</title></head>\n" +
        40.  
          "<body bgcolor=\"#f0f0f0\">\n" +
        41.  
          "<h1 align=\"center\">" + title + "</h1>\n" +
        42.  
          "<ul>\n" +
        43.  
          " <li><b>站点名</b>:"
        44.  
          + name + "\n" +
        45.  
          " <li><b>网址</b>:"
        46.  
          + request.getParameter("url") + "\n" +
        47.  
          "</ul>\n" +
        48.  
          "</body></html>");
        49.  
          }
        50.  
           
        51.  
          // 处理 POST 方法请求的方法
        52.  
          public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        53.  
          doGet(request, response);
        54.  
          }
        55.  
          }

        由于请求方式是GET,因此需要doGet()方法来处理。仔细阅读doGet()方法的代码,发现处理逻辑只是把表单数据放入到了一段html代码中。这段html代码会被传输给浏览器,然后浏览器渲染出结果,如下图所示:

         

        image.png

        Servlet的特点

        Servlet相对于CGI有了很大的改进,效率更高,功能更强大,更容易移植。主要表现在一下几个方面:

        • CGI每个请求启动一个进程,而Servlet是更轻量的线程。线程和进程的对比和优劣请自行Google。
        • CGI每个进程都需要初始化,Servlet只初始化一次实例就行
        • Servlet依托于Java语言,具有很好的跨平台型。CGI根据语言的不同,跨平台型不同
        • CGI与数据库连接需要重连,Servlet可以使用数据库连接池。
        • Java有丰富的、各种各样的库函数

        Servlet的缺点

        看上面的代码,会发现,html代码是写在Java代码中的。对于前端人员来说,这种形式非常非常难以开发和修改。

        Servlet的升级 -- JSP

        Servlet是在Java代码中写HTML代码。与之对应的就是在HTML代码中写Java代码,这就是JSP。

        JSP是啥?

        JSP:JavaServer Pages 简单点说,就是可以在html中写Java代码。

        还是先从例子中大概了解下JSP:

        还是上面表单处理的例子。表单的html代码就不展示了,我们直接模拟GET请求,即在浏览器中输入地址:http://localhost:8080/testjsp/main.jsp?name=菜鸟教程&url=http://www.runoob.com

        很明显,这个URL的关键是main.jsp。这个文件的内容是啥呢? main.jsp

        
        
        1.  
          <%@ page language="java" contentType="text/html; charset=UTF-8"
        2.  
          pageEncoding="UTF-8"%>
        3.  
          <%@ page import="java.io.*,java.util.*" %>
        4.  
          <!DOCTYPE html>
        5.  
          <html>
        6.  
          <head>
        7.  
          <meta charset="utf-8">
        8.  
          <title>菜鸟教程(runoob.com)</title>
        9.  
          </head>
        10.  
          <body>
        11.  
          <h1>使用 GET 方法读取数据</h1>
        12.  
          <ul>
        13.  
          <li><p><b>站点名:</b>
        14.  
          <%= request.getParameter("name")%>
        15.  
          </p></li>
        16.  
          <li><p><b>网址:</b>
        17.  
          <%= request.getParameter("url")%>
        18.  
          </p></li>
        19.  
          </ul>
        20.  
          </body>
        21.  
          </html>

        这就是JSP,在html代码中插入Java代码。java代码被<% %>所包围。 <%= request.getParameter("name")%>表示获取请求参数name的值,<%= request.getParameter("url")%>表示获取请求参数url的值。最终展示结果是怎样的呢?看下图:

         

        image.png

        JSP是如何工作的?

        为啥html代码中可以写Java代码呢?看下图:

         

        image.png

        其实原理是这样的:

        就像其他普通的网页一样,您的浏览器发送一个HTTP请求给服务器。

        Web服务器识别出这是一个对JSP网页的请求,并且将该请求传递给JSP引擎。通过使用URL或者.jsp文件来完成。

        JSP引擎从磁盘中载入JSP文件,然后将它们转化为servlet。这种转化只是简单地将所有模板文本改用println()语句,并且将所有的JSP元素转化成Java代码。

        JSP引擎将servlet编译成可执行类,并且将原始请求传递给servlet引擎。

        Web服务器的某组件将会调用servlet引擎,然后载入并执行servlet类。在执行过程中,servlet产生HTML格式的输出并将其内嵌于HTTP response中上交给Web服务器。

        Web服务器以静态HTML网页的形式将HTTP response返回到您的浏览器中。

        最终,Web浏览器处理HTTP response中动态产生的HTML网页,就好像在处理静态网页一样。

        用一句话来讲:每个JSP都最终会变成对应的Servlet执行

        JSP的缺点

        在HTML代码中写Java代码,方便了前端人员,但是苦了后端人员。因此,单纯使用JSP,开发效率依旧不高。

        后来,有牛人发现,Servlet天生非常适合逻辑处理(因为主要是Java代码),而JSP非常适合页面展示(因为主要是html代码),那么在结合Servlet和JSP各自的优缺点后,诞生了Web开发中最常用和最重要的架构设计模式:MVC

        发展期 - MVC时代

        MVC模式(Model-View-Controller)是软件工程中的一种软件架构模式,把软件系统分为三个基本部分:模型(Model)、视图(View)和控制器(Controller):

        • Controller——负责转发请求,对请求进行处理
        • View——负责界面显示
        • Model——业务功能编写(例如算法实现)、数据库设计以及数据存取操作实现

         

        image.png

        简而言之,请求发来后,会首先经过Controller层处理,需要返回的结果封装成对象传递给JSP,然后JSP负责取出数据展示就够了。这样,后端开发人员只负责编写Servlet,前端人员负责JSP,极大提升了开发效率。

        
        
        1.  
          @WebServlet("/userPosts")
        2.  
          public class UserPostController extends HttpServlet {
        3.  
           
        4.  
          private static final long serialVersionUID = -4208401453412759851L;
        5.  
           
        6.  
          @Override
        7.  
          protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        8.  
          String username = req.getParameter("username");
        9.  
          User user = Data.getByUsername(username);
        10.  
          List<Post> posts = Data.getPostByUser(user);
        11.  
           
        12.  
          req.setAttribute("posts", posts);
        13.  
          req.setAttribute("user", user);
        14.  
          RequestDispatcher dispatcher = req.getRequestDispatcher("/templates/userPost.jsp");
        15.  
          dispatcher.forward(req, resp);
        16.  
          }
        17.  
          }

        像上面这段代码,UserPostController就是一个Servlet,负责逻辑处理。需要返回的数据封装到HttpServletRequest对象中,传递给jsp页面。而负责展示的就是/templates/userPost.jsp这个jsp文件。

        繁盛期 - 框架时代

        有了Servlet和JSP,相当于有了武器。有了MVC,相当于有了战术。但是武器和战术之间还缺少一层,就是具体实施者。

        实践证明,单纯使用Servlet、JSP和MVC开发,依然会面临诸多的问题。而程序员普遍存在一种特质,就是懒。因为懒,所以才想着能有更简单的解决办法。因为懒,针对一些通用问题,才会想出通用解决方法。可以说,因为懒,科技才有了进步。。。这时候,为了解放劳动力,一些开源框架营运而出。这些框架的目的只有一个:让开发简单,简单,更简单

        提到Java Web框架,就不得不提几乎所有开发者都知道的三大框架:SSH

        SSH

        关于三大框架,这里不做介绍了,网上的文章铺天盖地。想要说的是:无论什么框架,都是对常见问题的抽象和封装,再出什么新的框架,也万变不离其宗,脱离不了Servlet这个根基。学习的时候千万不能跟着框架走,框架让做什么就做什么,而是要想为什么这样做。否则,今天学会了一个框架,明天又出了新的框架,又会抓瞎了。

        Servlet 的确已经能够帮我们完成所有的工作了,但是现在的 web 应用很少有直接将交互全部页面都用 servlet 来实现,而是采用更加高效的 MVC 框架来实现。这些 MVC 框架基本的原理都是将所有的请求都映射到一个 Servlet,然后去实现 service 方法,这个方法也就是 MVC 框架的入口。

        <small id='tuftg51c'></small><noframes id='fhqgs12v'>

        <tfoot id='soo7debq'></tfoot>

          <legend id='zvdc1m40'><style id='50w6wacj'><dir id='2r8p0gm9'><q id='hxxonqgl'></q></dir></style></legend>
          <i id='gi3omxhq'><tr id='onq9c0zl'><dt id='do3bv3dx'><q id='w14iqccu'><span id='ioupc5sd'><b id='657vw6o4'><form id='c2z42q5v'><ins id='92pe2sdc'></ins><ul id='dqysd81n'></ul><sub id='vqn8pek8'></sub></form><legend id='u37lub5n'></legend><bdo id='pgls3tlm'><pre id='yt6qsze0'><center id='h39z5slw'></center></pre></bdo></b><th id='q9b43yfc'></th></span></q></dt></tr></i><div id='k5z65cpf'><tfoot id='45s0qb8t'></tfoot><dl id='d79rdk2b'><fieldset id='egch3k8o'></fieldset></dl></div>

                <tbody id='i8yqui07'></tbody>

              本文来源于网络,若有侵权请联系3449817223#qq.com,将在第一时间删除。

              上一篇:JavaWeb开发介绍 小程序开发上一篇
              下一篇公众号开发下一篇:java web的发展历史
              <legend id='1f8gol30'><style id='9yklu2p6'><dir id='3jdijeoa'><q id='b03v3i0i'></q></dir></style></legend><tfoot id='31oci8po'></tfoot>
                <tbody id='8j3jnlgc'></tbody>

              <small id='m1nrc39w'></small><noframes id='iieadi1u'>

                  <i id='l640rkpq'><tr id='a5wpds4w'><dt id='r1h7kghz'><q id='8bf5c4vz'><span id='a9hxb98n'><b id='80k458ro'><form id='btg0vpmi'><ins id='xz056e5f'></ins><ul id='znhaz4gv'></ul><sub id='y6r6r0qv'></sub></form><legend id='pvx7eule'></legend><bdo id='31o9lest'><pre id='hxcrjufz'><center id='geihuu4h'></center></pre></bdo></b><th id='l5kfugy1'></th></span></q></dt></tr></i><div id='o051o4l4'><tfoot id='o2jys93d'></tfoot><dl id='8txw9ngb'><fieldset id='50aigavc'></fieldset></dl></div>