JavaWeb

CoolEr3022

于 2022-04-11 14:36:31 发布

阅读量992

点赞数

分类专栏：笔记文章标签： web

本文链接：https://blog.csdn.net/weixin_56341892/article/details/124098547

版权

JavaWeb

一、理论

（一）关于系统架构

1、系统架构包括形式

C/S架构
B/S架构

2、C/S架构

Client/Server（客户端/服务器）
C/S架构的软件或者说系统
- QQ（先去腾讯官网下载一个QQ软件，几十MB，然后把这个客户端软件安装上去，然后输入QQ号以及密码，登录之后，就可以使用这个软件了。）
C/S架构的特点：需要安装特定的客户端软件。
C/S架构的系统优点和缺点：
- 优点：
  - 速度快（软件中的数据大部分都是集成到客户端软件当中的，很少量的数据从服务器端传送过来，所以C/S结构的系统速度快）
  - 体验好（速度又快，界面又酷炫，当然体验好了。）
  - 界面酷炫（专门的语言去实现界面的，更加灵活。）
  - 服务器压力小（因为大量的数据都是集成在客户端软件当中，所以服务器只需要传送很少的数据量，当然服务器压力小。）
  - 安全（因为大量的数据是集成在客户端软件当中的，并且客户端有很多个，服务器虽然只有一个，就算服务器那边地震了，火灾了，服务器受损了，问题也不大，因为大量的数据在多个客户端上有缓存，有存储，所以从这个方面来说，C/S结构的系统比较安全。）
  - …
- 缺点：
  - 升级维护比较差劲。（升级维护比较麻烦。成本比较高。每一个客户端软件都需要升级。有一些软件不是那么容易安装的。）

3、B/S架构

B/S（Browser / Server，浏览器 / 服务器）
B/S结构的系统还是一个C/S，只不过这个C比较特殊，这个Client是一个固定不变浏览器软件
B/S结构的系统优点和缺点：
- 优点：
  - 升级维护方便，成本比较低。（只需要升级服务器端即可。）
  - 不需要安装特定的客户端软件，用户操作极其方便。只需要打开浏览器，输入网址即可。
- 缺点：
  - 速度慢（不是因为带宽低的问题，是因为所有的数据都是在服务器上，用户发送的每一个请求都是需要服务器全身心的响应数据，所以B/S结构的系统在网络中传送的数据量比较大。）
  - 体验差（界面不是那么酷炫，因为浏览器只支持三个语言HTML CSS JavaScript。再加上速度慢。）
  - 不安全（所有的数据都在服务器上，只要服务器发生火灾，地震等不可抗力，最终数据全部丢失。）
  - …

4、架构选择

娱乐性软件建议使用：C/S 结构
公司内部使用的一些业务软件建议使用：B/S 结构
- 公司内部使用的系统，需要维护成本低。
- 公司内部使用的系统，不需要很酷炫。
- 公司内部使用的企业级系统主要是能够进行数据的维护即可。
开发B/S结构的系统，其实就是开发一个WEB系统。
C/S和B/S结构的系统并不是哪个好，哪个不好。不同结构的系统在不同的业务场景下有不同的适用场景。

（二）JavaEE

1、Java包括三大块：

JavaSE
- Java标准版（一套类库：别人写好的一套类库，这个类库是标准类库。）
JavaEE（WEB方向，WEB系统。）
- Java企业版（也是一套类库：也是别人写好的一套类库，这套类库可以帮助我们完成企业级项目的开发，专门为企业内部提供解决方案的一套（多套）类库。）
- 可以开发web系统。
- JavaEE实际上包括很多种规范，13种规范，其中Servlet就是JavaEE规范之一。
JavaME
- Java微型版（还是一套类库，这套类库帮助我们进行电子微型设备内核程序的开发）
- 机顶盒内核程序，吸尘器内核程序，电冰箱内核程序，电饭煲内核程序。。。。。

（三）B/S结构的系统通信原理（没有涉及到Java小程序）

1、WEB系统的访问过程

第一步：打开浏览器
第二步：找到地址栏
第三步：输入一个合法的网址
第四步：回车
第五步：在浏览器上会展示响应的结果。

2、域名

https://www.baidu.com/ （网址）
www.baidu.com 是一个域名
在浏览器地址栏上输入域名，回车之后，域名解析器会将域名解析出来一个具体的IP地址和端口号等。
解析结果也许是：http://110.242.68.3:80/index.html

3、IP地址

计算机在网络当中的一个身份证号。在同一个网络当中，IP地址是唯一的。
A计算机要想和B计算机通信，首先你需要知道B计算机的IP地址，有了IP地址才能建立连接。

4、端口号

一个端口代表一个软件（一个端口代表一个应用，一个端口仅代表一个服务）。
一个计算机当中有很多软件，每一个软件启动之后都有一个端口号。
在同一个计算机上，端口号具有唯一性。

5、URL

统一资源定位符（http://www.baidu.com）

6、一个WEB系统的通信原理和通信步骤

第一步：用户输入网址（URL）
第二步：域名解析器进行域名解析：http://110.242.68.3:80/index.html
第三步：浏览器软件在网络中搜索110.242.68.3这一台主机，直到找到这台主机。
第四步：定位110.242.68.3这台主机上的服务器软件，因为是80端口，可以很轻松的定位到80端口对应的服务器软件。
第五步：80端口对应的服务器软件得知浏览器想要的资源名是：index.html
第六步：服务器软件找到index.html文件，并且将index.html文件中的内容直接输出响应到浏览器上。
第七步：浏览器接收到来自服务器的代码（HTML CSS JS）
第八步：浏览器渲染，执行HTML CSS JS代码，展示效果。

7、请求和响应

请求和响应实际上说的是数据的流向不同。
从Browser端发送数据到Server端，我们称为请求。英语单词：request
从Server端向浏览器Browser端发送数据，我们称为响应。英语单词：response
B --> S （请求request）
S --> B （响应response）

二、WEB服务器软件

（一）关于WEB服务器软件

1、WEB服务器软件：（这些软件都是提前开发好的。）

Tomcat（WEB服务器）
jetty（WEB服务器）
JBOSS（应用服务器）
WebLogic（应用服务器）
WebSphere（应用服务器）

2、应用服务器和WEB服务器的关系

应用服务器实现了JavaEE的所有规范。(JavaEE有13个不同的规范。)
WEB服务器只实现了JavaEE中的Servlet + JSP两个核心的规范。
应用服务器是包含WEB服务器的。
JBOSS中内嵌了一个Tomcat服务器。

3、Tomcat

tomcat开源免费的轻量级WEB服务器。
tomcat还有另外一个名字：catalina（catalina是美国的一个岛屿，风景秀丽，据说作者是在这个风景秀丽的小岛上开发了一个轻量级的WEB服务器，体积小，运行速度快，因此tomcat又被称为catalina）
tomcat的logo是一只公猫（寓意表示Tomcat服务器是轻巧的，小巧的，体积小，运行速度快，只实现了Servlet+JSP规范）
tomcat是java语言写的。
tomcat服务器要想运行，必须先有jre（Java的运行时环境），所以要先安装JDK，配置java运行环境。

4、配置Tomcat服务器

关于Tomcat服务器的目录
- bin ：这个目录是Tomcat服务器的命令文件存放的目录，比如：启动Tomcat，关闭Tomcat等。
- conf：这个目录是Tomcat服务器的配置文件存放目录。（server.xml文件中可以配置端口号，默认Tomcat端口是8080）
- lib ：这个目录是Tomcat服务器的核心程序目录，因为Tomcat服务器是Java语言编写的，这里的jar包里面都是class文件。
- logs: Tomcat服务器的日志目录，Tomcat服务器启动等信息都会在这个目录下生成日志文件。
- temp：Tomcat服务器的临时目录。存储临时文件。
- webapps：这个目录当中就是用来存放大量的webapp（web application：web应用）
- work：这个目录是用来存放JSP文件翻译之后的java文件以及编译之后的class文件。

5、启动tomcat

bin目录下有一个文件：startup.bat,通过它可以启动Tomcat服务器
- bat文件是windows操作系统专用的，bat文件是批处理文件，这种文件中可以编写大量的windows的dos命令，执行bat文件就相当于批量的执行dos命令。
- startup.sh，这个文件在windows当中无法执行，在Linux环境当中可以使用。在Linux环境下能够执行的是shell命令，大量的shell命令编写在shell文件当中，然后执行这个shell文件可以批量的执行shell命令。
- tomcat服务器提供了bat和sh文件，说明了这个tomcat服务器的通用性。
- 分析startup.bat文件得出，执行这个命令，实际上最后是执行：catalina.bat文件。
- catalina.bat文件中有这样一行配置：MAINCLASS=org.apache.catalina.startup.Bootstrap （这个类就是main方法所在的类。）
- tomcat服务器就是Java语言写的，既然是java语言写的，那么启动Tomcat服务器就是执行main方法。
尝试打开dos命令窗口，在dos命令窗口中输入startup.bat来启动tomcat服务器。
配置Tomcat服务器需要哪些环境变量？
- JAVA_HOME=JDK的根
- CATALINA_HOME=Tomcat服务器的根
- PATH=%JAVA_HOME%\bin;%CATALINA_HOME%\bin
启动Tomcat： startup
关闭Tomcat：stop （shutdown.bat文件重命名为stop.bat，原因是shutdown命令和windows中的关机命令冲突。）
测试Tomcat服务器有没有启动成功
- 打开浏览器，在浏览器的地址栏上输入URL即可：
  - http://ip地址:端口号
  - 端口号是8080
  - 本机的IP地址是：127.0.0.1，或者是localhost。

（二）实现一个最基本的web应用（这个web应用中没有java小程序）

第一步：找到CATALINA_HOME\webapps目录

因为所有的webapp要放到webapps目录下。（如果不放到这里，Tomcat服务器找不到你的应用。）
第二步：在CATALINA_HOME\webapps目录下新建一个子目录，起名：oa

这个目录名oa就是你这个webapp的名字。
第三步：在oa目录下新建资源文件，例如：index.html

编写index.html文件的内容。
第四步：启动Tomcat服务器
第五步：打开浏览器，在浏览器地址栏上输入这样的URL：

http://127.0.0.1:8080/oa/index.html

我们在浏览器上直接输入一个URL，然后回车。这个动作和超链接一样吗？既然是一样的，我们完全可以使用超链接。

<!--注意以下的路径，以/开始，带项目名，是一个绝对路径。不需要添加：http://127.0.0.1:8080-->
<a href="/oa/login.html">user login2</a>

<!--多个层级也没有关系，正常访问即可。-->
<!--注意：目前前端上的路径都以“/”开始的，都是加项目名的。-->
<a href="/oa/test/debug/d.html">d page</a>

http://127.0.0.1:8080/oa/userList.html
- 访问这个地址，可以展示一个用户列表页面。但是这个用户列表页面是写死在HTML文件当中的。这种资源称为静态资源。
- 连接数据库需要JDBC程序，也就是说需要编写Java程序连接数据库，数据库中有多少条记录，页面上就显示多少条记录，这种技术被称为动态网页技术。（动态网页技术并不是说页面中有flash动画。动态网页技术是说页面中的数据是动态的，根据数据库中数据的变化而变化。）

（三）B/S结构系统的角色和协议

1、在整个BS结构的系统当中，参与的人员

浏览器软件的开发团队（谷歌浏览器、火狐浏览器、IE浏览器…）
WEB Server的开发团队（Tomcat、Jetty、WebLogic、JBOSS、WebSphere…）
DB Server的开发团队（Oracle、MySQL…）
webapp的开发团队（WEB应用是我们做为JavaWEB程序员开发的）

2、角色和角色之间需要遵守的规范和协议

webapp的开发团队和 WEB Server的开发团队之间有一套规范: JavaEE规范之一Servlet规范。
Servlet规范的作用
- WEB Server 和 webapp解耦合。
Browser 和 WebServer之间有一套传输协议：HTTP协议。（超文本传输协议。）
webapp开发团队和 DB Server的开发团队之间有一套规范：JDBC规范。

在这里插入图片描述

3、Servlet规范

遵循Servlet规范的webapp，这个webapp就可以放在不同的WEB服务器中运行。（因为这个webapp是遵循Servlet规范的。）
Servlet规范包括
- 规范了哪些接口
- 规范了哪些类
- 规范了一个web应用中应该有哪些配置文件
- 规范了一个web应用中配置文件的名字
- 规范了一个web应用中配置文件存放的路径
- 规范了一个web应用中配置文件的内容
- 规范了一个合法有效的web应用它的目录结构应该是怎样的。
- …
模拟Servlet本质

package javax.servlet;

/*
	现在充当的角色是SUN公司。
	SUN公司把Servlet接口/规范制定出来了。
*/
public interface Servlet{
   

	// 一个专门提供服务的方法
	void service();
}

package com.cooler.servlet;

import javax.servlet.Servlet;

// 充当的角色发生了改变:webapp开发者
// 只要是webapp开发者写的XXXServlet都要实现Servlet接口
public class BankServlet implements Servlet{
   
	public void service(){
   
		System.out.println("BankServlet's service...");
	}
}

package com.cooler.servlet;

import javax.servlet.Servlet;

// 充当的角色发生了改变:webapp开发者

public class UserListServlet implements Servlet{
   
	public void service(){
   
		System.out.println("UserListServlet's service...");
	}
}

package com.cooler.servlet;

import javax.servlet.Servlet;

// 充当的角色发生了改变:webapp开发者

public class UserLoginServlet implements Servlet{
   
	public void service(){
   
		System.out.println("UserLoginServlet's service...");
	}
}

package org.apache;

import java.util.Scanner;
import java.util.Properties;
import java.io.FileReader;
import javax.servlet.Servlet;

// 充当Tomcat服务器的开发者
public class Tomcat{
   
	public static void main(String[] args) throws Exception{
   
        
		System.out.println("Tomcat服务器启动成功，开始接收用户的访问。");

		// 简单的使用Scanner来模拟一下用户的请求
		// 用户访问服务器是通过浏览器上的“请求路径”
		// 也就是说用户请求路径不同，后台执行的Servlet不同。
		/*
			/userList    UserListServlet
			/login		 UserLoginServlet
			/bank		 BankServlet
			......
		*/
		System.out.print("请输入您的访问路径：");
		Scanner s = new Scanner(System.in);

		// 用户的请求路径  
		String key = s.nextLine(); // Tomcat服务器已经获取到了用户的请求路径了。

		// Tomcat服务器应该通过用户的请求路径找对应的XXXServlet
		// 请求路径和XXXServlet之间的关系应该由谁指定呢？
		// 对于Tomcat服务器来说需要解析配置文件
		FileReader reader = new FileReader("web.properties");
		Properties pro = new Properties();
		pro.load(reader);
		reader.close();

		// 通过key获取value
		String className = pro.getProperty(key);
		// 通过反射机制创建对象
		Class clazz = Class.forName(className);
		Object obj = clazz.newInstance(); // obj的类型对于Tomcat服务器开发人员来说不知道。
		
		// 但是Tomcat服务器的开发者知道，XXXXServlet一定实现了Servlet接口
		//面向接口编程
		Servlet servlet = (Servlet)obj;
		servlet.service();

	}
}

（1）充当SUN公司的角色，指定Servlet规范——javax.servlet.Servlet接口

（2）充当Tomcat服务器的开发者

（3）充当Webapp的开发者

——BankServlet implements Servlet

——UserListServlet implements Servlet

——UserLoginServlet implements Servlet

通过分析：

对于JavaWeb程序员来说，只需要做两件事：

①编写一个类实现Servlet接口

②将编写的类配置到配置文件当中，在配置文件中指定请求路径和类名的关系。配置文件的文件名固定，配置文件的存放路径固定，SUN公司指定的Servlet规范规定。

三、Servlet开发

（一）开发一个带有Servlet（Java小程序）的webapp

1、开发步骤：

第一步：在webapps目录下新建一个目录，起名crm（这个crm就是webapp的名字）。（注意：crm就是这个webapp的根）
第二步：在webapp的根下新建一个目录：WEB-INF（注意：这个目录的名字是Servlet规范中规定的，必须全部大写。）
第三步：在WEB-INF目录下新建一个目录：classes（注意：这个目录的名字必须是全部小写的classes。另外这个目录下一定存放的是Java程序编译之后的class文件（这里存放的是字节码文件）。）
第四步：在WEB-INF目录下新建一个目录：lib（注意：这个目录不是必须的。但如果一个webapp需要第三方的jar包的话，这个jar包要放到这个lib目录下，必须是全部小写的lib。例如java语言连接数据库需要数据库的驱动jar包。那么这个jar包就一定要放到lib目录下。这Servlet规范中规定的。）
第五步：在WEB-INF目录下新建一个文件：web.xml（注意：这个文件是必须的，这个文件名必须叫做web.xml。这个web.xml文件就是一个配置文件，在这个配置文件中描述了请求路径和Servlet类之间的对照关系。这个文件最好从其他的webapp中拷贝。）

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee
                      https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
  version="5.0"
  metadata-complete="true">


</web-app>

第六步：编写一个Java程序，这个小java程序必须实现Servlet接口。
- 这个Servlet接口不在JDK当中。（因为Servlet不是JavaSE。Servlet属于JavaEE，是另外的一套类库。）
- Servlet接口（Servlet.class文件）是Oracle提供的。（最原始的是sun公司提供的。）
- Servlet接口是JavaEE的规范中的一员。
- Tomcat服务器实现了Servlet规范，所以Tomcat服务器也需要使用Servlet接口。Tomcat服务器中应该有这个接口，Tomcat服务器的CATALINA_HOME\lib目录下有一个servlet-api.jar，解压这个servlet-api.jar之后，里面有一个Servlet.class文件。
- 重点：从JakartaEE9开始，Servlet接口的全名变了：jakarta.servlet.Servlet
- 注意：编写这个Java小程序的时候，java源代码位置无所谓，你只需要将java源代码编译之后的class文件放到classes目录下即可。
第七步：编译我们编写的HelloServlet

import jakarta.servlet.Servlet;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;
import jakarta.servlet.ServletConfig;
import java.io.IOException;
import java.io.PrintWriter;


public class HelloServlet implements Servlet{
   

	// 5个方法
	public void init(ServletConfig config) throws ServletException{
   
	
	}

	public void service(ServletRequest request,ServletResponse response)
		throws ServletException , IOException{
   

		// 向控制台打印输出
		System.out.println("My First Servlet, Hello Servlet");

		// 设置响应的内容类型是普通文本或html代码
		// 需要在获取流对象之前设置，有效。
		response.setContentType("text/html");

		// 将一个信息直接输出到浏览器上
		// 需要使用ServletResponse接口：response
		// response表示响应：从服务器向浏览器发送数据叫做响应。
		PrintWriter out = response.getWriter();
		
		// 设置响应的内容类型时不要在获取流之后设置。
		//response.setContentType("text/html");

		out.print("Hello Servlet, You are my first servlet!");

		// 浏览器是能够识别html代码的，那我们是不是应该输出一段HTML代码呢？
		out.print("<h1>hello servlet，你好Servlet</h1>");

		// 这是一个输出流，负责输出字符串到浏览器
		// 这个输出流不需要我们刷新，也不需要我们关闭，这些都由Tomcat来维护。
		/*
		out.flush();
		out.close();
		*/
	}

	public void destroy(){
   
	
	}

	public String getServletInfo(){
   
		return "";
	}

	public ServletConfig getServletConfig(){
   
		return null;
	}
}

让HelloServlet编译通过——配置环境变量CLASSPATH

CLASSPATH=.;D:\JavaWeb\工具\apache-tomcat-10.0.12\lib\servlet-api.jar

以上配置的CLASSPATH和Tomcat服务器运行没有任何关系，只是为了让HelloServlet能够正常编译生成class文件。

第八步：将以上编译之后的HelloServlet.class文件拷贝到WEB-INF\classes目录下。
第九步：在web.xml文件中编写配置信息，让“请求路径”和“Servlet类名”关联在一起。（这一步用专业术语描述：在web.xml文件中注册Servlet类。）

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee
                      https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
  version="5.0"
  metadata-complete="true">

	<!--servlet描述信息-->
	<!--任何一个servlet都对应一个servlet-mapping -->
	<servlet>
		<servlet-name>fdsa</servlet-name>
		<!--这个位置必须是带有包名的全限定类名-->
		<servlet-class>com.cooler.servlet.HelloServlet</servlet-class>
	</servlet>

	<!--servlet映射信息-->
	<servlet-mapping>
		<!--这个也是随便的，不过这里写的内容要和上面的一样。-->
		<servlet-name>fdsa</servlet-name>
		<!--这里需要一个路径-->
		<!--这个路径唯一的要求是必须以 / 开始-->
		<!--当前这个路径可以随便写-->
		<url-pattern>/fdsa/fd/saf/d/sa/fd/sa/fd</url-pattern>
	</servlet-mapping>
	
</web-app>

第十步：启动Tomcat服务器
第十一步：打开浏览器，在浏览器地址栏上输入一个url，这个URL必须是：http://127.0.0.1:8080/crm/fdsa/fd/saf/d/sa/fd/sa/fd

（浏览器上的请求路径不能随便写，这个请求路径必须和web.xml文件中的url-pattern一致。注意：浏览器上的请求路径和web.xml文件中的url-pattern的唯一区别就是：浏览器上的请求路径带项目名：/crm），浏览器上编写的路径太复杂，可以使用超链接。（注意：html页面只能放到WEB-INF目录外面。）

2、总结：

一个合法的webapp目录结构

浏览器发送请求，到最终服务器调用Servlet中的方法，过程如下：
- 用户输入URL，或者直接点击超链接：http://127.0.0.1:8080/crm/fdsa/fd/saf/d/sa/fd/sa/fd
- 然后Tomcat服务器接收到请求，截取路径：/crm/fdsa/fd/saf/d/sa/fd/sa/fd
- Tomcat服务器找到crm项目
- Tomcat服务器在web.xml文件中查找/fdsa/fd/saf/d/sa/fd/sa/fd 对应的Servlet是：com.cooler.servlet.HelloServlet
- Tomcat服务器通过反射机制，创建com.cooler.servlet.HelloServlet的对象。
- Tomcat服务器调用com.cooler.servlet.HelloServlet对象的service方法。

3、向浏览器响应一段HTML代码

public void service(ServletRequest request, ServletResponse response){
   
    response.setContentType("text/html");
    PrintWriter out = response.getWriter();
    out.print("<h1>hello servlet!</h1>");
}

####　4、Servlet中连接数据库

Servlet是Java程序，所以在Servlet中完全可以编写JDBC代码连接数据库。
在一个webapp中去连接数据库，需要将驱动jar包放到WEB-INF/lib目录下。（com.mysql.cj.jdbc.Driver 这个类就在驱动jar包当中。）

import jakarta.servlet.Servlet;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;
import jakarta.servlet.ServletConfig;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.*;


public class StudentServlet implements Servlet{
   

	public void init(ServletConfig config) throws ServletException{
   
	
	}

	public void service(ServletRequest request,ServletResponse response)
		throws ServletException , IOException{
   

		response.setContentType("text/html");
		PrintWriter out = response.getWriter();

		// 编写JDBC代码，连接数据库，查询所有学生信息。
		Connection conn = null;
		PreparedStatement ps = null;
		ResultSet rs = null;
		try{
   
			// 注册驱动 （com.mysql.jdbc.Driver，这个已过时。）
			// 新版本中建议使用：com.mysql.cj.jdbc.Driver驱动。
			Class.forName("com.mysql.cj.jdbc.Driver");
			// 获取连接
			String url = "jdbc:mysql://localhost:3306/cooler";
			String user = "root";
			String password = "root";
			conn = DriverManager.getConnection(url,user,password);
			// 获取预编译的数据库操作对象
			String sql = "select no,name from t_student";
			ps = conn.prepareStatement(sql);
			// 执行SQL
			rs = ps.executeQuery();
			// 处理查询结果集
			while(rs.next()){
   
				String no = rs.getString("no");
				String name = rs.getString("name");
				//System.out.println(no + "," + name);
				out.print(no + "," + name + "<br>");
			}
		}catch(Exception e){
   
			e.printStackTrace();
		}finally{
   
			// 释放资源
			if(rs != null){
   
				try{
   
					rs.close();
				}catch(Exception e){
   
					e.printStackTrace();
				}
			}
			if(ps != null){
   
				try{
   
					ps.close();
				}catch(Exception e){
   
					e.printStackTrace();
				}
			}
			if(conn != null){
   
				try{
   
					conn.close();
				}catch(Exception e){
   
					e.printStackTrace();
				}
			}
		}
	}

	public void destroy(){
   
	
	}

	public String getServletInfo(){
   
		return "";
	}

	public ServletConfig getServletConfig(){
   
		return null;
	}
}

（二）使用IDEA工具开发Servlet

第一步：New Project
第二步：新建模块（File --> new --> Module…）
第三步：让Module变成JavaEE的模块。（让Module变成webapp的模块。符合webapp规范。符合Servlet规范的Module）
- 在Module上点击右键：Add Framework Support…（添加框架支持）
- 在弹出的窗口中，选择Web Application（选择的是webapp的支持）
- 选择了这个webapp的支持之后，IDEA会自动给你生成一个符合Servlet规范的webpp目录结构。
- 注意：在IDEA工具中根据Web Application模板生成的目录中有一个web目录，这个目录就代表webapp的根
第四步（非必须）：根据Web Application生成的资源中有index.jsp文件，这里选择删除这个index.jsp文件。
第五步：编写Servlet（StudentServlet）
- class StudentServlet implements Servlet
- 将CATALINA_HOME/lib/servlet-api.jar和jsp-api.jar添加到classpath当中（这里的classpath说的是IDEA的classpath）
  - File --> Project Structrue --> Modules --> + 加号 --> Add JARS…
- 实现jakarta.servlet.Servlet接口中的5个方法。
第六步：在Servlet当中的service方法中编写业务代码（我们这里连接数据库了。）

package servlet;

import jakarta.servlet.*;

import java.io.IOException;
import java.io.PrintWriter;
import java.sql.*;

/**
 * @author CoolEr
 * @create 2022/2/17
 */
public class StudentServlet implements Servlet {
   
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {
   

    }

    @Override
    public ServletConfig getServletConfig() {
   
        return null;
    }

    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
   
        //设置响应的内容类型
        servletResponse.setContentType("text/html");
        PrintWriter out = servletResponse.getWriter();
        //连接数据库
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
   
            //注册驱动
            Class c = Class.forName("com.mysql.cj.jdbc.Driver");
            //获取连接
            String url = "jdbc:mysql://localhost:3306/cooler";
            String user = "root";
            String password = "3399";

            conn = DriverManager.getConnection(url,user,password);
            //获取预编译的数据库操作对象
            String sql = "select cno,cname,cteacher from c";
            ps = conn.prepareStatement(sql);
            //执行sql
            rs = ps.executeQuery();
            //处理查询结果集
            while(rs.next()){
   
                String no = rs.getString("CNO");
                String cname = rs.getString("CNAME");
                String teacher = rs.getString("CTEACHER");
                out.print(no + "," + cname + "," + teacher + "<br>");
            }
        } catch (ClassNotFoundException e) {
   
            e.printStackTrace();
        } catch (SQLException e) {
   
            e.printStackTrace();
        } finally{
   
            //释放资源
            if (rs != null) {
   
                try {
   
                    rs.close();
                } catch (SQLException e) {
   
                    e.printStackTrace();
                }
            }
            if (ps != null) {
   
                try {
   
                    ps.close();
                } catch (SQLException e) {
   
                    e.printStackTrace();
                }
            }
            if (conn != null) {
   
                try {
   
                    conn.close();
                } catch (SQLException e) {
   
                    e.printStackTrace();
                }
            }
        }
    }

    @Override
    public String getServletInfo() {
   
        return null;
    }

    @Override
    public void destroy() {
   

    }
}

第七步：在WEB-INF目录下新建一个子目录：lib（这个目录名必须是全部小写的lib），并且将连接数据库的驱动jar包放到lib目录下。
第八步：在web.xml文件中完成StudentServlet类的注册。（请求路径和Servlet之间对应起来）

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <servlet>
        <servlet-name>studentServlet</servlet-name>
        <servlet-class>servlet.StudentServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>studentServlet</servlet-name>
        <url-pattern>/servlet/student</url-pattern>
    </servlet-mapping>
</web-app>

第九步：给一个html页面，在HTML页面中编写一个超链接，用户点击这个超链接，发送请求，Tomcat执行后台的StudentServlet。

（这个文件不能放到WEB-INF目录里面，只能放到WEB-INF目录外面。）

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>student</title>
</head>
<body>
    <!--这里的项目名是 /xmm ，无法动态获取，先写死-->
    <a href="/xmm/servlet/student">student list</a>
</body>
</html>

第十步：让IDEA工具去关联Tomcat服务器。关联的过程当中将webapp部署到Tomcat服务器当中。
- IDEA工具右上角，绿色小锤子右边有一个：Add Configuration
- 左上角加号，点击Tomcat Server --> local
- 在弹出的界面中设置服务器Server的参数（基本上不用动）
- 在当前窗口中有一个Deployment（点击这个用来部署webapp），继续点击加号，部署即可。
- 修改 Application context为：/xmm
第十一步：启动Tomcat服务器
- 在右上角有绿色的箭头，或者绿色的小虫子，点击这个绿色的小虫子，可以采用debug的模式启动Tomcat服务器。
- 开发中建议适用debug模式启动Tomcat
第十二步：打开浏览器，在浏览器地址栏上输入：http://localhost:8080/xmm/index.html

（三）Servlet对象的生命周期

1、Servlet对象的维护

Servlet对象的创建，对象上方法的调用，对象最终的销毁，Javaweb程序员是无权干预的。
Servlet对象的生命周期是由Tomcat服务器（WEB Server）全权负责的。
Tomcat服务器通常我们又称为：WEB容器。【WEB Container】
WEB容器来管理Servlet对象的死活。

2、思考：

自己new的Servlet对象受WEB容器的管理吗？

WEB容器创建的Servlet对象，这些Servlet对象都会被放到一个集合当中（HashMap），只有放到这个HashMap集合中的Servlet才能够被WEB容器管理，自己new的Servlet对象不会被WEB容器管理。（自己new的Servlet对象不在容器当中）
web容器底层应该有一个HashMap这样的集合，在这个集合当中存储了Servlet对象和请求路径之间的关系

3、研究

（1）服务器在启动的时候，Servlet对象有没有被创建出来（默认情况下）？

在Servlet中提供一个无参数的构造方法，启动服务器的时候看看构造方法是否执行。
经过测试得出结论：默认情况下，服务器在启动的时候Servlet对象并不会被实例化。
这个设计是合理的。用户没有发送请求之前，如果提前创建出来所有的Servlet对象，必然是耗费内存的，并且创建出来的Servlet如果一直没有用户访问，显然这个Servlet对象是一个废物，没必要先创建。

（2）让服务器启动的时候创建Servlet对象：

在servlet标签中添加<load-on-startup>子标签，在该子标签中填写整数，越小的整数优先级越高。

<servlet>
    <servlet-name>aservlet</servlet-name>
    <servlet-class>servlet.AServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>aservlet</servlet-name>
    <url-pattern>/a</url-pattern>
</servlet-mapping>

4、Servlet对象生命周期

默认情况下服务器启动的时候AServlet对象并没有被实例化

（1）用户发送第一次请求的时候，控制台输出了以下内容：

AServlet无参数构造方法执行了
AServlet's init method execute!
AServlet's service method execute!

根据以上输出内容得出结论：
- 用户在发送第一次请求的时候Servlet对象被实例化（AServlet的构造方法被执行了。并且执行的是无参数构造方法。）
- AServlet对象被创建出来之后，Tomcat服务器马上调用了AServlet对象的init方法。（init方法在执行的时候，AServlet对象已经被创建出来了。）
- 用户发送第一次请求的时候，init方法执行之后，Tomcat服务器马上调用AServlet对象的service方法。

（2）用户继续发送第二次请求，控制台输出了以下内容：

AServlet's service method execute!

根据以上输出结果得知，用户在发送第二次，或者第三次，或者第四次请求的时候，Servlet对象并没有新建，还是使用之前创建好的Servlet对象，直接调用该Servlet对象的service方法，这说明：
- 第一：Servlet对象是单例的（单实例的。但是要注意：Servlet对象是单实例的，但是Servlet类并不符合单例模式。我们称之为假单例。之所以单例是因为Servlet对象的创建javaweb程序员管不着，这个对象的创建只能是Tomcat来说了算，Tomcat只创建了一个，所以导致了单例，但是属于假单例。真单例模式构造方法是私有化的。）
- 第二：无参数构造方法、init方法只在第一次用户发送请求的时候执行。也就是说无参数构造方法只执行一次。init方法也只被Tomcat服务器调用一次。
- 第三：只要用户发送一次请求：service方法必然会被Tomcat服务器调用一次。发送100次请求，service方法会被调用100次。

（3）关闭服务器的时候，控制台输出了以下内容：

AServlet's destroy method execute!

通过以上输出内容，可以得出以下结论：
- Servlet的destroy方法只被Tomcat服务器调用一次。
- destroy方法是在服务器关闭的时候被调用。因为服务器关闭的时候要销毁AServlet对象的内存。服务器在销毁AServlet对象内存之前，Tomcat服务器会自动调用AServlet对象的destroy方法。
请问：destroy方法调用的时候，对象销毁了还是没有销毁呢？
- destroy方法执行的时候AServlet对象还在，没有被销毁。destroy方法执行结束之后，AServlet对象的内存才会被Tomcat释放。

（4）Servlet对象更像一个人的一生：

Servlet的无参数构造方法执行：标志着出生。
Servlet对象的init方法的执行：标志着正在接受教育。（初始化）
Servlet对象的service方法的执行：标志着已经开始工作，已经开始为人类提供服务。
Servlet对象的destroy方法的执行：标志着临终。（编写销毁前的准备）

（5）关于Servlet类中方法的调用次数

- 构造方法只执行一次。
- init方法只执行一次。
- service方法：用户发送一次请求则执行一次，发送N次请求则执行N次。
- destroy方法只执行一次。

（6）当Servlet类中编写一个有参数的构造方法，如果没有手动编写无参数构造方法会出现什么问题？

报错：500错误。500错误是一个HTTP协议的错误状态码。一般情况下是因为服务器端的Java程序出现了异常。（服务器端的错误都是500错误：服务器内部错误。）
如果没有无参数的构造方法，会导致出现500错误，无法实例化Servlet对象。
所以一定要注意：在Servlet开发当中，不建议程序员来定义构造方法，因为定义不当，一不小心就会导致无法实例化Servlet对象。

（7）Servlet的无参数构造方法是在对象第一次创建的时候执行，并且只执行一次。init方法也是在对象第一次创建的时候执行，并且只执行一次。无参数构造方法不能代替掉init方法——Servlet规范中有要求，作为javaweb程序员，编写Servlet类的时候，不建议手动编写构造方法，因为编写构造方法，很容易让无参数构造方法消失，这个操作可能会导致Servlet对象无法实例化。所以init方法是有存在的必要的。

（8）init、service、destroy方法中使用最多的方法

使用最多就是service方法，service方法是一定要实现的，因为service方法是处理用户请求的核心方法。
什么时候使用init方法呢？
- init方法很少用。
- 通常在init方法当中做初始化操作，并且这个初始化操作只需要执行一次。例如：初始化数据库连接池，初始化线程池…
什么时候使用destroy方法呢？
- destroy方法也很少用。
- 通常在destroy方法当中，进行资源的关闭。马上对象要被销毁了，还有什么没有关闭的，抓紧时间关闭资源。还有什么资源没保存的，抓紧时间保存一下。

（四）GenericServlet

1、编写一个Servlet类直接实现Servlet接口的缺点

我们只需要service方法，其他方法大部分情况下是不需要使用的。代码很丑陋。

2、适配器设计模式Adapter

编写一个GenericServlet类，这个类是一个抽象类，其中有一个抽象方法service。
- GenericServlet实现Servlet接口。
- GenericServlet是一个适配器。
- 以后编写的所有Servlet类继承GenericServlet，重写service方法即可。

3、思考：

（1）提供了一个GenericServlet之后，init方法还会执行，会执行GenericServlet类中的init方法。

（2）init方法是Tomcat服务器调用的。

（3）init方法中的ServletConfig对象是谁创建的？是谁传过来的？

都是Tomcat干的。
Tomcat服务器先创建了ServletConfig对象，然后调用init方法，将ServletConfig对象传给了init方法。

（4）Tomcat服务器伪代码：

public class Tomcat {
   
    public static void main(String[] args){
   
        // .....
        // Tomcat服务器伪代码
        // 创建LoginServlet对象（通过反射机制，调用无参数构造方法来实例化LoginServlet对象）
        Class clazz = Class.forName("servlet.LoginServlet");
        Object obj = clazz.newInstance();
        
        // 向下转型
        Servlet servlet = (Servlet)obj;
        
        // 创建ServletConfig对象
        // Tomcat服务器负责将ServletConfig对象实例化出来。
        // 多态（Tomcat服务器完全实现了Servlet规范）
        ServletConfig servletConfig = new org.apache.catalina.core.StandardWrapperFacade();
        
        // 调用Servlet的init方法
        servlet.init(servletConfig);
        
        // 调用Servlet的service方法
        // ....
        
    }
}

4、改造GenericServlet

import jakarta.servlet.*;

import java.io.IOException;

/**
 * GenericServlet 就是一个适配器。
 */
public abstract class GenericServlet implements Servlet {
   

    // 成员变量
    private ServletConfig config;

    /**
     * init方法中的ServletConfig对象是小猫咪创建好的。
     */
    @Override
    public final void init(ServletConfig config) throws ServletException {
   
        //System.out.println("servletConfig对象，小猫咪创建好的：" + config);
        this.config = config;
        // 调用init()方法
        this.init();
    }

    /**
     * 这个init方法是供子类重写的。
     */
    public void init(){
   

    }

    @Override
    public ServletConfig getServletConfig() {
   
        return config;
    }

    /**
     * 抽象方法，这个方法最常用。所以要求子类必须实现service方法。
     * @param servletRequest
     * @param servletResponse
     * @throws ServletException
     * @throws IOException
     */
    public abstract void service(ServletRequest servletRequest, ServletResponse servletResponse)
            throws ServletException, IOException;

    @Override
    public String getServletInfo() {
   
        return null;
    }

    @Override
    public void destroy() {
   

    }
}

（五）ServletConfig

1、什么是ServletConfig

jakarta.servlet.ServletConfig，是Servlet规范中的一员，是一个接口。
ServletConfig对象中封装了<servlet></servlet>标签中的配置信息。（web.xml文件中servlet的配置信息）
一个Servlet对应一个ServletConfig对象。
Servlet对象是Tomcat服务器创建，并且ServletConfig对象也是Tomcat服务器创建。默认情况下，他们都是在用户发送第一次请求的时候创建。
Tomcat服务器调用Servlet对象的init方法的时候需要传一个ServletConfig对象的参数给init方法。
ServletConfig接口的实现类是Tomcat服务器给实现的。（Tomcat服务器说的就是WEB服务器。）

2、ServletConfig接口常用的方法

public String getInitParameter(String name); // 通过初始化参数的name获取value
public Enumeration<String> getInitParameterNames(); // 获取所有的初始化参数的name
public ServletContext getServletContext(); // 获取ServletContext对象
public String getServletName