JavaWeb

JavaWeb

一：基本概念

1：前言

1-1：web

网页的意思，www.baidu.com

1-2：静态web

html，css，所有人可见的基本网页的骨架

1-3：动态web

jsp，当登录淘宝等网站后，网站给每个人返回的信息不同，依赖于大数据推送。

2：web应用程序

• 访问的程序，不管html，css还是其他，都在世界的某个角落部署着与之相对应的chengx
• 通过url访问程序
• web应用程序被web服务器，如tomcat支配
• web应用程序分为动态和静态
• web应用程序没有服务器是不行的

3：静态web

• html，css

4：动态web

• jsp
• 可以与数据库进行数据交互
• 传统的web引用会存在宕机维护

二：Web服务器

1：动态web技术

1-1：Asp

• 微软的----前后台代码高度集合----维护成本高

1-2：php

• 好用，垮平台，代码简单，功能强大
• 高并发性能不好

1-3：Jsp/Servlet

• sun的
• 支持高并发，高性能，高可用
• B/S，浏览器服务器架构
• 基于java

2：web服务器

1：IIS

• 微软的

2：TomCat

• 开源免费
• 轻量级服务器
• 适合中小型应用
• 适合初学者

三：Tomcat

1：下载和配置

1-1：url

http://tomcat.apache.org/

1-2：压缩包

• apache-tomcat-9.0.33-windows-x64.zip

1-3：解压

1-4 ：启动

D:\develope\server\java\tomcat\apache-tomcat-9.0.33\bin
startup.sh

1-5：停止

shutdown.sh

1-6 ：环境变量

2：讲解

2-1：解压文件讲解

bin	启动/停止
conf	配置-核心是server.xml
lib	以来的jar
logs	日志
webapps	web应用程序

2-2：端口问题

8080	tomcat
80	http
443	https
3306	mysql

2-3：server.xml讲解

<?xml version="1.0" encoding="UTF-8"?>
<Server port="8005" shutdown="SHUTDOWN">
  <Listener className="org.apache.catalina.startup.VersionLoggerListener" />
  <Listener className="org.apache.catalina.core.AprLifecycleListener" SSLEngine="on" />
  <Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" />
  <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />
  <Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />
  <GlobalNamingResources>
  
    <Resource name="UserDatabase" auth="Container"
              type="org.apache.catalina.UserDatabase"
              description="User database that can be updated and saved"
              factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
              pathname="conf/tomcat-users.xml" />
  </GlobalNamingResources>

  <Service name="Catalina">
    <!-- 端口 -->
    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />
    <!-- 引擎 -->
    <Engine name="Catalina" defaultHost="localhost">
      <Realm className="org.apache.catalina.realm.LockOutRealm">
        <Realm className="org.apache.catalina.realm.UserDatabaseRealm"
               resourceName="UserDatabase"/>
      </Realm>
      
      <!-- 主机 -->
      <Host name="localhost"  appBase="webapps"
            unpackWARs="true" autoDeploy="true">
        
        <!-- 日志目录 -->
        <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
               prefix="localhost_access_log" suffix=".txt"
               pattern="%h %l %u %t &quot;%r&quot; %s %b" />
      </Host>
    </Engine>
  </Service>
</Server>

2-4：webapps详解

ROOT	localhost:8080,tomcat默认
docs	文档
examples	示例

3：自定义web应用

• 1：复制-webapp下的ROOT，并且重命名aaa
• 2：留下WEB-INF，删除其他
• 3：新建html
• 4：访问localhost:8080/aaa

4：网站如何访问

• 1：输入域名，回车
• 2：先从本地解析域名，存在返回，不存在到DNS
• 3：DNS,全部的域名存放地
• 4：DNS解析域名，存在返回。

5：本地转域名

• 到C:\Windows\System32\drivers\etc修改hosts
• 在hosts中添加 127.0.0.1 www.test.com
• 到D:\develope\server\java\tomcat\apache-tomcat-9.0.33\conf修改server.xml

 <Host name="www.test.com"  appBase="webapps" unpackWARs="true" autoDeploy="true">

• 访问http://www.test.com:8080/

四：Http

1：是什么

• 超文本传输协议
• 文本–html，字符串
• 超文本-图片，音乐，视频，地图，定位
• 协议-请求-返回

2：历程

2-1：http1.0

• HTTP/1.0：客户端可以与web服务器连接后，只能获得一个web资源，断开连接。

2-2：http2.0

• HTTP/1.1：客户端可以与web服务器连接后，可以获得多个web资源。

3：请求

3-1：请求头

Request 
URL: https://m.baidu.com/ 请求路径
Request Method: GET 请求方式
Status Code: 200 OK 状态码
Remote Address: 220.181.38.130:443 请求地址

3-2：请求体

Accept: image/webp,image/apng,image/*,*/*;q=0.8 支持格式
Accept-Encoding: gzip, deflate, br 编码
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8 语言
Connection: keep-alive 保持连接
Cookie: 
Host: m.baidu.com 主机

3-3：请求方式

3-3-1 ：get

参数少，不安全，快

3-3-2：post

参数多，安全，慢

4：响应

4-1：响应头

Cache-Control: no-cache 缓存控制
Connection: keep-alive 断开或者连接
Content-Encoding: gzip 编码
Content-Type: text/html;charset=utf-8 字符集

4-2：响应体

accept-ranges: 支持类型
access-control-allow-origin: *
cache-control: max-age=2628000 缓存控制
content-length: 8265 文本长度
content-type: image/jpeg 文本类型
Connection	高速浏览器，请求完是断开还是保持连接
Host	表示主机
Refresh	告诉客户端多有刷新一次
Location	让网页重新定位

5：状态码

200	成功
3xx	重定向
4xx	找不到资源
5xx	服务器错误
502	网关错误

五：Maven

1：简介

• 配置和导入jar包
• 属于架构管理工具

2：核心思想

• 约定大于配置
• 如类的全列名，这样可以规范个人编程时候规范包名结构
• 导包方式固定

3：下载安装配置

https://maven.apache.org/
apache-maven-3.6.2-bin.zip

3-1：解压

3-2：环境变量

系统变量	M2_HOME	D:\develope\server\java\maven\apache-maven-3.6.2\bin	springboot等配置
系统变量	MAVEN_HOME	D:\develope\server\java\maven\apache-maven-3.6.2
	PATH	%MAVEN_HOME%\bin

4：目录解析

bin	启动
boot
conf	配置
lib	依赖

5：Conf解析

<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0   http://maven.apache.org/xsd/settings-1.0.0.xsd">
  
		<!-- 本地仓库地址 -->
		<localRepository>D:\develope\server\java\maven\repository</localRepository>

		<!-- 插件 -->
		<pluginGroups> </pluginGroups>

 		<!-- 代理 -->
		<proxies></proxies>

		<!-- 服务 -->
		<servers></servers>

		<!-- 阿里云镜像 -->
		<mirrors>	
				<mirror>
   				  <id>nexus-aliyun</id>
    				<mirrorOf>central</mirrorOf>
    				<name>Nexus aliyun</name>
    				<url>http://maven.aliyun.com/nexus/content/groups/public</url>
			</mirror>
	</mirrors>
  
		<profiles></profiles>
</settings>

6：配置maven

6-1：web项目

• 目录为src-main-webapp

6-2：标准项目

• 目录为
• src-main-java
• src-main-resource
• src-test-java

6-4：web项目目录

6-5：pom解析

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

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  
  <!-- maven版本 -->
  <modelVersion>4.0.0</modelVersion>
  
  <!-- 域名倒置 -->
  <groupId>com.chen</groupId>
  
   <!-- 项目名 -->
  <artifactId>demo1</artifactId>
  
   <!-- 项目版本 -->
  <version>1.0-SNAPSHOT</version>
  
   <!-- 打包方式 -->
   <!-- war-web；jar-java -->
  <packaging>war</packaging>

   <!-- 配置 -->
  <properties>
     <!-- 字符集 -->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    
    <!-- 编译依赖jdk1.7 -->  
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>
  
  <!-- 依赖 -->
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
    </dependency>
  </dependencies>
</project>

7：配置Tomcat

1：添加Tomcat讲解

2：添加项目讲解

8：Maven引用本地资源

<build>
      <resources>
        <resource>
            <directory>src/main/resources</directory>
            <excludes>
                <exclude>**/*.properties</exclude>
                <exclude>**/*.xml</exclude>
             </excludes>
            <filtering>false</filtering>
        </resource>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
    </resources>
</build>

9：替换Webapps版本

• 更改web.xml文件替换为webapps版本和Tomcat一致

<?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"
         metadata-complete="true">
</web-app>

六：Servlet

1：是什么

• sun的一门技术
• sun提供一个接口Servlet
• java类继承或者实现Servlet叫做servlet

2：怎么用

• 编写java类实现HttpServlet

• 将编写的程序部署到服务器（Tomcat）

• 继承关系MyServlet–（继承）–HttpServlet–（继承）–GenericServlet–（实现）–Servlet

1：示例应用

• 创建maven-web项目

• 导入依赖，删除src，编写model，实现父子工程

   <!-- servlet依赖 -->
   <!-- 父项目 -->
   <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>4.0.1</version>
    </dependency>

    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>javax.servlet.jsp-api</artifactId>
      <version>2.3.3</version>
    </dependency>

    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>

• 子项目

<parent>
    <artifactId>servlet</artifactId>
    <groupId>com.chen.servlet</groupId>
    <version>1</version>
 </parent>

• 子项目编写java-servlet程序

public class MyServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    PrintWriter writer = resp.getWriter();
    writer.print("hello");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    super.doPost(req, resp);
}
}

• web.xm依赖tomcat-config-web.xml更改格式

<?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"
         metadata-complete="true">
</web-app>

• web.xml注册servlet

<!-- 注册类名 -->
<servlet>
 	 <servlet-name>hello</servlet-name><!-- 自定义名字 -->
 	 <servlet-class>MyServlet</servlet-class><!-- 全列名 -->
</servlet>
<!-- 注册映射 -->
<servlet-mapping>
   	 <servlet-name>hello</servlet-name><!-- 自定义名字 -->
   	 <url-pattern>/hello</url-pattern><!-- 自定义路径 -->
</servlet-mapping>

• 绑定服务器

• 访问

http://localhost:8080/ser/hello

3：原理解析图

4：映射说明

4-1：一对一

<servlet>
  <servlet-name>hello</servlet-name>
  <servlet-class>MyServlet</servlet-class>
</servlet>
<servlet-mapping>
  <servlet-name>hello</servlet-name>
  <url-pattern>/hello</url-pattern>
</servlet-mapping>

4-2：多对一

<servlet>
  <servlet-name>hello</servlet-name>
  <servlet-class>MyServlet</servlet-class>
</servlet>
<servlet-mapping>
  <servlet-name>hello</servlet-name>
  <url-pattern>/hello</url-pattern>
</servlet-mapping>
<servlet-mapping>
  <servlet-name>hello</servlet-name>
  <url-pattern>/hello1</url-pattern>
</servlet-mapping>

4-3：一对通用

<servlet>
  <servlet-name>hello</servlet-name>
  <servlet-class>MyServlet</servlet-class>
</servlet>
  <servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
  </servlet-mapping>
  <servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello/*</url-pattern>
  </servlet-mapping>

4-4：默认路径

• 回取代index.jsp
• 全部返回为自定义的servlet
• 不建议使用

<servlet-mapping>
      <servlet-name>hello</servlet-name>
      <url-pattern>/*</url-pattern>
  </servlet-mapping>

4-5：通配

• 默认index.jsp
• 通配符xxx.aaa可以访问自定义的servlet

<servlet-mapping>
  <servlet-name>hello</servlet-name>
  <url-pattern>*.aaa</url-pattern>
</servlet-mapping>

4-6：自定义404

• 默认index.jsp
• 配置的自定义servlet优先级大于error优先级
• 当自定义的servlet无法访问的时候，才会访问自定义的error的servlet

<!-- 自定义servlet --> 
<servlet>
      <servlet-name>hello</servlet-name>
      <servlet-class>MyServlet</servlet-class>
  </servlet>
  <servlet-mapping>
      <servlet-name>hello</servlet-name>
      <url-pattern>*.aaa</url-pattern>
  </servlet-mapping>

<!-- 自定义error --> 
  <servlet>
      <servlet-name>error</servlet-name>
      <servlet-class>ErrorServlet</servlet-class>
  </servlet>
  <servlet-mapping>
      <servlet-name>error</servlet-name>
      <url-pattern>/</url-pattern>
  </servlet-mapping>

5：ServletContext

• 获取上下文
• 不同servlet之间的通信
• 数据共享

1：通信

<?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"
         metadata-complete="true">
<!-- 设置用户名 -- >
<servlet>
    <servlet-name>put</servlet-name>
    <servlet-class>com.chen.s2.PutServletContext</servlet-class>
</servlet>
<servlet-mapping>
      <servlet-name>put</servlet-name>
      <url-pattern>/put</url-pattern>
</servlet-mapping>

<!-- 得到用户名 -- >
<servlet>
    <servlet-name>get</servlet-name>
    <servlet-class>com.chen.s2.GetServletContext</servlet-class>
</servlet>
<servlet-mapping>
      <servlet-name>get</servlet-name>
      <url-pattern>/get</url-pattern>
</servlet-mapping>

</web-app>

public class PutServletContext extends HttpServlet {
    @Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String username = "张三";
        resp.getWriter().print(username);
        ServletContext context = this.getServletContext();
        context.setAttribute("username", username);
    }
}

public class GetServletContext extends HttpServlet {
    @Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        String username = (String) context.getAttribute("username");
      //字符集
        resp.setCharacterEncoding("utf-8");
      //格式  
      resp.setContentType("text/html");
        resp.getWriter().print("姓名："+username);
    }
}

2：获取初始化参数

<!-- 初始化参数 -->
<context-param>
  <param-name>param</param-name>
  <param-value>初始化参数</param-value>
</context-param>

<!-- 注册和和映射 -->
<servlet>
  <servlet-name>param</servlet-name>
  <servlet-class>com.chen.s2.GetParams</servlet-class>
</servlet>
<servlet-mapping>
  <servlet-name>param</servlet-name>
  <url-pattern>/param</url-pattern>
</servlet-mapping>

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    ServletContext context = this.getServletContext();
    String param = context.getInitParameter("param");
    resp.setContentType("text/html");
    resp.setCharacterEncoding("utf-8");
    resp.getWriter().print(param);
}

3：请求转发

<servlet>
    <servlet-name>dispactcher</servlet-name>
    <servlet-class>com.chen.s2.RequestDispatcher</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>dispactcher</servlet-name>
    <url-pattern>/dispactcher</url-pattern>
</servlet-mapping>

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    ServletContext context = this.getServletContext();
 		 //转发到param
    context.getRequestDispatcher("/param").forward(req, resp);
}

• url显示为

http://localhost:8080/s2/dispactcher

4：读取资源文件

• Properties

• 读取Resource目录下的资源文件

• properties

username:zhangsan
password:lisi

• web.xml

<servlet>
  <servlet-name>prop</servlet-name>
  <servlet-class>com.chen.s2.GetResource</servlet-class>
</servlet>
<servlet-mapping>
  <servlet-name>prop</servlet-name>
  <url-pattern>/prop</url-pattern>
</servlet-mapping>

• java

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    ServletContext context = this.getServletContext();
    InputStream in = context.getResourceAsStream("/WEB-INF/classes/db.properties");
    Properties properties = new Properties();
    properties.load(in);
    String username = properties.get("username").toString();
    resp.getWriter().print(username);
}

• 读取java目录下的文件
• 前提准备,修改pom

<build>
      <resources>
          <resource>
              <directory>src/main/resources</directory>
              <excludes>
                  <exclude>**/*.properties</exclude>
                  <exclude>**/*.xml</exclude>
              </excludes>
              <filtering>false</filtering>
          </resource>
          <resource>
              <directory>src/main/java</directory>
              <includes>
                  <include>**/*.properties</include>
                  <include>**/*.xml</include>
              </includes>
              <filtering>false</filtering>
          </resource>
      </resources>
</build>

• web.xml

<servlet>
  <servlet-name>prop</servlet-name>
  <servlet-class>com.chen.s2.GetResource</servlet-class>
</servlet>
<servlet-mapping>
  <servlet-name>prop</servlet-name>
  <url-pattern>/prop</url-pattern>
</servlet-mapping>

• java

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    ServletContext context = this.getServletContext();
    InputStream in = context.getResourceAsStream("/WEB-INF/classes/com/chen/s2/ab.properties");
    Properties properties = new Properties();
    properties.load(in);
    String username = properties.get("username").toString();
    resp.getWriter().print(username);
}

6：请求和响应

当浏览器向服务器发送请求的时候，Tomcat服务器会创建两个类

• 1：HttpServletRepsonse,给浏览器响应信息
• 2：HttpServletRequest，处理浏览器请求信息

1：HttpServletRepsonse

• 向浏览器写东西的方法

getOutputStream()
getWriter

• 设置一些格式，更方便浏览器展示返会

void setCharacterEncoding(String var1);
void setContentLength(int var1);
void setContentLengthLong(long var1);
void setContentType(String var1);
void setDateHeader(String var1, long var2);
void addDateHeader(String var1, long var2);
void setHeader(String var1, String var2);
void addHeader(String var1, String var2);
void setIntHeader(String var1, int var2);
void addIntHeader(String var1, int var2);

1：功能

• 文件下载
• 步骤

1：文件路径
2：文件名
3：设置浏览器支持下载
4：下载文件输入流-下载格式
5：创建缓冲区
6：获取OutputStream对象--可以将缓冲区中数据展示给浏览器
7：用OutputStream对象将缓冲区里面的数据展示给浏览器
8：关闭流

public class Down extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 1：文件路径
        String url = "D:\\develope\\tools\\ideacode\\servlet1\\s3-reponse\\src\\main\\resource\\idea.png";
      
        // 2：文件名
        String filename = url.substring(url.lastIndexOf("\\") + 1);
      
        // 3：设置浏览器支持下载,为防止中文乱码，设置文件名字符集
        resp.setHeader("Content-Disposition", "attachment;filename=" +  			   URLEncoder.encode(filename,"UTF-8"));
      
        // 4：下载文件输入流-下载格式
        FileInputStream in = new FileInputStream(url);
      
        // 5：创建缓冲区
        int len = 0;
        byte[] buffer = new byte[1024];
      
        // 6：获取OutputStream对象--可以将缓冲区中数据展示给浏览器
        ServletOutputStream out = resp.getOutputStream();
      
        // 7：用OutputStream对象将缓冲区里面的数据展示给浏览器
        while ((len = in.read(buffer)) > 0) {
            out.write(buffer, 0, len);
        }
      
        // 8：关闭流
        out.close();
        in.close();
    }
}

• 随机数字-略

2：重定向

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  resp.sendRedirect("success.jsp");
}

2：HttpServletRequest

1：转发

2：功能

public class Test extends HttpServlet {
  @Override
  protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
      req.setCharacterEncoding("UTF-8");
      resp.setCharacterEncoding("UTF-8");
      String username = req.getParameter("username");
      String password = req.getParameter("password");

      System.out.println(username);
      System.out.println(password);
      //转发
     req.getRequestDispatcher("success.jsp").forward(req, resp);
  }
}

<html>
  <body>
    <h2>登录页面</h2>
      <div id="login">
          <form action="${pageContext.request.contextPath}/login" method="post">
              账号：<input type="text" name="username" required><br>
              密码：<input type="password" name="password" required><br>
              爱好：
              <input type="checkbox" name="aihaos" value="1">1
              <input type="checkbox" name="aihaos" value="11">11
              <input type="checkbox" name="aihaos" value="111">111
              <input type="checkbox" name="aihaos" value="1111">1111
              <input type="checkbox" name="aihaos" value="11111">11111<br>
              <input type="submit"><br>
          </form>
      </div>
  </body>
</html>

7：转发和重定向

1：图例解析

• 转发

• 充定向

2：区别

1：不同

• 转发：url路径不变，状态码307。多为请求转发。
• 重定向，url路径变化，状态码302，多为重定向。

2：相同

• 都会存在页面跳转

七：Cookie&&Session

• 保存会话的两种技术为cookie和session

• 会话

• 浏览器（谷歌），访问服务器（www.baidu.com），查询相关信息，查询完毕，关闭谷歌。叫做一次会话

• 有状态会话

• 当用户访问了百度文库，登陆了账号，下次打开浏览器百度文库，默认登录成功，因为百度的服务器记下了用户的信息，这种情况可以理解为有状态会话

• cookie 服务器给客户端的信件,客户端访问服务器带着这个信件就好。

• session服务器技术-------服务器记得用户的信息，如账号密码，用户访问服务器，服务器自动匹配账号密码

1：cookie

public class TestCookie extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  
        req.setCharacterEncoding("UTF-8");
        resp.setCharacterEncoding("UTF-8");
      
      //得到请求的全部cookie
        Cookie[] cookies = req.getCookies();
        PrintWriter out = resp.getWriter();
        if (cookies != null) {
            out.print("上次访问时间==");
            for (int i = 0; i < cookies.length; i++) {
                Cookie cookie = cookies[i];
              
              //cookie的名字
                String name = cookie.getName();
                if ("time".equals(name)) {
                  
                  //cookie的值
                    String value = cookie.getValue();
                    String cookieTimeAsString = new Date(Long.parseLong(value)).toLocaleString();
                    out.print(cookieTimeAsString);
                }
                if ("aaa".equals(name)) {
                  
                  //解析中文，防止乱码
                    String value = URLDecoder.decode(cookie.getValue(), "utf-8");
                    out.print(value);
                }
            }
        } else {
            out.print("首次访问cookie");
        }
      //创建cookie
        Cookie time = new Cookie("time", System.currentTimeMillis() + "");
      
      //编码中文，防止乱码
        Cookie aaa = new Cookie("aaa", URLEncoder.encode("张三","UTF-8"));

      //添加cookie
        resp.addCookie(aaa);
        resp.addCookie(time);
    }
}

//设置cookie的过期时间为0，可以起到代码删除cookie的
Cookie cookie = new Cookie("time", System.currentTimeMillis() + "");
cookie.setMaxAge(0);
resp.addCookie(cookie);

1：cookie知识补充

• 一个cookie最多储存4KB的字符串
• 一个cookie只能保存一条信息
• 服务器向浏览器单次最多发送20个cookie
• 浏览器最多储存300个cookie
• cookie删除方式一：关闭浏览器
• cookie删除方式二：设置过期时间为0

2：其他知识补充

• 对于中文最好用URLEncoder.encode(“张鹏博”,“UTF-8”);处理

2：session

1：使用

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    req.setCharacterEncoding("UTF-8");
    resp.setCharacterEncoding("UTF-8");
    resp.setContentType("text/html;charset=UTF-8");
//得到session
    HttpSession session = req.getSession();
  //设置session
    session.setAttribute("name", "张三");
  //sessionid
    String id = session.getId();

  //session是新创建的
    if (session.isNew()) {
        resp.getWriter().write("Session创建成功，ID:"+id);
    } else {
        resp.getWriter().write("Session已经在服务器中存在，ID:"+id);
    }
}

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  
    HttpSession session = req.getSession();
  //手动删除session
    session.removeAttribute("name");
    session.invalidate();

    String name = session.getAttribute("name").toString();
    resp.getWriter().println("mingzi"+name);
}

<session-config>
    <!--xml配置session的过期时间是1分钟-->
    <session-timeout>1</session-timeout>
</session-config>

2：cookie和session区别

• session：当打卡浏览器并访问某个网站的一瞬间，服务器创建一个session，在此浏览器，无论采用多好窗口访问此网站，session都是一样的，这可能与其他浏览器访问该网站的session的又不同
• session可以手动注销，也可以自动过期，见上代码
• session可做用户登录，购物车等
• session可以保存用户的数据，数据类型可以是字符串也可以是对象
• session是服务器创建的保存到服务器
• cookie也是服务器创建的但是保存在浏览器

3：流程

八：Jsp

• Jsp------Java server page
• java服务器的页面
• jsp本质是servlet
• C:\Users\cheneteng.IntelliJIdea2018.3\system\tomcat\Unnamed_servlet1目录下会有一个work文件夹
• work下存在\Catalina\localhost\ROOT\org\apache\jsp文件夹
• jsp文件夹，存放的是jsp文件编译转换的java源代码和字节码
• 浏览器向服务器发送请求，，不管什么资源，其本质是在访问servlet
• jsp最终会被转换成java类

1：流程

2：jsp转换为java文件解析

• 同Servlet接口

• 内置方法

  public void _jspInit() {
  }

  public void _jspDestroy() {
  }

  public void _jspService(){
    
  }

• 内置对象

final javax.servlet.jsp.PageContext pagecontext;	//页面上下文
javax.servlet.http.HttpSession session = null; 		//session
final javax.servlet.ServletContext application;		//applicationContext
final javax.servlet.ServletConfig config;			//config
javax.servlet.jsp.JspWriter out = null;				//out
final java.lang.Object page = this;					//page:当前
HttpServletRequest request							//请求
HttpServletResponse response						//响应

• 输出页面增加的代码

response.setContextType("text/html");		//设置响应的页面类型
page.Context = _jspxfactory.getPageContext(this,request,response,null,true,8192,true);
_jspx_page_context = pageContext;
application = pageContext.getServletContext();
config = pafeContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
_jspx_out = out;

• 输出jsp中的java代码----原封不动输出

• 数据jsp中的html代码–out.write("\r\n")

3：JSP语法

1：变量和表达式

• <%= 变量或者表达式%>
• 将程序的输出发送到客户端
• 可以理解为System.out.println("")到浏览器

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <body>
    
  <%= new java.util.Date()%>
    
  <%-- 分割线 --%>
  <hr>

	<%= new java.lang.String("aaaaaaaaaaaaaaaaa") %>
  
  </body>
</html>

2：脚本片段

• <%–JSP脚本片段–%>
• 可以理解为for循环

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>

<body>
<%
    int i = 0;
%>
<%
    for (int j = 1; j <=100 ; j++) {
        i+=j;
    }
%>

<%= i %>
</body>
</html>

• 二,脚本片段简化

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>

<body>
<%
    int i = 0;
%>
<%
    for (int j = 1; j <=100 ; j++) {
        i+=j;

%>
<%
    }
%>
<%= i %>
</body>

</html>

• 三-优化脚本片段

<%  int i = 0;%>
<% for (int j = 1; j <= 100; j++) { %>
<%  i += j;%>
<%  } %>
<%= i %>

3：jsp声明

• <%! %>
• 可以理解为service中的业务逻辑

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<body>
  
<%! String a = "张三";%>
  
<%!public int sun(int aa,int b){
    return aa+b;
}%>
  
<%=sun(1,1) %>
<%=a %>
  
</body>
</html>

4：JSP指令

1：page

<%-- 导包 --%>
<%@ page import="java.util.Date" %>

<%-- 语言 --%>
<%@ page language="java" %>

<%-- 编码 --%>
<%@ page pageEncoding="utf-8" %>

<%-- 自定义500的错误 --%>
<%@ page errorPage="common/500.jsp" %>

• web.xml定制错误页面

<error-page>
    <error-code>404</error-code>
    <location>/common/404.jsp</location>
</error-page>
<error-page>
    <error-code>500</error-code>
    <location>/common/500.jsp</location>
</error-page>

2：include

• 抽取公共部分
• 方式一：抽取全部资源，放到一个页面，这种情况不能有相同的变量名字

<%@include file="common/head.jsp" %>
<hr>
<%= 1 / 1%>
<%@include file="common/wei.jsp" %>

• 方式二：也是整合引入的资源，这种情况，是多个页面拼接，本质是多个页面，可以有相同的变量名字

<body>
<jsp:include page="common/head.jsp" />
  
<%= 1/1%>
<%! int i =1;%>
<%= i %>
  
<jsp:include page="common/wei.jsp" />
</body>

</html>

5：JSP内置对象

1：9大内置对象

• jsp存在9大内置对象和4大作用域

• PageContext 存储数据

• Request （HttpServletRequest） 存储数据

• Response（HttpServletResponse）

• Session （HttpSession） 存储数据

• Application （ServletContext） 存储数据

• config （SevletConfig）

• out

• page （不用）

• exception

• 数据有效

pageContext 数据当前页面有效

request 数据再一次请求中有效，在转发中也有效。 如新闻

session 在浏览器打开网站的时候有效，关闭网站失效。如购物车

application 数据存储在服务器中，服务器宕机的时候回有效，这情况结合数据库比较好。如聊天记录

2：4大作用域

• pageContext – page域 --当前页面域

• request – request域–请求域

• session – session域–会话域

  • application – context–服务域

1：域对象范围

page<request<session<context

2：域对象作用

• 保存数据，实现数据共享

3：域对象方法

• setAttribute(“name”,Object) 保存数据
• getAttribute(“name”) 获取数据
• removeAttribute(“name”) 清除数据

6：标签—推荐JSTL

1：JSP标签

• jsp自带的标签比较少

<jsp:include page=””/> 引入，外部资源
<jsp:forword page=””/> 转发
<jsp:param> 参数

2：JSTL标签

• 因为jsp的标签功能比较单调，引入jstl来完善jsp的标签库
• 它封装了JSP应用的通用核心功能。
• JSTL支持通用的、结构化的任务，
• 比如迭代，条件判断，XML文档操作，国际化标签，SQL标签。
• 除了这些，它还提供了一个框架来使用集成JSTL的自定义标签。

jstl使用

1：引入

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

2:修复错误

在tomcat的lib中导入两个包

• jstl-1.2.jar

• standard-1.1.2.jar

3：EL表达式-

• 为了让jsp标签更简单
• jstl比el功能强大

1：取值

name=${name }

2：执行运算

${user==null}

3：获取web开发常用对象

九：JavaBean

• 要求

• 无参构造

• get和set方法

• 属性私有化

• 目的-ORM–对象关系映射，为了和数据库的字段映射

十：MVC

1：M

• model
• service 业务
• dao 操作数据库
• thirdarty 第三方
• domain 实体类javabean

2：V

• jsp 展示页面，用户操作页面

3：C

• controller负责页面转发和重定向，业务交给service，负责视图跳转

十一：过滤器

• 过滤网站的数据
• 如：处理中文乱码，登录等
• Filter- 同servlet

1：servlet

public class MyServlet extends HttpServlet {

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    resp.getWriter().print("你好世界");
}

@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    doGet(req, resp);
}
}

2：filter

• 特定请求都会被拦截，在web.xml中配置

public class MyFilter implements Filter {
public void init(FilterConfig filterConfig) throws ServletException {
    System.out.println("过滤器初始化。。。。。。。。。。。。。");
}

public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    servletRequest.setCharacterEncoding("UTF-8");
    servletResponse.setCharacterEncoding("UTF-8");
   //把拦截器放开，不能停止在一个拦截请求中，导致程序中止
    filterChain.doFilter(servletRequest,servletResponse);
}

public void destroy() {
    System.out.println("过滤器销毁。。。。。。。。。。。。。");
}
}

3：web.xml

<?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>myser</servlet-name>
    <servlet-class>com.chen.servlet.MyServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>myser</servlet-name>
    <url-pattern>/servlet/myser</url-pattern>
</servlet-mapping>
  
<servlet-mapping>
    <servlet-name>myser</servlet-name>
    <url-pattern>/myser</url-pattern>
</servlet-mapping>

<filter>
    <filter-name>myfil</filter-name>
    <filter-class>com.chen.filter.MyFilter</filter-class>
</filter>
  
<filter-mapping>
    <filter-name>myfil</filter-name>
    <url-pattern>/servlet/*</url-pattern>
</filter-mapping>
</web-app>

4：功能

• 处理字符集问题
• 可以拦截/servlet/myser的中文乱码问题
• 不可以拦截/myser的中文乱码

十二：监听器

• Listener
• 统计在线人数

1：listener

//统计在线人数
public class MyListener implements HttpSessionListener {
  public void sessionCreated(HttpSessionEvent se) {
      ServletContext context = se.getSession().getServletContext();
      Integer onlineCount = (Integer) context.getAttribute("onlineCount");
      if(onlineCount==null)
      {
          onlineCount = new Integer(1);
      }
      else{
          int count = onlineCount.intValue();
          onlineCount = new Integer(count+1);
      }
      context.setAttribute("onlineCount",onlineCount);
  }

  public void sessionDestroyed(HttpSessionEvent se) {
      System.out.println("监听器销毁");
  }
}

2：web.xml

<?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">

<listener>
    <listener-class>com.chen.listener.MyListener</listener-class>
</listener>
</web-app>

3：jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>$Title$</title>
</head>
<body>
<h1>当前在线人数<span style="color: blue">
    <%= this.getServletConfig().getServletContext().getAttribute("onlineCount")%>人
</span></h1>
</body>
</html>

4：session过期

1.手动销毁 getSession().invalidate();
2.自动销毁 
<session-config>
  <session-timeout>1</session-timeout>
</session-config>

十三：登录功能

1：登录

public class LoginServlet extends HttpServlet {

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    String username = req.getParameter("username");
    if (username.equals("admin")) {//成功
        req.getSession().setAttribute("USER_SESSION", req.getSession().getId());
        resp.sendRedirect("/sys/success.jsp");
    } else {//失败
        resp.sendRedirect("/error.jsp");

    }
}

@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    doGet(req, resp);
}
}

2：注销

public class LoginOutServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    req.getSession();
    Object user_session = req.getSession().getAttribute("USER_SESSION");
    if(user_session!=null){
        req.getSession().removeAttribute("USER_SESSION");
        resp.sendRedirect("/Login.jsp");
    }else {
        resp.sendRedirect("/Login.jsp");
    }
}

@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    doGet(req, resp);
}
}

3：过滤器

public class MyFilter implements Filter {
public void init(FilterConfig filterConfig) throws ServletException {

}

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    HttpServletRequest req = (HttpServletRequest) request;
    HttpServletResponse resp = (HttpServletResponse) response;
    if (req.getSession().getAttribute("USER_SESSION") == null) {
        resp.sendRedirect("/error.jsp");
    }
    chain.doFilter(request, response);
}

public void destroy() {

}
}

4：成功页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>成功</title>
</head>
<body>
<h1>主页</h1>
<a href="/servlet/loginout">注销</a>
</body>
</html>

5：失败页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>错误</title>
</head>
<body>
<h3>密码错误 </h3>
<a href="/Login.jsp"> 返回登录页面</a>
</body>
</html>

6：登录页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登录页</title>
</head>
<body>
<form action="/servlet/login" method="post">
    <input type="text" name="username">
    <input type="submit">
</form>
</body>
</html>

7：注册页面

<?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>login</servlet-name>
        <servlet-class>com.chen.servlet.LoginServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>login</servlet-name>
        <url-pattern>/servlet/login</url-pattern>
    </servlet-mapping>

    <servlet>
        <servlet-name>loginout</servlet-name>
        <servlet-class>com.chen.servlet.LoginOutServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>loginout</servlet-name>
        <url-pattern>/servlet/loginout</url-pattern>
    </servlet-mapping>


    <filter>
        <filter-name>MyFilter</filter-name>
        <filter-class>com.chen.filter.MyFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>MyFilter</filter-name>
        <url-pattern>/sys/*</url-pattern>
    </filter-mapping>
</web-app>

8：目录结构

十四：JDBC

1：使用

1. 加载驱动
2. 连接数据库，代表数据库
3. 向数据库发送SQL的对象Statement:CRUD
4. 编写SQL（根据业务，不同的SQL）
5. 执行SQL
6. 关闭连接

public static void main(String[] args) throws ClassNotFoundException, SQLException {
    //配置信息
    //useUnicode=true&characterEncoding=UTF-8 解决中文乱码
    String url = "jdbc:mysql://localhost:3306/test?user=root&password=&useUnicode=true&characterEncoding=UTF-8";
    String username = "root";
    String password = "password";

    //1.加载驱动
    Class.forName("com.mysql.jdbc.Driver");
    //2.连接数据库，代表数据库
    Connection connection = DriverManager.getConnection(url,username,password)

    //3.向数据库发送SQL的对象Statement： CRUD
    Statement statement = connection.createStatement();

    //4.编写SQL
    String sql = "select * from users";

    //5.执行查询SQL，返回一个ResultSet：结果集
    ResultSet rs = statement.executeQuery(sql);

    while(rs.next())
    {
        System.out.println("id="+rs.getObject("id"));
        System.out.println("name="+rs.getObject("name"));
    }

    //6.关闭连接：释放资源（一定要做）先开后关
    rs.close();
    statement.close();
    connection.close();
}

//增删改都用executeUpdate即可

2：编写sql

public static void main(String[] args) throws ClassNotFoundException, SQLException {
      //配置信息
      //useUnicode=true&characterEncoding=UTF-8 解决中文乱码
      String url = "jdbc:mysql://localhost:3306/test?user=root&password=&useUnicode=true&characterEncoding=UTF-8";
      String username = "root";
      String password = "password";

      //1.加载驱动
      Class.forName("com.mysql.jdbc.Driver");
      //2.连接数据库，代表数据库
      Connection connection = DriverManager.getConnection(url,username,password);

      //3.编写SQL
      String sql = "insert into users(id,name,password,email,birthday) values (?,?,?,?,?)";

      //预编译
      PreparedStatement preparedStatement = connection.prepareStatement(sql);

      preparedStatement.setInt(1,4);//给第一个占位符？赋值为1
      preparedStatement.setString(2,"Krito");//给第二个占位符？赋值为Krito
      preparedStatement.setString(3,"123456");
      preparedStatement.setString(4,"krito@qq.com");
      preparedStatement.setDate(5,new Date(new java.util.Date().getTime()));

      //5.执行SQL
      int i = preparedStatement.executeUpdate();
      if(i<0)
      {
          System.out.println("输入成功");
      }

      //6.关闭连接：释放资源（一定要做）先开后关
      preparedStatement.close();
      connection.close();
  }

3：事务

要么都成功，要么都失败

​ ACID原则：保证数据的安全。

• 开启事务
• 事务提交 commit()
• 事务回滚 rollback()
• 关闭事务

Common

1：pom

<dependencies>
    <!--servlet-->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>2.5</version>
    </dependency>

    <!--jsp-->
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>javax.servlet.jsp-api</artifactId>
        <version>2.3.3</version>
    </dependency>

    <dependency>
        <groupId>javax.servlet.jsp.jstl</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>

    <dependency>
        <groupId>taglibs</groupId>
        <artifactId>standard</artifactId>
        <version>1.1.2</version>
    </dependency>
  
    <!--mysql的驱动-->
    <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>5.1.47</version>
      </dependency>
</dependencies>

2：servlet

<!-- 注册类名 -->
<servlet>
 	 <servlet-name>hello</servlet-name><!-- 自定义名字 -->
 	 <servlet-class>MyServlet</servlet-class><!-- 全列名 -->
</servlet>
<!-- 注册映射 -->
<servlet-mapping>
   	 <servlet-name>hello</servlet-name><!-- 自定义名字 -->
   	 <url-pattern>/hello</url-pattern><!-- 自定义路径 -->
</servlet-mapping>

3：filter

<filter>
    <filter-name>myfil</filter-name>
    <filter-class>com.chen.filter.MyFilter</filter-class>
</filter>
  
<filter-mapping>
    <filter-name>myfil</filter-name>
    <url-pattern>/servlet/*</url-pattern>
</filter-mapping>

4：listener

<listener>
    <listener-class>com.chen.listener.MyListener</listener-class>
</listener>

Date(5,new Date(new java.util.Date().getTime()));

  //5.执行SQL
  int i = preparedStatement.executeUpdate();
  if(i<0)
  {
      System.out.println("输入成功");
  }

  //6.关闭连接：释放资源（一定要做）先开后关
  preparedStatement.close();
  connection.close();

}

### 3：事务

 	要么都成功，要么都失败

​	ACID原则：保证数据的安全。

- 开启事务
- 事务提交 commit() 
- 事务回滚 rollback()
- 关闭事务

# Common

## 1：pom

```jsp
<dependencies>
    <!--servlet-->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>2.5</version>
    </dependency>

    <!--jsp-->
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>javax.servlet.jsp-api</artifactId>
        <version>2.3.3</version>
    </dependency>

    <dependency>
        <groupId>javax.servlet.jsp.jstl</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>

    <dependency>
        <groupId>taglibs</groupId>
        <artifactId>standard</artifactId>
        <version>1.1.2</version>
    </dependency>
  
    <!--mysql的驱动-->
    <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>5.1.47</version>
      </dependency>
</dependencies>

2：servlet

<!-- 注册类名 -->
<servlet>
 	 <servlet-name>hello</servlet-name><!-- 自定义名字 -->
 	 <servlet-class>MyServlet</servlet-class><!-- 全列名 -->
</servlet>
<!-- 注册映射 -->
<servlet-mapping>
   	 <servlet-name>hello</servlet-name><!-- 自定义名字 -->
   	 <url-pattern>/hello</url-pattern><!-- 自定义路径 -->
</servlet-mapping>

3：filter

<filter>
    <filter-name>myfil</filter-name>
    <filter-class>com.chen.filter.MyFilter</filter-class>
</filter>
  
<filter-mapping>
    <filter-name>myfil</filter-name>
    <url-pattern>/servlet/*</url-pattern>
</filter-mapping>

4：listener

<listener>
    <listener-class>com.chen.listener.MyListener</listener-class>
</listener>