Web简介 HTTP协议 Web容器 Tomcat的安装与使用 JSP的基础的语法 scriptlet标签

Web：

一种分布式的应用架构，共享分布在网络上的各个Web服务器中的所有的互相连接的信息。Web采用的是客户端与服务器模式，采用HTTP协议进行通信。

Web具备以下的3点特征：
1.用HTML来表达信息，以及建立信息与信息的连接。
2.用统一资源定位技术URL来实现网络上的信息的精确的定位。
3.用网络应用层协议HTTP来规范浏览器与服务器之间的通信过程。

URL：Uniform Resource Locator的缩写。
表示统一资源定位器，它是一种专门为表示网络上的资源而设定的一种编址方式。
URL 一般由三部分组成：
1.应用层协议
2.主机的IP地址或者是域名。
3.资源所在的路径/文件名

HTTP协议：
超级文本传输协议，用来传输HTML的协议。
客户端与服务器之间的一次信息交换包括以下的过程：
1.客户端与服务器建立TCP连接
2.客户端发送HTTP请求。
3.服务器发回响应的HTTP结果
4.客户端与服务器之间的TCP连接关闭。

从浏览器与服务器通信过程中可以看出浏览器应该具备的功能：
1.请求与Web服务器建立TCP连接
2.创建并发送HTTP请求
3.接收并且解析HTTP响应
4.在窗口显示返回的结果（HTML文档、访问的某一个文件）

Web服务器应该具备的功能：
1.接收来自浏览器的TCP的连接
2.接收并解析HTTP请求
3.创建并发送HTTP响应

HTTP的请求格式：
HTTP规定 HTTP的请求由3部分组成的：
1.请求方法、URI、HTTP协议的版本
2.请求头
3.请求正文

HTTP请求的例子：
GET /hello.html HTTP/1.1 //请求方法、URI、HTTP协议的版本
HOST:localhost
Content-type:application/x-www-form-urlencode //请求头

username=TOM&password=1234&submit=submit //请求正文

HTTP响应的格式：
HTTP响应也由3部分组成
1.HTTP协议的版本 状态码 描述
2.响应头
3.响应正文

HTTP响应的例子：
HTTP1.1 200 ok //HTTP协议的版本 状态码 描述
server:Apache-coyote/1.1
content-type:text/html;charset=GBK
content-length:102 //响应头

html代码 //响应正文

HTTP协议的状态码：
一般状态码都是由3位的整数组成，以1,2,3,4,5开头
1XX:提示信息，表示临时的响应
2XX:响应成功，表明服务器成功的接收了浏览器的请求
3XX:重定向
4XX:客户端错误，表明客户端可能有问题
5XX:服务器错误，表明服务器由于遇到某种问题而不能响应客户端的请求。
一般比较常见的状态码:
200：响应成功
400：错误的请求
404：文件不存在
505：服务器内部的错误

请求正文部分的MIME类型
MIME是指多用途网络邮件扩展协议。
文件扩展名与MIME类型的对应关系：
1.未知的数据或不可识别的扩展名：content/unkown
2. .bin、.exe、.o、.a、.z:application/octet-stream
3. .pdf:apllication/pdf
4. .zip:application/zip
5. .tar:application/x-tar
6. .gif:image/gif
7. .jpg、.jpeg:image/jpeg
8. .htm、.html:text/html
9. .text、.c、.txt、.h、.java:text/plain
10. .mpg、.mpeg:video/mpeg
11. .xml:application/xml

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

public class HTTPClient {

       public static void main(String[] args) {              

                  try
                {
                     //创建Socket对象,产生与服务器之间的TCP连接
                     Socket socket = new Socket("localhost", 9999);
                     //获取Socket对象给我们提供的输出流，用来发送HTTP请求
                     OutputStream out = socket.getOutputStream();
                     //创建并发送HTTP请求
                     String request = "";
                     StringBuffer sb = new StringBuffer();
                     sb.append("post hello.html HTTP/1.1");
                     sb.append("\r\n");
                     sb.append("HOST:localhost");
                     sb.append("\r\n");
                     sb.append("Content-type:application/x-www-form-urlencode");
                     sb.append("\r\n");
                     sb.append("\r\n");
                     sb.append("username=TOM&password=1234&submit=submit");
                     request = sb.toString();
                     out.write(request.getBytes());
                     //让线程进行休眠，等待服务器响应
                     try
                   {
                            Thread.sleep(3000);
                   }catch (InterruptedException e) {
                            //TODO Auto-generated catch block
                            e.printStackTrace();
                   }
                     //通过Socket给我们提供的输入流对象，获取服务器发送的响应
                     InputStream in = socket.getInputStream();
                     //接收响应并解析响应
                     byte[] b = new byte[in.available()];
                     in.read(b);
                     //将读取的内容转变为字符串
                     String response = new String(b);
                     System.out.println("解析到的响应内容：");
                     System.out.println(response);
                     String content = response.substring(response.indexOf("\r\n\r\n"));
                     System.out.println("请求的文件的内容：");
                     System.out.println(content);                    
                     in.close();
                     out.close();
              }catch (UnknownHostException e) {
                     //TODO Auto-generated catch block
                     e.printStackTrace();
              }catch (IOException e) {
                     //TODO Auto-generated catch block
                     e.printStackTrace();
              }
       }
}

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class HTTPServer {

       public static void main(String[] args) {
              
                try
              {
                     //创建ServerSocket对象,用来接受客户端发送的TCP连接
                     ServerSocket server = new ServerSocket(9999);
                     //等待客户端的连接
                     System.out.println("等待客户端连接");
                     Socket socket = server.accept();
                     //通过socket给我们提供的输入流，接收客户端发送的HTTP请求
                     InputStream in = socket.getInputStream();
                     //通过Socket提供的输出流，发送给客户端的响应
                     OutputStream out = socket.getOutputStream();                     
                     //接受客户端发送过来的HTTP请求
                     //常见一个字节型数组，用来保存读取的数据
                     byte[] b = new byte[in.available()];
                     in.read(b);
                     //将读取到的数据转变为字符串
                     String str = new String(b);
                     System.out.println("接收到的HTTP请求：");
                     System.out.println(str);                    
                     //对请求进行解析
                     //解析请求的第一行
                     String firstLine = str.substring(0, str.indexOf("\r\n"));
                     //解析请求的文件
                     String[] strs = firstLine.split(" ");
                     //得到请求的文件名称
                     String fileName = strs[1];                                         
                     //生成响应
                     //获取想要访问的文件的File对象
                     File file = new File("d:"+File.separator+fileName);
                     //将文件的内容读取出来
                     InputStream fileIn = new FileInputStream(file);
                     //创建一个字节数组用来保存从文件中读取的内容
                     byte[] bs = new byte[fileIn.available()];
                     //读取内容
                     fileIn.read(bs);
                     //将读取到的字节数组转变为字符串
                     String fileContent = new String(bs);
                     System.out.println("从文件中读取的内容是："+fileContent);                     
                     //生成HTTP响应
                     StringBuffer sb = new StringBuffer();
                     sb.append("HTTP/1.1 200 ok");
                     sb.append("\r\n");
                     sb.append("server:Apache-coyote/1.1");
                     sb.append("\r\n");
                     sb.append("content-type:text/html;charset=GBK");
                     sb.append("\r\n");
                     sb.append("content-length:102");
                     sb.append("\r\n");
                     sb.append("\r\n");
                     sb.append(fileContent);
                     //将拼接好的内容转变为字符串
                     String response = sb.toString();                     
                     out.write(response.getBytes());                                         
                     in.close();
                     out.close();
                     fileIn.close();                    
              }catch (IOException e) {
                     //TODO Auto-generated catch block
                     e.printStackTrace();
              }                            
       }
}

想要通过java程序模拟HTTP客户端与服务器之间的通信过程：
思路：
1.浏览器需要具备的功能
创建TCP连接
生成HTTP请求并且将请求进行发送
接收服务器返回的HTTP响应并且对响应进行解析
2.服务器需要具备的功能
接受客户端发送的TCP连接
接收客户端发送的HTTR请求并且对请求进行解析
创建HTTP响应并且将响应发送给客户端

Web容器：
要想运行一个Web程序，则必须有响应的Web容器的支持，因为所有的动态的程序代码都要在Web容器中进行执行，并且将最后生成的结果交付给用户进行使用。

什么是静态请求，什么是动态请求，二者的区别：
简单的理解可以通过后缀完成，在一般的web站点中，HTML、htm之类的后置往往都属于静态请求，所以一般这样的操作都是直接通过文件系统取出之后并返回的。而如果是动态请求，后缀是JSP、PHP之类的，动态请求的所有的代码都是由程序拼凑而成。

Tomcat的安装与使用：
安装：直接解压缩就可以使用
安装目录的说明：
1.bin:所有的可执行命令，启动和关闭服务器的命令就在此文件夹。
2.conf:服务器的配置文件夹，其中保存了服务器的各个配置信息。
3.lib:Tomcat服务器所需要的各个类库文件
4.logs:保存服务器的系统日志
5.temp:临时文件夹
6.webapps:web应用程序存放的目录，web项目保存到此目录中即可发布
7.work:临时文件夹，生成所有的临时文件。

第一个Web工程：
工程结构：
1.src:我们编写的所有的java的源代码，存放在此文件夹
2.JRE：存放我们java程序想要执行的时候，所用到的执行环境。
3.JavaEE6.0:我们使用的JavaEE给我们提供的API
4.JSTL1.2：JSP的标准标签库
5.WebRoot：用来存放，我们所编写的所有的静态页面以及动态页面，使用的第三方的类库。
.jsp文件：java server page，java的服务器页面，我们JavaEE中jsp文件就是我们所编写的动态页面。在jsp中可以编写HTML页面，也可以编写Java代码。说白了，JSP就是HTML中可以嵌入Java代码了。

JSP的执行流程：
首先一个客户端向服务器发送一个请求的页面地址，服务器端在接收到用户的请求的内容后要对*.jsp文件进行转换，将其转换为*.java源文件，并最终编译为一个*.class文件。也就是说最后真正执行的文件还是以*.class文件格式为主的。因为程序第一次运行要经历以上的步骤，所有有时会出现卡顿，而第二次执行时，由于已经产生好了源文件以及字节码文件，所以可以直接运行，不再耗费时间。
另外，在每次修改JSP文件后，所有的JSP文件所对应Java源文件也会重新生成，每一次修改对于程序来讲都相当于是一个新的程序重新执行一样，所以当每次修改完毕之后，第一次运行时，也会出现较慢的情况。由于我们的服务器会出现缓存的情况，建议大家每一次修改完代码之后，最好将服务器重启之后在运行程序。

JSP的基础的语法：
JSP的注释：
在JSP中支持两种注释语法的操作，一种是显示注释，一种是隐式注释。
显示注释的语法：

<!-- 注释的内容 -->

隐式的注释的语法：
1.单行注释
//注释的内容
2.多行注释
/*
注释的内容
*/
3.JSP注释
<%-- 注释 -->

scriptlet标签：
在JSP中，最重要的部分就是Scriptlet(脚本小程序),所有的嵌入在HTML中Java代码都必须使用ScriptLet标记出来。
JSP中一共存在3中Scriptlet标签：
第一种：<%%>
使用此种标签，编写的java代码，最终都会在JSP对应生成的源文件的_jspService方法中包含，在此种Scriptlet标签中，我们只能写声明局部变量、局部常量、简单的java语句。实际上在java中，在一个方法里面能写的代码，在这个里面都可以写。
第二种：<%!%>
使用此标签，编写的java代码，最终都会在JSP对应生成的源文件的类的内部，其他方法的外部中包含。也就是说此种Scriptlet标签包含的java代码中，我们可以用来编写全局变量、全局常量、定义内部类、定义其他的方法等等。实际上在java中，在一个类里面可以写什么代码，在这个标签中就可以写什么代码。
第三种：<%=%>
是用来进行输出的