Web基础笔记

JavaWeb

1 基本概念

1.1 前言

web开发：

web，网页的意思， www.baidu.com

静态web：

html，css
提供给所有人看的数据始终不会发生变化！

动态web：

淘宝，几乎是所有的网站；
提供给所有人看的数据始终会发生变化，每个人在不同的时间，不同的地点看到的信息各不相同！
技术栈：Servlet/JSP，ASP，PHP 在Java中，动态web资源开发的技术统称为JavaWeb；

1.2 web应用程序

web应用程序：可以提供浏览器访问的程序；

a.html、b.html......多个web资源，这些web资源可以被外界访问，对外界提供服务；
你们能访问到的任何一个页面或者资源，都存在于这个世界的某一个角落的计算机上。
URL
这个统一的web资源会被放在同一个文件夹下，web应用程序-->Tomcat：服务器
一个web应用由多部分组成（静态web，动态web）
- html，css，js
- jsp，servlet
- Java程序
- jar包
- 配置文件（Properties）

web应用程序编写完毕后，若想提供给外界访问：需要一个服务器来统一管理；

1.3 静态web

*.htm, *.html,这些都是网页的后缀，如果服务器上一直存在这些东西，我们就可以直接进行读取。通络；
静态web存在的缺点
- Web页面无法动态更新，所有用户看到都是同一个页面
  - 轮播图，点击特效：伪动态
  - JavaScript [实际开发中，它用的最多]
  - VBScript
- 它无法和数据库交互（数据无法持久化，用户无法交互）

1.4 动态web

页面会动态展示： “Web的页面展示的效果因人而异”；

缺点：

加入服务器的动态web资源出现了错误，我们需要重新编写我们的后台程序,重新发布；
停机维护

优点：

Web页面可以动态更新，所有用户看到都不是同一个页面
它可以与数据库交互（数据持久化：注册，商品信息，用户信息........）

2 web服务器

2.1 技术讲解

ASP:

微软：国内最早流行的就是ASP；
在HTML中嵌入了VB的脚本， ASP + COM；
在ASP开发中，基本一个页面都有几千行的业务代码，页面极其换乱维护成本高！
C#
IIS

<%
	System.out.println("hello")
%>

php：

PHP开发速度很快，功能很强大，跨平台，代码很简单（70% , WP）
无法承载大访问量的情况（局限性）

JSP/Servlet :

B/S：浏览和服务器
C/S: 客户端和服务器
- sun公司主推的B/S架构
- 基于Java语言的 (所有的大公司，或者一些开源的组件，都是用Java写的)
- 可以承载三高问题带来的影响；
- 语法像ASP ， ASP-->JSP , 加强市场强度；

.....

2.2 web服务器

服务器是一种被动的操作，用来处理用户的一些请求和给用户一些响应信息；

IIS

微软的； ASP...,Windows中自带的

Tomcat

Tomcat 是Apache 软件基金会（Apache Software Foundation）的Jakarta 项目中的一个核心项目，最新的Servlet 和JSP 规范总是能在Tomcat 中得到体现，因为Tomcat 技术先进、性能稳定，而且免费，因而深受Java 爱好者的喜爱并得到了部分软件开发商的认可，成为目前比较流行的Web 应用服务器。

Tomcat 服务器是一个免费的开放源代码的Web 应用服务器，属于轻量级应用服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP 程序的首选。对于一个Java初学web的人来说，它是最佳的选择

Tomcat 实际上运行JSP 页面和Servlet。

....

工作3-5年之后，可以尝试手写Tomcat服务器；

下载tomcat：

安装 or 解压
了解配置文件及目录结构
这个东西的作用

3 Tomcat

3.1 安装tomcat

tomcat官网：http://tomcat.apache.org/

3.2 Tomcat启动和配置

文件夹作用：

启动，关闭Tomcat

访问测试：http://localhost:8080/

可能遇到的问题：

Java环境变量没有配置
闪退问题：需要配置兼容性
乱码问题：配置文件中设置

3.3 server.xml配置

可以配置启动的端口号

tomcat的默认端口号为：8080
mysql：3306
http：80
https：443

    <Connector port="8081" protocol="HTTP/1.1"
    	connectionTimeout="20000"
    	redirectPort="8443" />

可以配置主机的名称

默认的主机名为：localhost->127.0.0.1
默认网站应用存放的位置为：webapps

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

3.4 高难度面试题

请你谈谈网站是如何进行访问的！

输入一个域名；回车
检查本机的 C:\Windows\System32\drivers\etc\hosts配置文件下有没有这个域名映射；
1. 有：直接返回对应的ip地址，这个地址中，有我们需要访问的web程序，可以直接访问
```
    127.0.0.1 www.qinjiang.com
```
1. 没有：去DNS服务器找，找到的话就返回，找不到就返回找不到；

可以配置一下环境变量（可选）方便随时使用，不过一般用不到黑窗口

3.5 发布一个web网站

不会就先模仿

将自己写的网站，放到服务器(Tomcat)中指定的web应用的文件夹（webapps）下，就可以访问了

网站应该有的结构

--webapps ：Tomcat服务器的web目录
    -ROOT
    -yzhstudy ：网站的目录名
        - WEB-INF
            -classes : java程序
            -lib：web应用所依赖的jar包
        	-web.xml ：网站配置文件
        - index.html 默认的首页
        - static
            -css
            -style.css
            -js
            -img
        -.....

HTTP协议：面试

Maven：构建工具

Maven安装包

Servlet 入门

HelloWorld！
Servlet配置
原理

4 Http

4.1 什么是HTTP

HTTP（超文本传输协议）是一个简单的请求-响应协议，它通常运行在TCP之上。

文本：html，字符串，~ ….
超文本：图片，音乐，视频，定位，地图…….
80

Https：安全的超文本传输协议

4.2 两个时代

http1.0

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

http2.0

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

4.3 Http请求

客户端---发请求（Request）---服务器

百度为例：

Request URL:https://www.baidu.com/ 请求地址
Request Method:GET get方法/post方法
Status Code:200 OK 状态码：200
Remote（远程） Address:14.215.177.39:443

Accept:text/html
Accept-Encoding:gzip, deflate, br
Accept-Language:zh-CN,zh;q=0.9 语言
Cache-Control:max-age=0
Connection:keep-alive

4.3.1 请求行

请求行中的请求方式：GET

请求方式：Get，Post，HEAD，DELETE，PUT，TRACT…
- get：请求能够携带的参数比较少，大小有限制，会在浏览器的URL地址栏显示数据内容，不安全，但高效
- post：请求能够携带的参数没有限制，大小没有限制，不会在浏览器的URL地址栏显示数据内容，安全，但不高效。

4.3.2 消息头

Accept：告诉浏览器，它所支持的数据类型
Accept-Encoding：支持哪种编码格式 GBK UTF-8 GB2312 ISO8859-1
Accept-Language：告诉浏览器，它的语言环境
Cache-Control：缓存控制
Connection：告诉浏览器，请求完成是断开还是保持连接
HOST：主机

4.4 Http响应

服务器---响应-----客户端

百度为例：

Cache-Control:private 缓存控制
Connection:Keep-Alive 连接
Content-Encoding:gzip 编码
Content-Type:text/html 类型

4.4.1 响应体

Accept：告诉浏览器，它所支持的数据类型
Accept-Encoding：支持哪种编码格式 GBK UTF-8 GB2312 ISO8859-1
Accept-Language：告诉浏览器，它的语言环境
Cache-Control：缓存控制
Connection：告诉浏览器，请求完成是断开还是保持连接
HOST：主机..../.
Refresh：告诉客户端，多久刷新一次；
Location：让网页重新定位；

4.4.2 响应状态码

200：请求响应成功 200

3xx：请求重定向重定向：你重新到我给你新位置去；

4xx：找不到资源 404 资源不存在；

5xx：服务器代码错误 500 502:网关错误

4.5 常见面试题

当你的浏览器中地址栏输入地址并回车的一瞬间到页面能够展示回来，经历了什么？

5 Maven

为什么要学习这个技术？

在Javaweb开发中，需要使用大量的jar包，我们需要手动去导入；
如何能够让一个东西自动帮我导入和配置这个jar包；
由此，Maven诞生了！

5.1 Maven项目架构管理工具

作用：

用来就是方便导入jar包

Maven的核心思想：约定大于配置

有约束，不要去违反。
Maven会规定好你该如何去编写我们的Java代码，必须要按照这个规范来；

5.2 下载安装Maven

官网：https://maven.apache.org/

下载完成后，解压即可；

友情建议：电脑上的所有环境都放在一个文件夹下，方便管理；

5.3 配置环境变量

在我们的系统环境变量中

配置如下配置：

M2_HOME maven目录下的bin目录
MAVEN_HOME maven的目录
在系统的path中配置 %MAVEN_HOME%\bin

测试Maven是否安装成功

mvn -version

5.4 阿里云镜像

作用：加速我们的下载

镜像：mirrors
国内建议使用阿里云的镜像

<mirrors>
    <mirror>
        <!--该镜像的id-->
        <id>nexus-aliyun</id>
        <!--该镜像用来取代的远程仓库，也可以使用central作为中央仓库的id-->
        <mirrorOf>*,!jeecg,!jeecg-snapshots</mirrorOf>
        <name>Nexus aliyun</name>
        <!--该镜像的仓库地址，这里是用的阿里的仓库-->
        <url>http://maven.aliyun.com/nexus/content/groups/public</url>
    </mirror>
</mirrors>

5.5 本地仓库

在本地的仓库，还有一个远程仓库；

建立一个本地仓库：localRepository

<localRepository>D:\Environment\apache-maven-3.6.2\maven-repo</localRepository>

5.6 Maven命令

#查看maven的版本号
mvn –v

#自动帮我们到Maven中央仓库下载缺省的或者Maven中央仓库更新的各种配置文件和类库（jar包)到Maven本地仓库中。
mvn help:system

5.7 在IDEA中使用模板创建Maven项目

创建一个Maven项目

Bundled (Maven 3)或 Bundled (Maven 2)为IDEA自带Maven
等待项目初始化完毕
IDEA中的Maven设置

注意：IDEA项目创建成功后，看一眼Maven的配置

5.8 在IDEA中创建普通Maven项目

改版本为纯净版，没有多余的依赖

1、创建一个无模板的Maven项目

2、设置项目名称地址等信息

3、创建完成

5.9 标记文件夹功能

方法1：

方法2：

5.10 在IDEA中配置Tomcat

别使用模板里面的，点击+后时候自己创建

解决警告问题

为什么会有这个问题：我们访问一个网站，需要指定一个文件夹名字；

配置完后点击运行即可

5.11 pom文件

pom.xml 是Maven的核心配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!--Maven版本和头文件-->
<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">
  <modelVersion>4.0.0</modelVersion>

  <!--这里是配置的GAV-->
  <groupId>org.yzh</groupId>
  <artifactId>Maven01</artifactId>
  <version>1.0-SNAPSHOT</version>
  <!--packaging：项目的打包方式
    jar：java应用
    war：JavaWeb应用
  -->
  <packaging>war</packaging>

  <!-- 这两行甚至可以删除-->
  <name>Maven01 Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <!--配置-->
  <properties>
    <!--项目的默认构建编码-->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <!--编码版本-->
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <!--项目依赖-->
  <dependencies>
    <!--具体依赖的jar包配置文件-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <!--项目构建用的东西-->
  <build>
    <finalName>Maven01</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

Maven的高级之处在于,他会帮你导入这个JAR包所依赖的其他JAR包

5.12 Maven可能运到的问题

maven由于他的约定大于配置，我们之后可以能遇到我们写的配置文件，无法被导出或者生效的问题。

解决方案：

<!--在build中配置resources，来防止我们资源导出失败的问题-->
<build>
    <resources>
      <resource>
        <directory>src/main/resources</directory>
        <includes>
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <filtering>true</filtering>
      </resource>
      <resource>
        <directory>src/main/java</directory>
        <includes>
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <filtering>true</filtering>
      </resource>
    </resources>
</build>

5.13 IDEA查看Maven依赖关系图

5.14 Web项目中的web.xml版本

web.xml4.0版本的备忘

<?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">
    <display-name>Archetype Created Web Application</display-name>
</web-app>

web.xml3.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_3_1.xsd" version="3.1">
    <display-name>Archetype Created Web Application</display-name>
</web-app>

5.15 Maven仓库的使用

官网：https://mvnrepository.com/

注意：选择使用人数多的使用

6 Servlet

6.1 什么是Servlet

Servlet就是sun公司开发动态web的一门技术

Sun在这些API中提供一个接口叫做：Servlet，如果你想开发一个Servlet程序，只需要完成两个小步骤：

编写一个类，实现Servlet接口
把开发好的Java类部署到web服务器中。

把实现了Servlet接口的Java程序叫做，Servlet

6.2 HelloServlet

在Serlvet接口中，Sun公司有两个默认的实现类：HttpServlet，GenericServlet

步骤：

构建一个普通的Maven项目，删掉里面的src目录，以后我们的学习就在这个项目里面建立 Moudel；这个空的工程就是Maven主工程；

关于Maven父子工程的理解：

父项目中会有

    <modules>
    	<module>servlet-01</module>
    </modules>

子项目会有

    <parent>
        <artifactId>javaweb-02-servlet</artifactId>
        <groupId>com.yzh</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>

父项目中的java或依赖子项目可以直接使用

Maven环境优化
- 修改web.xml为最新的
- 将maven的结构搭建完整（java，resources，标记目录）

编写一个Servlet程序

编写一个普通类

实现Servlet接口，这里我们直接继承HttpServlet

public class HelloServlet extends HttpServlet {
    //由于get或者post只是请求实现的不同的方式，可以相互调用，业务逻辑都一样；
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("DoGet方式启动");
        PrintWriter out = resp.getWriter();
        out.print("Hello World 你好！");
    }

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

编写Servlet的映射

为什么需要映射？

因为写的是JAVA程序，但是要通过浏览器访问，而浏览器需要连接web服务器，所以我们需要再web服务中注册我们写的Servlet，还需配置一个浏览器能够访问的路径；

<!--注册Servlet-->
<servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>com.yzh.servlet.HelloServlet</servlet-class>
</servlet>
<!--Servlet的请求路径-->
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>

配置Tomcat

注意：配置项目发布的路径即可
启动测试，创建Servlet完成！

6.3 Servlet原理

Servlet是由Web服务器调用，web服务器在收到浏览器请求之后，会：

6.4 Mapping问题

一个Servlet可以指定一个映射路径

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

一个Servlet可以指定多个映射路径

<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello1</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello2</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello3</url-pattern>
</servlet-mapping

一个Servlet可以指定通用映射路径

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

默认请求路径（会覆盖之前默认的）

<!--默认请求路径-->
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/*</url-pattern>
</servlet-mapping>

指定一些后缀或者前缀等等….

<!--可以自定义后缀实现请求映射
注意点，*前面不能加项目映射的路径
/111.do
-->
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>*.do</url-pattern>
</servlet-mapping>

优先级问题

指定了固有的映射路径优先级最高，如果找不到就会走默认的处理请求；

<!--404-->
<servlet>
    <servlet-name>error</servlet-name>
    <servlet-class>com.yzh.servlet.ErrorServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>error</servlet-name>
    <url-pattern>/*</url-pattern>
</servlet-mapping>

6.5 ServletContext

web容器在启动的时候，它会为每个web程序都创建一个对应的ServletContext对象，它代表了当前的 web应用；

6.5.1 共享数据

我在这个Servlet中保存的数据，可以在另外一个servlet中拿到；

public class HelloServlet extends HttpServlet {
    //由于get或者post只是请求实现的不同的方式，可以相互调用，业务逻辑都一样；
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");  //设置请求参数内容编码，防止服务器在取内容时会默认使用其他编码解码
        resp.setCharacterEncoding("utf-8");  //服务器响应的内容用utf-8解码成二进制流传给客户端
        resp.setContentType("text/html; charset=utf-8");   //设置内容的编码格式，浏览器将用这个编码来编码二进制数据，展示。
        System.out.println("DoGet方式启动");

        ServletContext context = this.getServletContext();
        // 将一个数据保存在了ServletContext中，名字为：username 。值：“小明”
        context.setAttribute("username","小明");

        PrintWriter out = resp.getWriter();
        out.print("Hello World 你好！");
    }

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

public class GetServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html; charset=utf-8");   //设置内容的编码格式，浏览器将用这个编码来编码二进制数据，展示。
        ServletContext context = this.getServletContext();
        String username = (String)context.getAttribute("username");

        resp.getWriter().print("姓名：" + username);
    }

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

  <!--注册Servlet-->
  <servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>com.yzh.servlet.HelloServlet</servlet-class>
  </servlet>
  <!--Servlet的请求路径-->
  <servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
  </servlet-mapping>

  <servlet>
    <servlet-name>getc</servlet-name>
    <servlet-class>com.yzh.servlet.GetServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>getc</servlet-name>
    <url-pattern>/getc</url-pattern>
  </servlet-mapping>

测试访问结果；

6.5.2 获取初始化参数

在web.xml中

<context-param>
    <param-name>url</param-name>
    <param-value>jdbc:mysql://localhost:3306/mybatis</param-value>
</context-param>

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

6.5.3 请求转发

@Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("进入了ServletDemo02");
        resp.setContentType("text/html; charset=utf-8");
        ServletContext context = this.getServletContext();
        //转发的请求路径
        //RequestDispatcher requestDispatcher = context.getRequestDispatcher("/hello"); 
        //调用forward实现请求转发；
        //requestDispatcher.forward(req, resp);
        
        //合并成一句
        context.getRequestDispatcher("/hello").forward(req, resp);
    }

6.5.4 读取资源文件

Properties

在java目录下新建properties
在resources目录下新建properties

发现：都被打包到了同一个路径下：classes，我们俗称这个路径为classpath

思路：需要一个文件流；

db.properties

username=root
password=123456

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    //InputStream is = this.getServletContext().getResourceAsStream("/WEB-INF/classes/db.properties");
    InputStream is = this.getServletContext().getResourceAsStream("/WEB-INF/classes/com/yzh/servlet/aa.properties");

    Properties prop = new Properties();
    //加载文件
    prop.load(is);

    String name = prop.getProperty("username");
    String pwd = prop.getProperty("password");

    resp.getWriter().print(name + ":" + pwd);

}

java路径下的资源文件需要设置pom.xml配置文件，否则读取不到

<!--在build中配置resources，来防止我们资源导出失败的问题-->
<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

6.6 HttpServletResponse

web服务器接收到客户端的http请求，针对这个请求，需要创建两个对象，一个是代表请求的HttpServletRequest对象，一个是代表响应的HttpServletResponse对象；

如果要获取客户端请求过来的参数：使用HttpServletRequest
如果要给客户端响应一些信息：使用HttpServletResponse

分析源码:

6.6.1 简单分类

负责向浏览器发送数据的方法

ServletOutputStream getOutputStream() throws IOException;
PrintWriter getWriter() throws IOException;

负责向浏览器发送响应头的方法

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);

响应的状态码（只需要记简单的几个）

int SC_CONTINUE = 100;
int SC_SWITCHING_PROTOCOLS = 101;
int SC_OK = 200;
int SC_CREATED = 201;
int SC_ACCEPTED = 202;
int SC_NON_AUTHORITATIVE_INFORMATION = 203;
int SC_NO_CONTENT = 204;
int SC_RESET_CONTENT = 205;
int SC_PARTIAL_CONTENT = 206;
int SC_MULTIPLE_CHOICES = 300;
int SC_MOVED_PERMANENTLY = 301;
int SC_MOVED_TEMPORARILY = 302;
int SC_FOUND = 302;
int SC_SEE_OTHER = 303;
int SC_NOT_MODIFIED = 304;
int SC_USE_PROXY = 305;
int SC_TEMPORARY_REDIRECT = 307;
int SC_BAD_REQUEST = 400;
int SC_UNAUTHORIZED = 401;
int SC_PAYMENT_REQUIRED = 402;
int SC_FORBIDDEN = 403;
int SC_NOT_FOUND = 404;
int SC_METHOD_NOT_ALLOWED = 405;
int SC_NOT_ACCEPTABLE = 406;
int SC_PROXY_AUTHENTICATION_REQUIRED = 407;
int SC_REQUEST_TIMEOUT = 408;
int SC_CONFLICT = 409;
int SC_GONE = 410;
int SC_LENGTH_REQUIRED = 411;
int SC_PRECONDITION_FAILED = 412;
int SC_REQUEST_ENTITY_TOO_LARGE = 413;
int SC_REQUEST_URI_TOO_LONG = 414;
int SC_UNSUPPORTED_MEDIA_TYPE = 415;
int SC_REQUESTED_RANGE_NOT_SATISFIABLE = 416;
int SC_EXPECTATION_FAILED = 417;
int SC_INTERNAL_SERVER_ERROR = 500;
int SC_NOT_IMPLEMENTED = 501;
int SC_BAD_GATEWAY = 502;
int SC_SERVICE_UNAVAILABLE = 503;
int SC_GATEWAY_TIMEOUT = 504;
int SC_HTTP_VERSION_NOT_SUPPORTED = 505;

6.6.2 下载文件

获取下载文件的路径和文件名
设置支持浏览器下载的配置
获取下载文件的输入流
创建缓冲区
获取OutputStream对象
将FileOutputStream流写入到buffer缓冲区
使用OutputStream将缓冲区中的数据输出到客户端

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    // 1.获取下载文件的路径和文件名
    String realPath = "E:\\Maven02\\response\\src\\main\\resources\\关键字.png";
    System.out.println("下载文件的路径："+realPath);
    //技巧：获取最后一个斜杠后面的的内容
    String filename = realPath.substring(realPath.lastIndexOf("\\") + 1);
    // 2.设置支持浏览器下载的配置 (attachment:附件) (URLEncoder.encode(filename, "UTF-8"):避免文件名乱码)
    resp.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(filename, "UTF-8"));
    // 3.获取下载文件的输入流
    FileInputStream fis = new FileInputStream(realPath);
    // 4.创建缓冲区
    int len = 0;
    byte[] buf = new byte[1024];
    // 5.获取OutputStream对象
    ServletOutputStream os = resp.getOutputStream();
    // 6.将FileOutputStream流写入到buffer缓冲区,使用OutputStream将缓冲区中的数据输出到客户端
    while((len = fis.read(buf)) != -1){
        os.write(buf, 0, len);
    }
    // 7.关闭流
    os.close();
    fis.close();
}

6.6.3 验证码功能

前端实现
后端实现，需要用到 Java 的图片类，生产一个图片

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    //如何让浏览器3秒自动刷新一次;
    resp.setHeader("refresh", "3");

    //在内存中创建一个图片
    BufferedImage image = new BufferedImage(80, 20, BufferedImage.TYPE_INT_RGB);
    Graphics2D g = (Graphics2D)image.getGraphics(); //笔
    //设置图片的背景颜色
    g.setColor(Color.green);
    g.fillRect(0, 0 ,80, 20);
    //给图片写入数据
    g.setColor(Color.white);
    g.setFont(new Font(null, Font.BOLD, 20));
    g.drawString(makeNum(), 0, 20);

    //设置浏览器打开的方式为图片
    resp.setContentType("image/jpg");
    //网址会读取缓存，要刷新的话需要设置不能缓存
    resp.setDateHeader("expires", -1);
    resp.setHeader("Cache-Control", "no-cache");
    resp.setHeader("Pragma", "no-cache");

    //把图片写到浏览器
    ImageIO.write(image, "jpg", resp.getOutputStream());
}

//生成随机数
private String makeNum(){
    Random random = new Random();
    String num = random.nextInt(9999999) + "";
    StringBuffer sb = new StringBuffer();
    //如果生成的数不足7位，填0补充
    for (int i = 0; i < 7-num.length(); i++) {
        sb.append(0);
    }
    num = sb.toString() + num;
    return num;
}

6.6.4 实现重定向

一个web资源收到客户端请求后，他会通知客户端去访问另外一个web资源，这个过程叫重定向

常见场景：

用户登录

void sendRedirect(String var1) throws IOException;

测试：

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        /*
        实际原理，先设置位置，后设置响应码
        resp.setHeader("Location", "/r/img");
        resp.setStatus(HttpServletResponse.SC_MOVED_TEMPORARILY); //302
        */
        resp.sendRedirect("/r/img");
    }

6.6.5 面试题

重定向和转发的区别

相同点：

页面都会发生跳转

不同点：

请求转发的时候，url路径不会发生改变
重定向的时候，url路径会发生改变

6.6.6 实现登录重定向（案例）

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

<%--这里提交的路径，需要寻找到Servlet的路径--%>
<%--${pageContext.request.contextPath}代表当前的项目--%>
<form action="${pageContext.request.contextPath}/login" method="get">
    用户名：<input type="text" name="username"> <br>
    密码：<input type="text" name="password"> <br>
    <input type="submit">
</form>

</body>
</html>

LoginServlet.java

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    //获取表单数据
    String username = req.getParameter("username");
    String password = req.getParameter("password");
    System.out.println(username + ":" + password);

    //重定向时候一定要注意，路径问题，否则404；
    resp.sendRedirect("./success.jsp");
}

6.7 HttpServletRequest

HttpServletRequest代表客户端的请求，用户通过Http协议访问服务器，HTTP请求中的所有信息会被封装到HttpServletRequest，通过这个HttpServletRequest的方法，获得客户端的所有信息；

6.7.1 获取参数，请求转发

request.getParameter("");

@Override
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");

    String username = req.getParameter("username");
    String password = req.getParameter("password");
    String[] hobbys = req.getParameterValues("hobbys");
    System.out.println(username + ":" +password);
    System.out.println("爱好为："+Arrays.toString(hobbys));

    //通过请求转发,url地址不会发生改变，这里的 / 代表当前的web应用
    req.getRequestDispatcher("/success.jsp").forward(req, resp);
    //通过重定向,url地址发生改变
    //        resp.sendRedirect("./success.jsp");
}

重定向和转发的区别

相同点

页面都会实现跳转

不同点

请求转发的时候，url地址栏不会产生变化，状态码：307 ；
重定向的时候，url地址栏会发生变化，状态码：302；

7 Cookie、Session

7.1 会话

会话：用户打开一个浏览器，点击了很多超链接，访问多个web资源，关闭浏览器，这个过程可以称之为会话；

有状态会话：一个同学来过教室，下次再来教室，我们知道这个同学曾经来过，称之为有状态会话；

一个网站，怎么证明你来过？

服务端给客户端一个信件，客户端下次访问服务端带上信件就可以了； cookie
服务器登记你来过了，下次来的时候进行匹配； seesion

7.2 保存会话的两种技术

cookie

客户端技术（响应，请求）

session

服务器技术，利用这个技术，可以保存用户的会话信息，可以把信息或者数据放在Session中

使用场景：网站登录之后，再次访问就不用再登录了

从请求中拿到cookie信息
服务器响应给客户端cookie

Cookie[] cookies = req.getCookies(); //获得Cookie
cookie.getName(); //获得cookie中的key
cookie.getValue(); //获得cookie中的vlaue
new Cookie("lastLoginTime", System.currentTimeMillis()+""); //新建一个cookie
cookie.setMaxAge(24*60*60); //设置cookie的有效期为1天
resp.addCookie(cookie); //给响应添加一个cookie

cookie：一般会保存在本地的用户appdata目录下；

注意：

一个Cookie只能保存一个信息；
一个web站点可以给浏览器发送多个cookie，每个浏览器不一定相同；
Cookie大小有限制4kb多一点；
300个cookie浏览器上限

	IE6.0	IE7.0/IE8.0	Opera	Firefox	Safari	Chrome
cookie个数	每个域20个	每个域50个	每个域30个	每个域50个	没有个数限制	每个域53个
cookie总大小	4095字节	4095字节	4096字节	4097字节	4097字节	4097字节

4095字节约等于4KB

删除Cookie（两个方法）

不设置有效期，关闭浏览器，自动失效；
设置有效期时间为 0 ；

编码解码：

//编码
URLEncoder.encode("编码","utf-8")
//解码
URLDecoder.decode(cookie.getValue(),"UTF-8")

代码演示：

@Override
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");

    PrintWriter out = resp.getWriter();
    Cookie[] cookies = req.getCookies(); //返回多个数组，说明cookie可以为多个

    //判断Cookie是否存在
    if(cookies != null){
        out.print("你上一次访问的时间为：");
        for (Cookie cookie : cookies) {
            if(cookie.getName().equals("LastLoginTime")){
                Long LastLoginTime = Long.parseLong(cookie.getValue());
                Date date = new Date(LastLoginTime);
                out.print(date.toLocaleString());
            }
            if(cookie.getName().equals("name")){
                //解码
                out.print("name="+ URLDecoder.decode(cookie.getValue(),"utf-8"));
            }
        }
    }else{
        out.print("这是你第一次访问本网站");
    }

    Cookie cookie = new Cookie("LastLoginTime", System.currentTimeMillis()+"");
    //编码
    Cookie cookie1 = new Cookie("name", URLEncoder.encode("李四","utf-8"));
    resp.addCookie(cookie);
    resp.addCookie(cookie1);
}

7.4 Session（重点）

7.4.1 什么是Session

服务器会给每一个用户（浏览器）创建一个Seesion对象；
一个Seesion独占一个浏览器，只要浏览器没有关闭，这个Session就存在；
用户登录之后，整个网站它都可以访问！--> 保存用户的信息；保存商品的信息…..

7.4.2 Session和cookie的区别

Cookie是把用户的数据写到浏览器，浏览器保存（可以保存多个）
Session把用户的数据写到用户独占Session中（服务器端保存保存重要的信息，减少服务器资源的浪费）
Session对象由服务创建；

使用场景：

保存一个登录用户的信息；
购物车信息；
在整个网站中经常会使用的数据，我们将它保存在Session中；

7.4.3 使用Session并得到SessionID

@Override
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", new Person("测试人员", 1));
    //获取Session的ID
    String sessionId = session.getId();
    //判断Session是不是新创建
    if(session.isNew()){
        resp.getWriter().write("Session创建成功，ID：" + sessionId);
    }else{
        resp.getWriter().write("Session已经在服务器存在，ID：" + sessionId);
    }

    //Session的创建流程
    //Cookie cookie = new Cookie("JSESSIONID",sessionId);
    //resp.addCookie(cookie);
}

7.4.4 获得和注销Session

@Override
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();
    Person person = (Person)session.getAttribute("name");
    System.out.println(person.toString());
    //移除Session
    session.removeAttribute("name");
    //手动注销Session
    session.invalidate();
}

7.4.5 removeAttribute与invalidate的区别

removeAttribute：

从session删除指定名称的绑定对象
意思是调用此方法后再调用getAttribute(String name)时，不能获取指定名称的绑定对象，但是session还存在。

invalidate：

销毁此session对象
意思是session对象中绑定的那些对象值也都不存在了

7.4.6 Session会话自动过期

web.xml配置

<session-config>
    <!--Session自动失效，以分钟为单位-->
    <session-timeout>1</session-timeout>
</session-config>

8 JSP

8.1 什么是JSP

Java Server Pages ： Java服务器端页面，也和Servlet一样，用于动态Web技术！

最大的特点：

写JSP就像在写HTML
区别：
- HTML只给用户提供静态的数据
- JSP页面中可以嵌入JAVA代码，为用户提供动态数据；

8.2 JSP原理

思路：JSP到底怎么执行的！

代码层面没有任何问题
服务器内部工作

tomcat中有一个work目录；

IDEA中使用Tomcat的会在IDEA的tomcat中生产一个work目录

发现页面转变成了Java程序！

浏览器向服务器发送请求，不管访问什么资源，其实都是在访问Servlet！

JSP最终也会被转换成为一个Java类！

JSP 本质上就是一个Servlet

//初始化
public void _jspInit() {
}
//销毁
public void _jspDestroy() {
}
//JSPService
public void _jspService(.HttpServletRequest request,HttpServletResponse
response)

判断请求

内置一些对象

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.setContentType("text/html;charset=UTF-8");  //设置响应的页面类型
pageContext = _jspxFactory.getPageContext(this, request, response,null, true, 8192, true);
_jspx_page_context = pageContext;
application = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
_jspx_out = out;

注意：以上对象可以在JSP页面中直接使用！

在JSP页面中；只要是 JAVA代码就会原封不动的输出；

如果是HTML代码，就会被转换为：

out.write("<html>\r\n");

这样的格式，输出到前端！

8.3 JSP基础语法

任何语言都有自己的语法，JAVA中有。 JSP 作为java技术的一种应用，它拥有一些扩充的语法（了解即可！），Java所有语法都支持！

8.3.1 JSP表达式

<%--JSP表达式
    作用：用来将程序的输出，输出到客户端
    <%= 变量或者表达式%>
--%>

<%= new java.util.Date()%>

8.3.2 jsp脚本片段

<%--jsp脚本片段--%>
<%
    int sum = 0;
    for (int i = 1; i <=100 ; i++) {
   		sum+=i;
    }
    out.println("<h1>Sum="+sum+"</h1>");
%>

8.3.3 脚本片段的再实现

<%
    int x = 10;
    out.println(x);
%
<p>可以在两个代码块之间写标签</p>
<%
    int y = 2;
    out.println(y);
%>

<hr>

<%--在代码嵌入HTML元素--%>
<%
	for (int i = 0; i < 5; i++) {
%>
<h1>Hello,World <%=i%> </h1>
<%
	}
%>

注：如果要使用el表达式${变量}，该变量需要先request.setAttribute("变量名", 变量值);进去

8.3.4 JSP声明

JSP声明：会被编译到JSP生成Java的类中！其他的，就会被生成到_jspService方法中！在JSP，嵌入Java代码即可！

<%!
    static {
   		System.out.println("Loading Servlet!");
    }
    private int globalVar = 0;
    public void get(){
    System.out.println("进入了get方法！");
    }
%>

<%%>			//片段
<%=%>			//表达式的值
<%!%>			//全局申明
<%--注释--%>	   //注释

JSP的注释，不会在客户端显示，HTML就会！

8.4 定制errorPage

方法1：在报错页面定向到指定页面

<%--自定义错误页面--%>
<%@ page errorPage="error/500.jsp" %>

方法2：配置web.xml

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

8.5 JSP指令

<%@page args.... %>
<%@include file=""%>

<%--@include会将两个页面合二为一，变量通用--%>
<%@include file="common/header.jsp"%>
<h1>网页主体</h1>
<%@include file="common/footer.jsp"%>

<hr>

<%--jSP标签
jsp:include：拼接页面，本质还是三个，变量不通用
--%>
<jsp:include page="/common/header.jsp"/>
<h1>网页主体</h1>
<jsp:include page="/common/footer.jsp"/>

8.6 内置对象及其作用域

8.6.1 九大内置对象

PageContext 存东西
Request 存东西
Response
Session 存东西
Application 【SerlvetContext】存东西
config 【SerlvetConfig】
out
page ，不用了解
exception

8.6.2 内置对象作用域

pageContext//当前页面有效
request//一次请求有效
session//随浏览器关闭而失效
application//随服务器关闭而失效

request：客户端向服务器发送请求，产生的数据，用户看完就没用了，比如：新闻，用户看完没用的！
session：客户端向服务器发送请求，产生的数据，用户用完一会还有用，比如：购物车；
application：客户端向服务器发送请求，产生的数据，一个用户用完了，其他用户还可能使用，比如：
聊天数据；

8.6.3 测试案例

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <%
        //内置对象
        pageContext.setAttribute("name1", "测试1号"); //一个页面中有效
        request.setAttribute("name2", "测试2号");     //一次请求中有效
        session.setAttribute("name3", "测试3号");     //一次会话中有效
        application.setAttribute("name4", "测试4号"); //一次服务器中有效
    %>

    <%
        //代码块中的代码，会原封生成到.jsp.java中
        //要求这里面的代码必须保证java语法的正确性
        //从pageContext中取出，通过findAttribute寻找的方式来
        //从底层到高层（作用域）
        String name1 = (String) pageContext.findAttribute("name1");
        String name2 = (String) pageContext.findAttribute("name2");
        String name3 = (String) pageContext.findAttribute("name3");
        String name4 = (String) pageContext.findAttribute("name4");
        String name5 = (String) pageContext.findAttribute("name5"); //不存在
    %>

<%--    使用EL表达式输出，如果使用jsp %= 内置输出，可能会出现null--%>
    <h3>取出的值为：</h3>
    <h3>${name1}</h3>
    <h3>${name2}</h3>
    <h3>${name3}</h3>
    <h3>${name4}</h3>
    <h3>以EL表达式输出的值：${name5}</h3>
    <h3>以%=输出的值：<%=name5%></h3>

</body>
</html>

8.6.4 jsp页面转发

<%
    //jsp页面中使用
    pageContext.forward("/index.jsp");
    //servlet中使用
    //request.getRequestDispatcher("/index.jsp").forward(request,response);
%>

8.7 JSP标签、JSTL标签、EL表达式

需要导入的依赖

<!-- JSTL表达式的依赖 -->
<dependency>
    <groupId>javax.servlet.jsp.jstl</groupId>
    <artifactId>jstl-api</artifactId>
    <version>1.2</version>
</dependency>
<!-- standard标签库 -->
<dependency>
    <groupId>taglibs</groupId>
    <artifactId>standard</artifactId>
    <version>1.1.2</version>
</dependency>

EL表达式格式： ${ }

EL表达式作用：

获取数据
执行运算
获取web开发的常用对象

JSP标签

<%--jsp:include--%>
<%--
	http://localhost:8080/jsptag.jsp?name=admin&pwd=123
--%>
<jsp:forward page="/jsptag2.jsp">
<jsp:param name="name" value="admin"></jsp:param>
<jsp:param name="pwd" value="123"></jsp:param>
</jsp:forward>

JSTL表达式

JSTL标签库的使用就是为了弥补HTML标签的不足；它自定义许多标签，可以供我们使用，标签的功能和 Java代码一样！

格式化标签

SQL标签

XML 标签

核心标签（掌握部分）

JSTL标签库使用步骤

引入对应的 taglib
使用其中的方法
在Tomcat 也需要引入 jstl的包，否则会报错：JSTL解析错误

c：if

<head>
	<title>Title</title>
</head>
<body>
    <h4>if测试</h4>
    <hr>
    <form action="coreif.jsp" method="get">
        <%--
            EL表达式获取表单中的数据
            ${param.参数名}
        --%>
        <input type="text" name="username" value="${param.username}">
        <input type="submit" value="登录">
    </form>
    
    <%--判断如果提交的用户名是管理员，则登录成功--%>
    <c:if test="${param.username=='admin'}" var="isAdmin">
    	<c:out value="管理员欢迎您！"/>
    </c:if>
    
    <%--自闭合标签--%>
    <c:out value="${isAdmin}"/>
</body>

c:choose c:when

<body>
    <%--定义一个变量score，值为85--%>
    <c:set var="score" value="55"/>
    
    <c:choose>
        <c:when test="${score>=90}">
        	你的成绩为优秀
        </c:when>
        <c:when test="${score>=80}">
        	你的成绩为一般
        </c:when>
        <c:when test="${score>=70}">
        	你的成绩为良好
        </c:when>
        <c:when test="${score<=60}">
        	你的成绩为不及格
        </c:when>
    </c:choose>
</body>

c:forEach

<%
    ArrayList<String> people = new ArrayList<>();
    people.add(0,"张三");
    people.add(1,"李四");
    people.add(2,"王五");
    people.add(3,"赵六");
    people.add(4,"田六");
    request.setAttribute("list",people);
%>
    <%--
        var , 每一次遍历出来的变量
        items, 要遍历的对象
        begin, 哪里开始
        end, 到哪里
        step, 步长
    --%>

<c:forEach var="people" items="${list}">
	<c:out value="${people}"/> <br>
</c:forEach>

<hr>

<c:forEach var="people" items="${list}" begin="1" end="3" step="1" >
	<c:out value="${people}"/> <br>
</c:forEach>

9 JavaBean

实体类（一般写成pojo、entity，dto，vo）

JavaBean有特定的写法：

必须要有一个无参构造
属性必须私有化private
必须有对应的get/set方法（因为私有，所以说必须通过get/set）；

一般用来和数据库的字段做映射 ORM；

ORM ：对象关系映射 (Object Relational Mapping)

表--->类
字段-->属性
行记录---->对象

people表

	id	name	age	address
注释	主键	姓名	年龄	地址

People.java

class People{
    private int id;
    private String name;
    private int id;
    private String address;
    //无参
    //get,set
}

10 MVC三层架构

什么是MVC： Model view Controller 模型、视图、控制器

10.1 早些年

用户直接访问控制层，控制层就可以直接操作数据库；

servlet--CRUD-->数据库
弊端：程序十分臃肿，不利于维护
servlet的代码中：处理请求、响应、视图跳转、处理JDBC、处理业务代码、处理逻辑代码

架构：没有什么是加一层解决不了的！

程序猿调用
|
JDBC
|
Mysql Oracle SqlServer ....

10.2 MVC三层架构

Model

业务处理：业务逻辑（Service）
数据持久层：CRUD （Dao）

View

展示数据
提供链接发起Servlet请求（a，form，img…）

Controller （Servlet）

接收用户的请求：（req：请求参数、Session信息….）
交给业务层处理对应的代码
控制视图的跳转

10.3 登录的基本流程

登录--->接收用户的登录请求--->处理用户的请求（获取用户登录的参数，username，password）---->交给业务层处理登录业务（判断用户名密码是否正确：事务）--->Dao层查询用户名和密码是否正确-->数据库

11 Filter （重点）

Filter：过滤器，用来过滤网站的数据；

处理中文乱码
登录验证….

Filter配置步骤：

导包（javax.servlet.Filter ）

编写过滤器

实现Filter接口，重写对应的方法即可

package com.yzh.filter;

import javax.servlet.*;
import java.io.IOException;

public class EncodingFilter implements Filter {

    //初始化：web服务器启动，就已经初始化了，随时等待过滤对象出现！
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("EncodingFilter初始化");
    }

    //Chain : 链
    /*
    1. 过滤中的所有代码，在过滤特定请求的时候都会执行
    2. 必须要让过滤器继续通行
        chain.doFilter(request,response);
    */
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
        //设置编码
        request.setCharacterEncoding("utf-8");
        response.setCharacterEncoding("utf-8");
        response.setContentType("text/html;charset=utf-8");

        System.out.println("EncodingFilter执行前....");
        //让我们的请求继续走，如果不写，程序到这里就被拦截停止！
        filterChain.doFilter(request, response);
        System.out.println("EncodingFilter执行后....");
    }

    //销毁：web服务器关闭的时候，过滤会销毁
    public void destroy() {
        System.out.println("EncodingFilter销毁");
    }
}

在web.xml中配置 Filter

<filter>
    <filter-name>EncodingFilter</filter-name>
    <filter-class>com.yzh.filter.EncodingFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>EncodingFilter</filter-name>
    <!--只要是 /servlet的任何请求，会经过这个过滤器-->
    <url-pattern>/servlet/*</url-pattern>
    <!--<url-pattern>/*</url-pattern>-->
</filter-mapping>

12 监听器

实现一个监听器的接口；（有N种，分别实现不同接口类即可）

编写一个监听器

实现监听器的接口…

//统计网站在线人数 ： 统计session
public class OnlineCountListener implements HttpSessionListener {

    //创建session监听
    //一旦创建Session就会触发一次这个事件！
    public void sessionCreated(HttpSessionEvent se) {
        ServletContext ctx = se.getSession().getServletContext();
        System.out.println(se.getSession().getId());

        Integer onlineCount = (Integer) ctx.getAttribute("onlineCount");
        if(onlineCount == null){
            onlineCount = new Integer(1);
        }else {
            int count = onlineCount.intValue();
            onlineCount = new Integer(count + 1);
        }
        ctx.setAttribute("onlineCount", onlineCount);
    }

    //销毁session监听
    //一旦销毁Session就会触发一次这个事件！
    public void sessionDestroyed(HttpSessionEvent se) {
        ServletContext ctx = se.getSession().getServletContext();
        System.out.println(se.getSession().getId());

        Integer onlineCount = (Integer) ctx.getAttribute("onlineCount");
        if(onlineCount == null){
            onlineCount = new Integer(0);
        }else {
            int count = onlineCount.intValue();
            onlineCount = new Integer(count - 1);
        }
        ctx.setAttribute("OnlineCount", onlineCount);
    }

    /*
        Session销毁：
        1. 手动销毁 getSession().invalidate();
        2. 自动销毁
    */
}

web.xml中注册监听器

<listener>
    <listener-class>com.yzh.listener.OnlineCountListener</listener-class>
</listener>

测试页面：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
    <h3>在线人数：<span style="color: red"><%=application.getAttribute("onlineCount")%></span></h3>
  </body>
</html>

13 过滤器、监听器常见应用

1、GUI编程中的监听器

2、用户登录权限拦截

用户登录之后才能进入主页！用户注销后就不能进入主页了！

用户登录之后，向Sesison中放入用户的数据
进入主页的时候要判断用户是否已经登录；要求：在过滤器中实现！

HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) resp;
if (request.getSession().getAttribute(Constant.USER_SESSION)==null){
	response.sendRedirect("/error.jsp");
}
chain.doFilter(request,response);

14 JDBC及事务

14.1 什么是JDBC

解释：Java连接数据库！

需要jar包的支持：

java.sql
javax.sql
mysql-conneter-java… 连接驱动（必须要导入）

导入数据库依赖

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

JDBC 固定步骤：

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

详细过程可以去看我数据库基础里面的演示

14.2 事务

要么都成功，要么都失败！

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

开启事务 setAutoCommit(false);
事务提交 commit()
事务回滚 rollback()
关闭事务 setAutoCommit(true);

转账：
A:1000
B:1000
A(900) --100--> B(1100)