同学们，今天我们正式学习了JavaWeb后台程序，大家要分清前台、后台、数据库这样一种关系。

今日需要掌握的有：

• 了解HTTP协议，几种常见的状态码一定要熟知
• 从前台表单提交数据到后台Servlet，Servlet对请求的数据进行处理，再将结果响应给前台。这个过程的具体操作一定要熟知！
  

请同学们按照如上要求，总结今日所学。

王刘锁
今天是学的最艰难的一天了,上午被那个STS配置Tomcat给搞的头大也没弄好,还是中午牺牲午休时间给解决的,然后下午上课就有点犯困走神,这下下午的知识又没听懂,晚上去写案例一行代码都敲不出来!又浪费时间重新看了一遍视频,感觉亏了一个亿一样!代码勉勉强强敲了一遍,记录一下对今天知识的理解.
先说HTTP协议,用来规范浏览器和服务器的数据传递,特点是有请求必有响应,这么见名知意的名词不用多解释了.
现在使用的是1.1版本不会一次响应就断开一次它会在等待一段时间没有请求的时候断开连接!
再说协议的结构;请求部分有
1.请求行(提交方式--post和get的区别也很简单不多说, 提交路径 协议版本),
2.请求头(key:value的格式,一个key对应一个或多个value,我们要记住几个User-Agent--浏览器类型
,Referer--网页来源,If-Modified-Since--查找本地缓存),
3.请求体(post的提交方式才有).
响应部分我们要记:
1,响应行:协议版本 状态码(200-成功,302-重定向,304-查找本地缓存,404-资源不存在,500-服务器错误
这些能理解就理解不能理解就记住,见得多了就知道了,)  状态码描述
2,响应头(key:value格式一对一或对多):Last-Modified查找本地缓存和请求的那个一块使用.
Content=Dispostion--下载文件用的头信息,Location--重定向的跳转路径,Refresh--定时跳转或刷新.
下面是两个案例:
一,页面提交跳转;
网址栏内输入localhost:8080/web_01(项目名)/index.html,在html文件中编写代码一个提交表单,
表单的提交路径action属性赋值另外一个index2html的文件名当然两个文件在同一级,这样在提交的
时候就会跳转到index2.html页面上,我在写着个案例的时候就是不知道怎么样跳转,差点去设置一个提
交事件,没认真听课的下场.
二,获取登录界面提交的信息并打印控制台,向注册添加信息到数据库和登录验证信息属实这样的案例还
没有涉及,目前只能打印到控制台这么low的方式了!其实原理还是跳转,不过就是把路径改成/web_01/ServletDemo
也就是/表名/访问Servlet实现类的那种方式,说到这里就必须说一下Servlet是什么,它是一个Java小程序用来
接收客户端的请求信息并响应,那就可以知道它是运行在服务器上的了,它其实是一种动态页面开发技术,那我们使用它其实就是编写一个类去实现它,然后把这个类配置到服务器中,配置需要去web.xml文件中编写代码,代码的格式和原理也不多说了,
接下来我们要向获得数据就需要知道几个方法:用ServletRequest中的方法,这几个方法参数都是要获得的数据的name值.
String getParameter(String name);接收一个值文本框,单选框..
String[] getParameterValues(String name);接收多个值.多选框..
Map getParameterMap(); 接收所有的数据,key是数据对应的参数名,value是值
就记得这么多了,可能有一些小的知识点没听到或没记住,

陈强
TomCat和Servlet的一天.
首先是通过TomCat去发布一个web项目.我们采用的是直接将项目复制到TomCat安装目录下的webapps路径下即可,然后根据localhost:端口号/项目名/HTML文件即可.发布一个项目的前提是,要在eclipse中去集成TomCat,只有集成成功后,服务器可以正常启动了,该在webapps目录下的项目才可以发布成功.
第二部是servlet的请求与响应.使用Servlet的基本步骤就是第一,编写一个类去实现Servlet接口,第二是将编写的这个类配置到服务器中即可.这里要注意导入Servlet包,并添加源代码的步骤.
首先在编写类的部分,实现Servlet接口的时候重写里面全部的方法,而我们要使用到的是service方法,在方法里面在根据是请求还是响应,去进行响应方法的调用.
然后配置方面,主要是根据以下的格式进行编写.
  <servlet>
           <servlet-name>xxxxx</servlet-name>
          <!-- SErvlet的全路径 -->
          <servlet-class>类对应的CLASS路径</servlet-class>
  </servlet>
  <servlet-mapping>
          <servlet-name>xxxxx</servlet-name>
          <!-- Servlet的访问路径 -->
          <url-pattern>/xxxxx</url-pattern>
  </servlet-mapping>
这里编写的过程中要注意, <url-pattern>标签中最前面的/千万不能少,否则报错!!!
做了一个简单的响应的测试,就是在service中通过getWriter方法去输出一个语句,然后将该类配置到服务器中,配置完成后去访问<url-pattern>中的内容.
总结一下这个过程就是服务器通过<url-pattern>标签去找<servlet-mapping>标签中的<servlet-name>,然后该标签再去找到<servlet>标签中的<servlet-name>,最后在找到<servlet>中的<servlet-class>,这样子就找到了对应的类,然后将内容响应.
表单请求部分,其实都是一个道理.创建一个表单的HTML,表单的action提交路径应为项目路径/<url-pattern>的值,method我们一般设置为post,然后创建一个类去实现Servlet接口,在service方法中去获取表单中的一些信息.使用到的是paremeter等一系列的方法.都配置成功之后,就可以运行Tomcat服务器,然后去表单的HTML填写表单内的信息提交,服务器就会收到表单的请求信息了.
整个流程就是<form action="/项目名/url标签" method="post">------<url-pattern>----<servlet-mapping>中的<servlet-name>----<servlet>中的<servlet-name>----<servlet-class>-----java文件
获取整个表单信息的MAP集合方法还没敲,先把总结交了再好好敲~~~

吴利君
今天学习了tmocat和简单的Servlet，可以进行简单的前后端交互，可以做一个简单的网页，可以说，今天是web学习的开始，今后编程都是这样，通过前端传递数据，然后后端进行数据接收，处理，然后交给前端进行显示给用户，中间如果你要实现特殊功能只要相应功能的工具类，jar包，然后进行代码实现就行。
首先，今天讲了HTTP这个协议，这个是一个很强大的数据传输协议，目前很多网站都是使用它进行数据传输，不过HTTP也存在安全问题，所以有它衍生的HTTPS会更加安全，HTTPS是进行SSL加密的HTTP，服务器通过数字证书进行身份认证，然后进行数据传输，很安全。
HTTP抓包有两种，get和post它最大的区别就是数据传输规则，一个是在响应行，一个是在响应体，然后是get传输有大小限制，毕竟get是通过响应行传输数据的。还有的时候它们解决乱码的方式也不一样，个人推荐是用post，安全，而且看着舒服。
HTTP的状态码有404,302,304等等，很强大，通过这个可以很清晰的知道自己的错误的大致情况，debug的时候很方便。
然后是Servlet，它是运行在服务器上面的小程序，主要用于接收浏览器传来的数据，然后给后台进行数据处理，然后在把数据放进request域或者session域等等，这样前端就获取数据进行显示。
它的使用也很简单，主要是前端路径写Servlet的xml里面的url然后通过servlet-class就能找到对应的Servlet，这样就Servlet就拿到数据，然后就可以在service层处理，然后dao层与数据库交互，这样就完成了特定功能，然后返回显示给前端。

常小天
今天开始正式学习web阶段的重点内容。今天的学习内容是使用Tomcat发布工程以及编写servlet程序接收浏览器请求并做出响应。
使用Eclipse新建服务器，并将新建的工程添加进Tomcat服务器的操作这里就不说了，按部就班的来就可以，没啥好说的。这里重点说一说servlet的编写。Servlet是运行在服务器上的java程序。功能是接收客户端的请求并作出响应，遵循的是HTTP协议。HTTP规范了网络上客户端与服务器之间数据传输的格式，这使得现在网络上多种服务器多种客户端都能够顺利传输数据得以实现。要使用servlet，首先要编写一个java类实现Servlet接口，重写Service方法。Service方法要传入两个参数，ServletRequest和ServletResponse。前者将请求封装成了对象，有相应的方法去获得从客户端传入的数据；后者能将响应封装成对象，有相应的方法向客户端输出数据。具体的方法可查API。接下来的步骤同样很关键。我们要将写好的java类配置到我们的服务器中。配置的方法是在工程的web-INF目录下的web.xml文件中编写<servlet>标签和<servlet-mapping>标签，前者将我们写好的java类的类名与一个<servlet name>联系起来，后者将一个我们自行编写的虚拟路径与<servlet name>联系起来，前后两个<servlet name>的内容一致，以此将虚拟路径与java类连接起来，使得客户端可以通过虚拟路径调用java类程序。在此基础上，我们进一步将HTML页面也连接进来。在HTML文件中的表单提交路径中写入配置文件中的虚拟路径，便可以实现登录、注册等操作。

一、Tomcat
1.使用Tomcat7.0：在8.0以后的版本，对编码作了优化，较少出现乱码问题。使用7.0是为了学习如何处理乱码问题。
2.解压即可使用。首先要设置环境变量JAVA_HOME.不然会出现Tomcat启动一闪而过，导致开启失败。
startup.bat:启动服务器
shutdown.bat:停止服务器
3.Tomcat载入Eclipse开发环境:
  Windows->Prepferences->Server->Runtime Environments
  显示Tomcat窗口栏:Window->showView->Servers;
4.项目加入Tomcat。Servers窗口中，对Tomcat7.0右键->add and remove...
当运行tomcat出现错误时，先移除项目，再运行。如果还是有错，是tomcat的错误。没有错，是项目的错误
5.tomcat解决乱码方式:
1)请求乱码:
  post请求:request.setCharacterEncoding("utf-8");
2)响应乱码：
  response.setContentType("text/html;charset=utf-8");
6.端口冲突问题:
1)将占用端口的应用结束:
  cmd->netstat -ano 查看进程所使用的端口
2)修改自身应用的端口号:
  修改tomcat/conf/server.xml中的端口号


HTTP协议:
1.协议规定了不同浏览器和不同软件服务器统一所要遵循的规则，规范浏览器和服务器之间的数据传递。
2.每次请求必须要得到回应，请求错误也会回应。1.1版本的协议增加了请求超时会挂断协议。
3.HTTP协议的内容形式:
1)使用高级浏览器(Goole,FireFox)抓包:
FireFox，按F12->网络选项卡->跳转到新的页面，会显示请求的协议;
2)协议内容:
(1)GET方式:
请求行:请求方式 请求路径 协议版本
请求头:请求头一般都是key.value键值对的形式，一般情况下一个key对应一个value.也有一些是一个key对应多个value
(2)POST方式:多了一个请求体

(3)响应部分:

响应头:键值对，一般一个key对应一个value,也有一个key对应多个value;
*Last-Modefied: 与请求中的IF-Modified-Since 一起使用查找本地缓存。
*Content-Dispistion:文件下载的使用的一个头信息
*Location          :重定向的跳转的路径
*Refresh           :定时刷新/定时跳转
*响应体:显示到浏览器页面的内容


Servlet部分:
1.概念理解:
Servlet只是一个运行在WEB服务器上的小的java程序，用来接收和响应从客户端发过来的请求，通常使用HTTP协议。
2.在web方面使用Servlet的具体步骤:
1).新建一个普通java类，实现Servlet接口，载入所有接口方法。把server()方法放到前面。
2).新建一个Servlet，良好的习惯是先到web.xml中配置servlet。理解一下web.xml运行原理就知道怎么配置了:
web.xml是web项目的核心配置。一旦写错，项目就无法运行。web.xml作为前端和后台服务器的中间件。或者说,作为form表单与Servlet联系的中间件。
当一个form表单做出提交的请求后，首先是转发到web.xml中，通过表单的action里面提供的servlet虚拟路径名,与<servlet-mapping>标签的设置的虚拟路径匹配，然后找到servlet-name相同的
得到servlet的路径。进而再把表单交给servlet处理。
因此，配置方式如下:
(1)在<web-app></web-app>之间加入<servlet ></servlet>和映射标签<servlet-mapping></servlet-mapping>。注意，两个是并列关系，不是包含
(2)在<servlet-mapping>标签中，添加两个标签:
<servlet-name>mytest</servlet-name>:名字随便取，但是要和<servlet>标签中的<servlet-name>标签名字一样。
<url-pattern>/aa</url-parttern>:虚拟路径名，随便取，但是要和前端form表单的action里面设置的虚拟路径名一样。
(3)在<servlet ></servlet>标签中。设置两个值
<servlet-name>mytest</servlet-name>:与<servlet-mapping>标签中的<servlet-name>名字一样。
<servlet-class>Servlet类所在的包路径名
(4)form表单中action属性写虚拟路径名的两个写法:
绝对路径名:/day0531/aa
相对路径名:aa
这两个写法都可以，推荐用绝对路径名。
3.request获取请求参数的常用方法：
注意，返回的都是String类型的数据,string->int:Integer.parseToInt()
String getParameter(String name):通过表单名字获取参数
String[] getParameterValues(String name); 通过表单名字获取多个值:比如下拉框，多选框
Map<String,String> getParameterMap():以【name:value】的键值对应封装在map集合。
Enumeration getParamterNames();用于获取所有的表单组件名字。

林文辉
一个请求必定有一个响应
请求部分：
Get和Post提交方式的区别：
1.Get会在地址栏显示提交的参数，而POST不会
2.GET提交的数据有大小限制，POST没有大小限制。
3.超链接只有get,没有post
4.表单可以使用post和get。表单一般都是使用post方式提交
5.get没有请求体
请求头：

User-Agen:浏览器类型。不同浏览器下载文件使用的编码方式不一样，可以通过这个针对不同
的浏览器使用不同的编码转换。

Referer:网页来源

If-Modified-Since: 与Last-Modified 查找本地缓存
响应部分：
状态码：
200 响应成功
302 重定向
304 查找本地缓存
404 访问资源不存在
500 服务器内部错误。
响应头：
Last-Modified :与If-Modified-Since一起查找本地缓存
Content-Dispostion        :文件下载的使用使用的一个头信息.
Location:重定向的跳转的路径.
Refresh:定时刷新/定时跳转.
Servlet:
1.运行在Tomcat上的一个java程序
2.getParameter() 获取参数，String类型
   getParametersValue()，返回一个String类型数组
   getParameterMap(),返回一个Map集合，获取表单中的所有数据，key为name。

侯玉林
今天主要学习了,tomcat服务器的部署,http协议的意义,以及如何通过servlet技术实现动态操作页面.

许剑鸿 WebDay13


TOMCAT:Apache组织研发,免费的小型的服务器软件,支持Servlet/JSP的开发规范.
Tomcat的目录结构:
        *** bin                :tomcat的执行的文件.
        * conf                :tomcat的配置文件.
        *** lib                :tomcat运行的需要的jar包.
        *** logs                :tomcat的运行的日志文件.
        * temp                :tomcat产生临时文件存放的路径.
        *** webapps        :tomcat发布的web项目的路径.
        * work                :tomcat运行JSP的时候,JSP翻译成Servlet的代码存放的路径
发布web项目到tomcat中:
        直接copy项目到webapps下/在server.xml中配置虚拟路径/配置tomcat的虚拟路径
        *一般由开发软件直接发布web项目


HTTP:超文本传输协议（HTTP，HyperText Transfer Protocol) 作用:规定浏览器和服务器的数据交互的格式.
HTTP协议的特点是基于请求和响应的模型(请求和响应成对出现)
请求分为GET POST :
            * GET的提交的参数会显示到地址栏上,而POST不显示.
            * GET往往是有大小限制的,而POST没有大小的限制.
            * GET没有请求体,而POST有请求体.


Servlet:就是一个运行在WEB服务器上的小的Java程序,用来接收和响应从客户端发送过来的请求,通常使用HTTP协议.
        用来处理从客户端浏览器发送的请求,并且可以对请求作出响应

编写一个Servlet:1,编写一个类实现Servlet接口
                public class ServletDemo1 implements Servlet{
                        @Override
                        public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
                                res.getWriter().println("Hello Servlet...");
                                String   req.getParameter(标签名);
                                String[]   req.getParameterValues(标签名);
                                Map<String,String[]>   req.getParameterMap();
                        }
                        ...
                }
                 2,将编写的类配置到服务器中(web.xml)
                          <!-- 配置Servlet -->
                  <servlet>
                          <servlet-name>test1</servlet-name>
                          <servlet-class>com.itheima.a_servlet.ServletDemo1</servlet-class>
                  </servlet>
  
                  <servlet-mapping>
                          <servlet-name>test1</servlet-name>
                          <url-pattern>/ServletDemo1</url-pattern>
                </servlet-mapping>

柯威龙
今天学习了WEB服务器.他的一个定义的话就是在硬件上需要一太配置很高的电脑.软件上就是需要在
电脑上安装一个服务器的的软件.这样的额一台电脑称之为WEB服务器
Servlet是一个类Tomcat是一个服务器.相当于Tomcat是一个容器的话,Servlet属于这个容器里面的.
Servlet是一个运行在服务器上面的一个小的java程序.是用来接收和响应从服务器到客户端,客户端到
服务器的.Servlet的请求和响应是因为其中有一个http的协议.用来规范服务器和客户端之间传输数据
当要用java制作一个Servlet的时候,需要在普通类上去实现Servlet.然后去配置文件.
Tomacat服务器的话分为两种架构.分为cs和bs.cs的话都是需要在PC端安装下载的.BS的话只需要浏览器
就可以打开了.

Tomcat:(服务器)
        安装与配置环境,以及常见的错误等;
        如何将Tomcat添加到eclipse中;
       
       
HTTP协议:
        get和post差别;大小限制,响应体,
        常见的请求头:user-Agent:浏览器类型;Referer:防盗链;If-modified-Since查找本地缓存
        常见的响应头:Last-Modified查找本地缓存;Content-Dispostion:文件下载;Location重定向;Refresh:定时刷新跳转;
        常见的状态码:200成功;302重定向;304查找本地缓存;404访问资源不存在;500服务器内部错误;
       
Servlet:运行在WEB服务器上的小的Java程序,用来接收和响应从客户端发送过来的请求,通常使用HTTP协议.
        使用步骤:   1,编写一个java类实现Servlet接口.将servlet方法重写,
                                2,ServletRequest调用setCharacterEncoding方法将编码格式缓存UTF-8
                                3,调用getParameter,getParameterValues,getParameterMap等方法获取用户输入的值
                                4,将web.xml配置文件要写入:  <servlet>
                                                                                                <servlet-name>任意名称</servlet-name>
                                                                                                <servlet-class>com.itheima.Demo01.ServletDemo01(java的class的全名)</servlet-class>
                                                                                        </servlet>
                                                                                        <servlet-mapping>
                                                                                                <servlet-name>任意名称(两个name要一样)</servlet-name>
                                                                                                <url-pattern>/postt(任意取名,前面要加/)</url-pattern>
                                                                                        </servlet-mapping>
                                5,将HTML文件中的表格中的action="/项目名/与web.xml的<url-pattern>一致"
                                6,将编写的这个类配置到服务器中.

颜琳琳
今天主要学习了Tomcat服务器只需会安装即可.
接着学了HTTP协议:该协议主要掌握其中的状态码:200:响应成功; 302:重定向; 304:查找本地缓存; 404:找不到资源; 500:服务器内部错误
Servlet:是一种运行在WEB服务器上的一种Java的小程序.使用的步骤: 1.创建一个java类来实现Servlet接口; 2.在web.html中配置Servlet标签.
<!-- 配置Servlet -->
  <servlet>
                    <servlet-name>  <!-- Servlet的名称 -->  </servlet-name>
          <servlet-class>          <!-- SErvlet的全路径 -->   </servlet-class>
  </servlet>
  <!-- Servlet的映射 -->
  <servlet-mapping>
                    <servlet-name>   <!-- Servlet的名称 -->   </servlet-name>
                    <url-pattern>   <!-- Servlet的访问路径 -->   </url-pattern>
  </servlet-mapping>
从前台表单提交数据到后台Servlet,Servlet对请求的数据进行处理其中处理的方法有:
String getParameter(String name);用于接收一个名称对应一个值的数据;
String[] getParameterValues(String name);用于接收一个名称对应多个值的数据.
Map getParameterMap();        用于接收表单中的所有的数据,Map的key是表单提交的参数名称,Map的value是提交参数的值;然后再将结果响应给前台.

万冕


TomCat 是apache组织的开源小型免费服务器,能让别人通过本机IP来访问上传的网页

今天才知道我们的Java是写B/S的,不需要安装,只需要一个浏览器,就可以操作非常的方便,更新只需要通过服务器里更新,
客户端浏览器都不需要更新.

HTTP是超文本传输协议,请求和响应是成对出现的,且必须先有请求后有响应

请求的方式主要由GET和POST两种方式,GET的数据就出现在地址行里,且GET没有请求体,POST的数据在请求体里,且POST没有
大小限制,还有一些常见的错误,200(响应成功) 302(重定向) 304(读取本地缓存) 404(资源不存在/路径错误) 500(服务器内部错误/代码出错)


今天被请求数据卡了一下,请求数据就是前端已经将数据封装进了ServletRequest req对象里了,然后我们通过req.getParameter
方法获取里面的数据getParameter(单一值) getParameterValues(多个值) getParameterMap(获取所有数据);

苏海斌
http协议
请求and响应
请求部分分为请求行请求头请求体
响应部分也是

请求行提交方式常用的GET和POST;
两者的区别是
1.GET的提交的参数会显示到地址栏,而POST不显示
2.GET往往有大小限制,POST没有
3.GET没有请求体而POST有请求体
请求头:(小重点)
User-Agent         :代表浏览器的类型---文件下载:下载中文文件:IE使用URLEncodor进行编码,而Firefox使用Base64编码
Referer            :代表的是网页的来源---防盗链
If-Modified-Since  :通常与响应中的头Last-Modified一起使用查找本地缓存

响应部分
响应行的状态码:
200 成功
302 重定向
304 查找本地缓存
404 找不到资源
500 服务器内部错误
响应头
Last-Modified      :与全球中的If-Modified-Since一起使用查找本地缓存
Content-Dispostion :文件下载的使用的一个头信息
Location           :重定向的跳转的路径
Refresh            :定时刷新/跳转


Servlet:是运行在web服务器上的一个小的Java程序
使用方法:
1.创建一个Java类实现Servlet接口
2.配置

吴鹏

总结
--------------------------------------

协议:用来规定双方的责任和义务,需要遵守的规则;
http协议:用来规定浏览器与服务器之间()数据的传递需要遵守的规则;

特点:基于请求和相应的模型;必须得先有请求,然后再有相应;请求和相应必须成对出现;
默认端口号为80;
协议版本:
1.0 :每次相应后即刻关闭了链接;
1.1 :每次响应后不会立即关闭,当等待超过设定时间后才关闭,现在使用该版本协议;

http协议的详解:
抓包分析:GET方式：
* 请求部分:
GET /day09/demo1-http/demo2.html?name=aaa&age=23 HTTP/1.1   请求行:请求方式   请求路径   协议版本
Accept: text/html, application/xhtml+xml, */*
X-HttpWatch-RID: 59176-10011
Referer: http://localhost:8080/day09/demo1-http/demo1.html
Accept-Language: zh-CN
User-Agent: Mozilla/5.0 (Windows NT 6.3; WOW64; Trident/7.0; rv:11.0) like Gecko
Accept-Encoding: gzip, deflate
Host: localhost:8080
DNT: 1
Connection: Keep-Alive

抓包分析:POST方式：
POST /day09/demo1-http/demo2.html HTTP/1.1   请求行:请求方式   请求路径   协议版本
Accept: text/html, application/xhtml+xml, */*
X-HttpWatch-RID: 59176-10031
Referer: http://localhost:8080/day09/demo1-http/demo1.html
Accept-Language: zh-CN
User-Agent: Mozilla/5.0 (Windows NT 6.3; WOW64; Trident/7.0; rv:11.0) like Gecko
Content-Type: application/x-www-form-urlencoded
Accept-Encoding: gzip, deflate
Host: localhost:8080
Content-Length: 15
DNT: 1
Connection: Keep-Alive
Cache-Control: no-cache

name=bbb&age=38

* 响应部分:
HTTP/1.1 200 OK
Server: Apache-Coyote/1.1
Accept-Ranges: bytes
ETag: W/"145-1461807615933"
Last-Modified: Thu, 28 Apr 2016 01:40:15 GMT
Content-Type: text/html
Content-Length: 145
Date: Thu, 28 Apr 2016 01:43:52 GMT

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>Demo2.html</h1>
</body>
</html>


请求部分:

请求行:请求方式   请求路径   协议版本
请求头:一般都是key:value键值对的形式,一般情况下一个key对应一个一个value,也有一些事一个k对多个v;
请求体:只有POST方法才有请求体;

请求头
    都是键值对的形式现实的,一般一个k对应一个v,也有一个k对应多个v;
    user-Agent:代表浏览器的类型 --- 个别浏览器在处理某些代码时有区别,比如下载文件,IE使用URLEncoder进行编码,火狐使用Base64;
    Referer:记录当前页面的来源---防盗链;
    If-Modified-Since:通常与响应中的头Last-Modified一起查找本地缓存;
请求行
    提交方式:提交方式有很多,常用的GET,POST
    GET    提交的参数会显示到地址栏,POST不会,没有请求体;
    POST    提交的大小没有限制,GET有限制;
    提交路径:
    协议版本:

请求体:
    POST提交方式的提交的参数;

相应部分:

响应行:
    协议版本  状态码  状态码的描述
    状态码: 200   成功;
               302   重定向;
               304   查找本地缓存;
               404   访问资源不存在;
               500   服务器内部错误;

响应头:
    都是键值对的形式现实的,一般一个k对应一个v,也有一个k对应多个v;
    Last-Modified:与请求中的If-Modified-Since一起查找本地缓存;
    Content-Dispostion:文件下载时候使用的一个头信息;
    Location:重定向的一个跳转路径;
    Referesh:定时刷新/定时跳转;
空行

响应体:
    响应的页面内容的代码;
-------------------------------------------------

1 前台表单提交数据到后台Servlet
<form action="/self/ServletDemo2" method="post">
        姓名:<input type="text" name="name"><br />
        年龄:<input type="text" name="age"><br />
            <input type="submit"  value="提交"/><br>
    </form>
上述代码为前端HTML表单的部分代码,其中为了实现表单数据提交的时候提交到我们所实现Servlet后重写方法的类,
action后面要填入该类的路径,并且不是全部的路径,而是/项目名称/实现类名称;这样,在我们填写完信息后,点击提交的时候,
数据才会传入实现后的类;


Servlet对请求的数据进行处理
首先,我们要先在实现类中接收传过来的数据,然后才能处理数据,处理数据的为服务器端,传入数据的为客户端,在这里的数据传输属于请求,因此,
我们获取数据就要使用req的方法,其中,我们常用的方法为 String req.getParameter(String name),如果是复选框的话,
使用String[] req.getParameterValues(String[] name);形如:
String name = req.getParameter("name");
int age  = Integer.parseInt(req.getParameter("age"));
要注意的是,传输的数据都是属于String类型,为了向上面代码里那样获得int类型的数据的话,要使用Integer.parseInt()方法;


我们还可以使用Map<String,String[]> map = req.getParameterMap();
这样会将前端代码中,name的值放进key,value的值放进value里,




将结果响应给前台
获得数值后,我们可以对其进行操作,在这边我就将其打印到前端,打印到前端属于服务器响应,因此我们可以使用
res.getWriter().println(String name)方法,将得到的数据打印到前端页面;代码实现:
        res.getWriter().println(name);
        res.getWriter().println(age);

郭明杰:

1 [软件架构]:主要分为C/S架构跟B/S架构,cs架构需要服务器跟客户端的支持,
优点是效果好速度快但是服务器端更新的话,客户端也要更新才能使用,bs架构则反之

2 [WEB的资源]:分为静态资源(HTML,CSS,JS...) 跟  动态资源(PHP,ASP,Servlet,JSP...)

3 [服务器]:在一台配置很高的电脑上安装服务器软件,这台电脑就成为是WEB服务器
4 发布一个WEB工程到Tomcat 有三种方法 我们主要用的方法就是把工程拷贝到webapps下
5 [HTTP]Http协议的作用是规范浏览器跟服务器之间的数据传递
        5.1 数据传输:从浏览器发送到服务器(请求) ; 从服务器发送到浏览器(响应);
        5.2 请求:一次请求必定有一次响应,
                请求体: 就是post提交方式提交的参数,get方式提交没有请求体!!
        5.3 响应: *响应行:(200 响应成功)(404 资源不存在)(302 重定向)(304 查找本地缓存)(500 服务器内部错误)       
                      *响应头：键值对，一般一个key对应一个value,也有一个key对应多个value的
                                                Last-Modified:与请求中的If-Modified-Since一次使用查找本地缓存
                                                Content-Dispostion:文件下载的时候使用的一个头信息
                                                Location: 重定向的跳转路径
                                                Refresh: 定时刷新/定时跳转
       
6 [Servlet]: 就是一个运行在WEB服务器上的小程序,用来接收和响应从客户端发送过来的请求,通常使用HTTP协议.
        6.1 使用方法:1 写一个普通的javac类,实现servlet接口 2 去WEB-INF/web.xml中 配置我们这个servlet
       
7 [使用SercletRequest接收参数]
String getParameter(String name) ----用于接收一个名称对应一个值的数据
String[] getParameterValues(String name) :---用于金额手一个名称对应多个值的数
据
* Map getParameterMap();---用于接收表单中的所有的数据,Map的key是表单提交的参数
名称,Map的value是提交参数的值.
* Enumeration getParameterNames()---用于获取表单中提交的所有的参数的名称.

8 [解决Post提交中文乱码解决方式]:
请求乱码解决 :
get请求: String str = new String(request.getParameter("name").getBetys
("ISO-8859-1"),"UTF-8");
post:请求    request.setCharacterEncoding("utf-8");
响应乱码:        response.setContentType("text/html;charset=utf-8");

张育辉
Tomxat总结
        一:目录结构
          bin    tomcat的执行文件;
          conf   tomcat的配置文件
          lib    tomcat运行所需要的jar包
          logs   tomcat运行的日志文件
          temp   产生的临时文件的存放路径
          wepapps  发布wep项目路径
          work    运行JSP时候,会编译成为servlet的代码存放路径
          
        二:软件的架构
                C/S 客服端和服务端的软件,都需要下载软件
                B/S 浏览器端和服务器端的软件. 不需要安装到PC端,只需要有一个浏览器即可
               
        三:http协议
                1概述:是用来规定浏览器与服务器之前需要遵守的规则;是用于3w服务器传输超文本到本地浏览器的传送协议,
                http是一个应用层协议,由请求和响应构成,是一个标准的客户端服务器模型,http是一个无状态的协议(同一个客户端这一次请求和上一次请求没有对应的关系);
                默认端口号是80,可以省略不写,
                2特点:基本的请求和响应的模型,
                        必须先有请求后有响应,请求和响应必须成对出现,
                3协议的详解;
                        请求行-|
                                        -|提交方式有很多,常用的get和post
                                        -|两个区别:get提交的参数会显示到地址栏上,而post不显示
                                        -|get有大小限制,而post没有大小限制;
                                        -|get没有请求体,而post有请求体
                        请求头-|
                                        -|都是键值对的形式显示的,一般一个key对应着一个值也有个别的一个key对应的多个值
                                        -|User-Agent:代表浏览器的类型
                                        -|Referer:代表网页的来源,-防盗链
                                        -|if-Modified-since:通常与响应的头Last-Modified一起使用查找本地缓存
                       
                        请求体-|
                                        -|就是post提交方式的提交参数(注册的参数)
                        响应部分的状态码-|
                                                                -|200:成功
                                                                -|302:重定向
                                                                -|304:查找本地缓存
                                                                -|404:资源不存在
                                                                -|500:服务器内部错误
                        响应头-|
                                        -|Last-Modified:与请求中的if-Modified-since一起使用查找本地缓存
                                        -|Content-Dispostion:文件下载的使用的一个头信息
                                        -|Location:重定向的跳转的路径
                                        -|Refresh:定时刷新/定时跳转
                        响应体:显示浏览器的页面的内容.
        servlet总结:
                一:servlet就是一个运行在WEB服务器上的小的Java程序,用来接收和响应从客户端发送过来的请求,通常使用HTTP协议.
                        Servlet就是SUN公司提供的一个动态网页开发技术
                        用来处理从客户端浏览器发送的请求,并且可以对请求作出响应

Day13

今天的学习内容主要分为三部分:TomCat,Http,Servlet

TomCat
TomCat:由Apache(阿帕奇)组织研发,是免费的小型服务器软件,支持Servlet/JSP的开发规范.
服务器:硬件服务器和软件服务器;
硬件服务器:高配置的电脑.
软件服务器:在电脑上安装服务器软件.
软件服务器的架构:C/S(Client/Server,客户端/服务器端),B/S(Browser/Server,浏览器端/服务器端)
C/S和B/S的优缺点比较:
C/S架构,优点是软件展示效果酷炫,缺点是服务器端进行更新,客户端也要进行更新,较繁琐.
B/S架构,优点是只需要服务器端进行更新,浏览器端无序更新;缺点展示特效较差.
注意:对WEB资源中的动态资源的定义不是指图片或文字等的动态,而是指服务器端和浏览器端的数据进行请求和响应.
[发布一个Web项目到TomCat]
[为什么?] 我的理解是:因为将Web项目发布到TomCat上,就可以让别人使用你的IP地址来访问你的Web项目,也就是说你设计的Web项目可以
通过TomCat服务器来共享给别人,好比是未使用TomCat之前你玩的是单机游戏,使用TomCat之后你玩的单机游戏可以联网了.
[怎么做?] 首先安装TomCat,然后配置JAVA_HOME环境变量,将TomCat的运行环境添加到Eclipse中,在Servers中创建TomCat服务器.

Http
Http协议:用来规定浏览器端和服务器端的规则,作用是规范浏览器端和服务器端的数据传递.其包含请求和响应,特点为一次请求必定
会有一次响应,必须先有请求后有响应.其默认端口号为80.
Http协议的请求部分包含:请求行,请求头(User-Agent,Referer,If-Modified-Since),请求体(Post提交的参数)
请求行中提交方式有get和post方式,两者的区别get提交的参数会在浏览器地址栏上显示,post提交不会显示,get提交在内存
上有大小限制,post提交没有,get没有请求体,post有请求体
Http协议的响应部分包含:响应行,响应头(Last-Modified,Content-Dispostion,Location,Refresh),响应体
状态码:200(成功),302(重定向),304(查找本地资源),404(资源不存在),500(服务器内部错误)

Servlet
Servlet:运行在Web服务器上的小的Java程序,用来接收和响应从客户端发送过来的请求,通常使用Http协议.
使用Servlet:编写类来实现Servlet接口,并重写其方法,然后将类配置到TomCat服务器中.
使用Servlet来接收浏览器端表单传输的数据的方法有:
String getParameter(String name):接收单个name所对应的值
String[] getParameterValues(String name):接收单个name所对应的多个值
Map getParameterMap():接收所有的值

                                        软件的架构
C/S架构的软件
        Client/Server客户端和服务端的软件.都是需要在PC端安装的软件
        优点:效果好,速度快(一部分代码写到了客户端)
        缺点:服务器端更新,客户端都需要更新
B/S架构的软件
        Browser/Server 浏览器端和服务器端的软件.无需安装 只需浏览器即可
        优点:服务器更新,客户端无需更新
        缺点:效果一般,所有的代码运行都在服务器端,导致服务器压力过大
                效果:HTML5,CSS3可以做出比较好的效果
                服务器压力: 可以搭建服务器的集群 而且还有AJAX技术 服务器端的压力越来越少
WEB的资源
        静态资源:
                HTML,CSS,JS,图片
        动态资源:
                PHP,ASP,Servlet/JSP
服务器
        硬件:配置很高的电脑
        软件:必须在电脑上安装服务器软件,才可以成为WEB服务器
常见的服务器
        Apche:                发布PHP
        IIS:                发布ASP
        WebSphere:        IBM公司研发,收费大型服务器软件,支持EE的所有的开发规范
        WebLogic:        BEA公司研发,收费大型服务器软件,支持EE的所有的开发规范
        Tomcat:                Apache研发,免费小型服务器软件,支持Servlet/JSP的开发规范
        JBoss:               
WEB动态资源的目录结构
        website
                静态资源
                WEB-INF
                        web.xml        必须的
                        classes(可有可无) 存放编译后的class文件
                        lib(可有可无)

TomCat的目录结构
        bin:执行文件
        conf:配置文件!!!
        lib:运行需要的jar包
        logs:运行的日志文件
        temp:临时文件存放目录
        webapps:web项目的路径!!!
        work:运行JSP的时候,JSP被翻译成Servlet的代码存放的路径

WEB攻城发布到Tomcat的三种方法
        1 直接将工程copy到Tomcat/webapps下
        2 设置tomcat的虚拟路径(不推荐)
                在tomcat/conf/server.xml文件中进行配置
                        <Host>标签下配置
                        <Context path="虚拟路径" docBase="真实路径"/>
                        </Host>
        3 虚拟路径(官方推荐)
                在tomcat/conf/Catalina/localhost/xxx.xml
                        配置<Context docBase="真实路径"/>
                xxx作为虚拟路径的名称

STS发布WEB工程
        Eclipse中创建WEB项目 html等文件写在WebContent下

Tomcat常见问题
        1 没有配置JAVA_HOME环境变量
        2 端口号冲突   1:将占用端口的应用结束(netstat -ano) 2:修改自身应用端口号(server.xml修改)





                                        HTTP协议(超文本传输协议  )
协议:规定双方需要遵守的规则
HTTP协议:
        用来规定浏览器与服务器之间需要遵守的规则
作用:
        规范数据之间的传递
特点:
        基于请求和响应的模型
                必须先有请求后有响应 必须成对出现
        默认端口号是80
协议版本:
        1.0:每次响应后即刻关闭了连接
        1.1:现在使用.不是每次响应后挂断,等待很长时间后没有请求会挂断

HTTP抓包 httpwatchpro(安装后在IE工具类中)

       
                                        HTTP协议的详解
请求部分        
        请求行
                提交方式:提交方式有很多 常用的是GET和POST
                        区别:GET提交参数会显示到地址栏 并且有大小限制
                                POST提交参数不会显示到地址栏,无大小限制
                                GET没有请求体
                提交路径
                协议版本
        请求头
                一般都是key,value键值对的形式,一般情况下是一个key对应一个value,有时对应多个
                (需要记)
                User-Agent: 代表浏览器类型(主要解决乱码问题)
                Referer: 代表网页来源---防盗链
                IF-Modified-Since: 通常与响应中的头Last-Modified一起使用查找本地缓存
        空行
        请求体:POST提交方式提交的参数

响应部分
        响应行
                协议版本
                状态码:
                        200(成功)
                        302(重定向)
                        304(查找本地缓存)
                        404(访问资源不存在)
                        500(服务器内部错误)       
                状态码描述
        响应头:一般都是key,value键值对的形式,一般情况下是一个key对应一个value,有时对应多个
                Last-Modified: 与请求中的IF-Modified-Since一起使用查找本地缓存
                Content-Dispostion:        文件下载的时候使用的一个头信息
                Location:        重定向的跳转路径
                Refresh:        定时刷新/跳转
        空行
        响应体:显示到浏览器页面的内容


                                        Servlet
概述
        运行在WEB服务器上的小Java程序(接口),用来接收和响应从客户端发送过来的请求,通常使用HTTP协议
        (动态网页开发技术)
作用
        用来处理从客户端浏览器发送的请求,并对请求作出响应
使用
        1 编写类 实现Servlet接口
        2 在web.xml文件中配置Servlet
                name名称
                class全路径

                mapping映射
                name名称
                pattern访问路径

使用ServletRequest接收参数
                String getParameter(String name);                ---用于接收一个名称对应一个值的数据.
                String[] getParameterValues(String name);        ---用于接收一个名称对应多个值的数据.(复选框)
                Map getParameterMap();                        ---用于接收表单中的所有的数据,Map的key是表单提交的参数名称,Map的value是提交参数的值.
                Enumeration getParameterNames()                ---用于获取表单中提交的所有的参数的名称.(枚举 基本不用)
执行流程
        地址栏→xml配置文件→类→操作

用户提交测试
        1 XML配置属性设置类的全类名
        2 创建HTML文件 添加表单 action为项目名/配置文件的虚拟路径名
        3 在实现类中接收数据并打印

郑雪平

今天学习了tomcat, http协议和  servlet三大块内容.一开始先了解软件的架构,可分为两种:一.CB架构;二.sb架构.两者各有优缺点,第一种的优点是效果比较炫酷,速度比较快,缺点是需下载客户端,服务器端有更新客户端也需要跟着更新;第二种的优点是软件都安装在服务器端,只需安装一次,且维护方便,缺点是效果比较不酷炫,服务器端压力比较大,速度比较慢.
  tomcat主要学习怎么 发布一个web项目到服务器的方式,共有三种:
     一、复制项目到webapps文件夹下.
     二、修改server.xml,配置<Context path=”” docBase=””/>
     三、在conf/Catalina/localhost/xxx.xml 配置<Context docBase=””/>
学习Http协议我们知道了它是一种超文本传输协议,是规范浏览器和服务器之间需要遵守的规则,它还分为请求和响应两种模式,先请求后才是响应,两者一定会成对出现,国际惯例默认的端口号是80端口;请求提交的方式主要使用的是GET和POST,两者的区别是post有请求体get没有,get的有大小限制post没有限制;响应部分响应行常见的状态码有200,302,304,404,500.
其代表的含义是:200-->响应成功,302-->重复定向,304-->查找本地缓存,404-->访问的资源不存在,500-->服务器内部错误.
servlet就是一个运行在WEB服务器上的小的Java程序,用来接收和响应从客户端发送过来的请求,通常使用HTTP协议.
Servlet的作用：
用来处理从客户端浏览器发送过来的请求,并且可以对请求作出响应

HTTP是一种超文本传输协议主要是用来规范不同浏览器不同服务器之间的数据传输,在浏览器内输入服务器的连接地址,后台就会显示请求和响应的协议演示,HTTP主要记住5种响应码200成功302重定向304查找本地缓存404资源不存在以及500服务器内部错误

浏览器与服务器之间的响应请求,有点类似于JAVA中的网络编程,底层有可能用的是UDP或者TCP加上I/O流来传输数据.

浏览器本质上是一个软件通过解析html语句来实现页面的显示,在浏览器输入框中输入想访问的地址后,浏览器内部会调用Socket套接字去向指定的IP地址指定端口,这个服务器端口必须是打开的也就是Tomcat服务器等等类似服务器,发送一个HTTP规范的访问请求,这个请求会是一个字节数组解析后的字符串长串上面有想访问的网页文件名等等一系列参数,java中的服务器收到这个字符长串后开始解析(解析的过程可能是首先判断用户发送过来的路径,然后服务器先去xml文件查找这个路径,如果有Servlet小程序的话一并加载),如果说解析到想要访问的文件名那么会将这个网页文件的内容复制加上一些参数使用HTTP的规范进行传输,通过I/O流发送给浏览器软件, 浏览器内部解析后会将超文本标记语言放到浏览器软件内进行解析显示给用户,再把其它内容显示到其它的位置 ,没查找到的话就发送给浏览器一个没找到的响应,HTTP报404错误

前面提到xml内的Servlet小程序被加载,当用户按下表单的提交按钮后,action内写了指定的文件名,服务器去找xml内对应的文件名,找到Servlet实现类所在的位置,这个Servlet实现类开启监听端口接受用户的请求,请求内容同样是将它再浏览器内的表单数据以字节数组的形式发送过来,内部通过I/O流进行解析后做出的响应,可以是发送给用户信息,或者打印在控制台上或者进行其它操作,比如连接数据库进行判断等非常方便.

表单校验程序的配置: 写一个类实现Servlet接口,实现service方法传入的参数有两个
                                ServletRequest req      接收   
                                String  req.getParameter(String k);  k:表单元素指定名
                                Map<String,String[]>  req.getgetParameterMap(); 获取所有数据返回一个map集合
                          
                                ServletResponse res    发送   
                                 res.getWriter().println(String a); 浏览器内写入a,并切换页面

我们使用时主要注意web文件的配置,以及字节数组解析之后的乱码问题.

刘文峰
Tomcat是一个支持servlet/jsp的小型服务器.我们有三种方式可以将一个web工程发布到tomcat中:第一是直接将工程复制到tomcat安装路径下的webapps文件夹里;第二种是通过配置tomcat文件夹/conf/server.xml文件,在xml文件里的host标签下写一个标签 <Context path="/访问页面输入的路径" docBase="工程所在路径"/>;第三种是配置tomcat/conf/catalina/XXXX.xml文件,文件名为访问页面输入的路径,文件夹里同样写一个标签<Context docBase="工程所在路径"/>.

http协议是一个超文本传输协议,用于规范浏览器和服务器间的数据传输.http是基于请求和响应的模型,每一个请求都有一个响应,而且请求和响应必需是成对出现的.
请求的内容分为请求行,请求头,请求体(响应类似);请求行里有提交方式(get,post),提交路径和http协议版本号(现在使用1.1);get的提交方式会将参数显示在提交路径后面,比较不安全.请求头则是http协议规范数据的传递;请求体里写的是提交的参数(get方式提交没有请求体).
响应的内容同样分为三个部分:响应行里有协议版本,状态码和状态描述,
不同的状态码代表不同的意思:
200  成功
302         重定向
304  查找本地缓存
404  找不到指定文件(路径有错或文件不存在)
500  服务器内部错误(java代码有错)
响应头作用和请求体一样;响应体就是文件的代码;

Servlet用来接收客服端或浏览器发过来的请求并响应.我们可以创建一个类实现servlet接口并配置到服务器中,只要开启服务器就可以接收请求.如果要接收一个表单发过来的请求,我们可以将表单的提交路径(action属性)指向实现了servlet的类;重写接口里面的service(ServletRequest req, ServletResponse res)方法可以接收和响应请求.

陈世彪:
今天学习了Tomcat与Servlet入门
Tomcat是Apache组织研发的小型服务器
发布一个web工程有三种方法
1.直接将工程copy到tomcat/webapps下.
2.tomcat/conf/server.xml文件中进行配置:
3.tomcat/conf/Catalina/localhost/xxx.xml
在web.xml中
<servlet>
  <servlet-name>ServletDemo2</servlet-name>
  <servlet-class>ServletDemo2</servlet-class>这是.java的全类名
  </servlet>
  <servlet-mapping>
  <servlet-name>ServletDemo2</servlet-name>需要和第一个<servlet-name>的名字一模一样
  <url-pattern>/ServletDemo2</url-pattern>名字是页面调用时的名字
  </servlet-mapping>

网页中的提交方法常用的是get和post
GET的提交的参数会显示到地址栏上,而POST不显示.
GET往往是有大小限制的,而POST没有大小的限制.
GET没有请求体,而POST有请求体.

页面响应的方法有
res.getWriter().print()
如果中文乱码
res.setContentType("text/html;charset=utf-8");

在使用ServletRequest接收参数时
常用的方法有
String getParameter(String name);---用于接收一个名称对应一个值的数据.
直接用System.out.println()就可以打印获得
String[] getParameterValues(String name);---用于接收一个名称对应多个值的数据.
直接用System.out.println(Arrays.toString())就可以打印获得
Map getParameterMap();---用于接收表单中的所有的数据,Map的key是表单提交的参数名称,Map的value是提交参数的值.
需要使用增强for获取他的所有键,然后键找值,再使用(Arrays.toString())就可以打印获得

江某人:
        需要先把Tomcat放入eclipse
        了解HTTP协议，几种常见的状态码:
        THHP是超文本传输协议,是互联网上应用最为广泛的一种网络协议.所有的www文件都需要遵守这个协议
        HTTP协议的作用：规范浏览器和服务器之间的数据传递.
        HTTP协议的特点
        基于请求和响应的模型.
        必须先有请求后有响应.
            请求和响应必须成对出现.
        默认的端口号是80.
        HTTP协议的版本:
        1.0        :每次响应后即刻关闭了连接.
        1.1        :现在使用.不是每次响应后挂断,等待长时间以后没有请求会挂断.
                请求部分
        请求行:
            提交方式:
          提交方式有很多,常用的GET和POST:
        GET和POST的区别:
          GET的提交的参数会显示到地址栏上,而POST不显示.
            GET往往是有大小限制的,而POST没有大小的限制.
            GET没有请求体,而POST有请求体.
         请求头
    都是键值对的形式显示的.一般一个key对应一个value,也有个别的是一个key对应多个value.
     User-Agent                                :代表浏览器的类型. --- 文件下载:下载中文文件:IE使用URLEncodor进行编码,而Firefox使用Base64编码.
     Referer                                :代表的是网页的来源. --- 防盗链.
     If-Modified-Since                :通常与响应中的头Last-Modified一起使用查找本地缓存.
请求体
    就是POST提交方式的提交的参数.
        响应部分
响应行:
     协议版本
     状态码：
         200        ：成功
         302        ：重定向
         304        ：查找本地缓存
         404        ：资源不存在
         500        ：服务器内部错误
    状态码描述
响应头：键值对,一般一个key对应一个value,也有一个key对应多个value.
     Last-Modified:与请求中的If-Modified-Since一起使用查找本地缓存.
     Content-Dispostion        :文件下载的使用使用的一个头信息.
     Location:重定向的跳转的路径.
     Refresh:定时刷新/定时跳转.

               

什么是Servlet:
  就是一个运行在WEB服务器上的小的Java程序,用来接收和响应从客户端发送过来的请求,通常使用HTTP协议.
  Servlet就是SUN公司提供的一个动态网页开发技术.
        Servlet的作用：
  用来处理从客户端浏览器发送的请求,并且可以对请求作出响应
        使用Servlet：
  编写一个类实现Servlet接口.
  将编写的这个类配置到服务器中.
   String getParameter(String name);---用于接收一个名称对应一个值的数据.
   String[] getParameterValues(String name);---用于接收一个名称对应多个值的数据.
   Map getParameterMap();---用于接收表单中的所有的数据,Map的key是表单提交的参数名称,Map的value是提交参数的值.