Java

发布日期: 2020-06-09

作者: 勇也很努力

文章字数: 15.3k

阅读时长: 67 分

学习视频链接：B站遇见狂神说

JavaWeb，是通过Java语言编写的可以通过浏览器访问的程序的总称。

一、基本概念

web包括：web服务器和web客户端两部分。web按实现的技术和呈现的效果不同，分为静态web和动态web。

JavaWeb是基于请求和响应来开发的。

1、请求与响应

请求（Request）是指客户端给服务器端发送数据。

响应（Response）是指服务器端给客户端回传数据。

请求与响应是成对出现的，有请求就有响应。

请求与响应

    共享资源文件：可以通过网络进行传输的文件。所有的文件内容都可以通过网络传输，所有文件都是共享资源文件。
    静态资源文件：
        1.如果文件内容是固定的，这种文件可以被称为静态资源文件。（文档，图片，视频）
        2.如果文件存放的不是命令，这些命令只能在浏览器编译与执行，这种文件可以被称为静态资源文件。（.html，.css，.js）
    动态资源文件：如果文件存放命令，并且命令不能再浏览器编译与执行，只能在服务器端计算编译执行，这样的文件可以被称为动态资源文件。

2、静态web

指的是以*.htm、*.html为后缀的网页，如果服务器上一直存在这些文件，就可以从服务器上读取这些内容，然后返回给客户端浏览器解析呈现给用户。

静态web的缺点：
1. web页面无法更新，所有用户看到的都是同一个页面
  - 轮播图，点击特效：伪动态
  - JavaScript
2. 它无法和数据库交互（数据无法持久化，用户无法交互）

静态web

3、动态web

是指利用某些技术实现连接数据库，能够与用户交互，使web展示效果“因时因人而变”。

【不是网站中有动态效果就是动态web】

动态web的缺点：
1. 当服务器的动态web资源出现了错误，需要重新编写后台程序，重新发布；
动态web的优点：
1. web页面可以动态更新，所有用户看到的都不是同一个页面；
2. 可以与数据库交互（数据持久化）

动态web

二、web服务器

1、技术了解

1-1、ASP

动态服务器页面（Active Server Pages）

微软公司开发的代替CGI脚本程序的一种应用，也是微软公司的第一个服务器侧的脚本引擎，能够动态产生Web页面。
在HTML中嵌入VB的脚本，ASP+COM。
在ASP开发中，基本一个页面都有几千行的业务代码，页面极其混乱。
维护成本高。
主要使用C#语言
服务器：IIS（Internet Information Server）

1-2、PHP

PHP即“超文本预处理器”，是一种通用开源脚本语言。

PHP原始为Personal Home Page的缩写，已经正式更名为 “PHP: Hypertext Preprocessor”。

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

1-3、JSP/Servlet

JSP（JavaServer Pages：Java服务器页面）是由[Sun Microsystems](https://baike.baidu.com/item/Sun Microsystems)公司主导创建的一种动态网页技术标准。

Servlet（Server Applet）是Java Servlet的简称，称为小服务程序或服务连接器，用Java编写的服务器端程序，具有独立于平台和协议的特性，主要功能在于交互式地浏览和生成数据，生成动态Web内容。

sun公司主推的B/S架构
基于Java语言
可以承载三高（高性能、高并发、高可用）问题带来的影响
语法类似ASP

2、web服务器

服务器，也称伺服器，是提供计算服务的设备。由于服务器需要响应服务请求，并进行处理，因此一般来说服务器应具备承担服务并且保障服务的能力。

服务器的构成包括处理器、硬盘、内存、系统总线等。

服务器用来处理用户的一些请求和给用户一些响应信息。

Tomact由Apache组织提供的一种web服务器，提供对JSP和Servlet的支持。是一种轻量级的JavaWeb容器（服务器）。
IIS
1. 是一种Web（网页）服务组件，其中包括Web服务器、FTP服务器、NNTP服务器和SMTP服务器，分别用于网页浏览、文件传输、新闻服务和邮件发送等方面，它使得在网络（包括互联网和局域网）上发布信息成了一件很容易的事。
2. 是互联网信息服务，是由微软公司提供的基于运行Microsoft Windows的互联网基本服务。
Jboss：是一个遵从 JavaEE 规范的、开放源代码的、纯 Java 的 EJB 服务器，它支持所有的 JavaEE 规范（免费）。
Resin：是 CAUCHO 公司的产品，是一个非常流行的服务器，对 servlet 和 JSP 提供了良好的支持，性能也比较优良，resin 自身采用 JAVA 语言开发（收费，应用比较多）。
GlassFish：由 Oracle 公司开发的一款 JavaWeb 服务器，是一款强健的商业服务器，达到产品级质量（应用很少）。
WebLogic：是 Oracle 公司的产品，是目前应用最广泛的 Web 服务器，支持 JavaEE 规范，而且不断的完善以适应新的开发要求，适合大型项目（收费，用的不多，适合大公司）。

三、Tomact

1、下载安装Tomact

Tomact下载并解压。

Tomact目录

2、Tomact启动与配置

找到Tomact目录下bin目录下的srartup.bat文件，双击即可运行Tomact服务器（或者打开命令行，cd到Tomact的bin目录下，敲入启动命令：catalina run）。shutdown.bat关闭Tomact服务器。
测试Tomact服务器是否启动成功
- 打开浏览器，在浏览器地址栏输入以下地址测试：

配置

conf下的server.xml是服务器核心配置文件

配置启动的端口号：
    Tomact默认端口号：8080（http：80  https：443）
        <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />
配置主机的名称：
    默认主机名：localhost->127.0.0.1
    默认网站应用存放位置：webapps
        <Host name="localhost"  appBase="webapps"
                unpackWARs="true" autoDeploy="true">

网站访问：

网站访问

四、HTTP

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

1、HTTP请求

客户端—请求（request）—服务器

百度
Request URL: https://www.baidu.com/    请求地址
Request Method: GET    get/post方法
Status Code: 200 OK    状态码：200 
Remote Address: 14.215.177.38: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

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

消息头

Accept: 支持的数据类型
Accept-Encoding: 支持那种编码格式
Accept-Language: 语言环境
Cache-Control: 缓存控制
Connection: 请求完成是断开还是保持连接
HOST：主机

2、HTTP响应

服务器—响应（response）—客户端

Cache-Control: private    缓存控制
Connection: keep-alive    连接
Content-Encoding: gzip
Content-Type: text/html;charset=utf-8

响应体

Accept: 支持的数据类型
Accept-Encoding: 支持那种编码格式
Accept-Language: 语言环境
Cache-Control: 缓存控制
Connection: 请求完成是断开还是保持连接
HOST：主机
Refresh：多久刷新一次
Location：让网页重新定位

响应状态码

1xx：服务器接收客户端消息，但没有接收完成，等待一段事件后，发送1xx状态码

200：请求响应成功

3xx：请求重定向

4xx：找不到资源，资源不存在（404）

5xx：服务器代码错误（502：网关错误）

五、Maven

在JavaWeb开发中，需要导入大量的jar包，手动导入太麻烦，希望有一样东西可以自动帮到如何配置这些jar包，因此，Maven诞生了！

Maven是一个项目管理和综合工具。

其核心思想：约定大约配置。

有约束，不要去违反。

maven约定的目录结构：

/*
    maven约定的目录结构，需遵循
*/
Test/
    /src
        /main  放主程序Java代码和配置文件
            /java 程序包和java文件
            /resources Java程序中需要使用的配置文件
        /test  放测试程序代码和文件的（可不需要）
            /java 测试程序包和包中的Java程序
            /resources 测试java程序中要使用的配置文件
    /pom.xml maven的核心文件

1、下载安装Maven

Maven下载，下载完成后解压即可。

2、配置环境变量

M2_HOME maven目录下的bin目录
MAVEN_HOME maven的目录
PATH中配置MAVEN_HOME %MAVEN_HOME%\bin

测试MAVEN

3、阿里云镜像

镜像（mirrors）：加速下载

<mirror>
    <id>alimaven</id>
    <mirrorOf>central</mirrorOf>
    <name>aliyun maven</name>
    <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
</mirror>

注意缩进、空格问题！

4、本地仓库

建立一个本地仓库（localRepository）

<localRepository>F:\Java Tools\apache-maven-3.6.3\maven-repo</localRepository>

5、IDEA中使用Maven

启动IDEA后，创建Maven项目

点击Enable Auto Import自动导入

等待项目初始化完

[INFO] BUILD SUCCESS表示项目搭建成功。

IDEA中的maven配置

注意：项目自动创建完成后，MavenHome会使用IDEA默认，如若出现这种情况，手动改成本地的。

IDEA配置（默认）全局Maven配置（解决每次创建Maven项目时需要配置）

全局Maven配置

6、创建普通maven项目

创建时不勾选Create from archerype即可。

创建普通maven项目

7、标记文件夹

File->Project Structure->Modules选中当前项目

8、IDEA中配置Tomact

解决Warning

启动Tomact

9、pom文件

validate 验证项目是否正确以及必须的信息是否可用
compile 编译源代码
test 测试编译后的代码，即执行单元测试代码
package 打包编译后的代码，在target目录下生成package文件
verify 检验package是否有效并且达到质量标准
install 安装package到本地仓库，方便本地其它项目使用
site 生成项目的站点文档
deploy 部署，拷贝最终的package到远程仓库和替他开发这或项目共享，在集成或发布环境完成

<?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>com.lskj</groupId>
  <artifactId>javaweb-01-maven</artifactId>
  <version>1.0-SNAPSHOT</version>
  <!--
  package：项目的打包方式
  jar：Java应用
  war：JavaWeb应用
  -->
  <packaging>war</packaging>

  <name>javaweb-01-maven 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包配置文件-->
    <!--Maven的高级之处在于，会自动导入当前这个jar包所依赖的其它jar包-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <!--项目构建用的插件之类的东西-->
  <build>
    <finalName>javaweb-01-maven</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由于约定大于配置，可能会遇到编写的配置文件无法被导出或生效的问题。

解决办法：

<!--在bulid中配置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>

10、web.xml

maven默认web项目版本问题。

maven默认web

替换成与Tomact的webapp版本一致

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

11、Maven仓库

Maven仓库

六、Servlet

1、Servlet简介

Servlet是sun公司开发动态web的一门技术（Servlet是JavaEE规范之一。规范就是接口）
Servlet是JavaWeb三大组件之一。（三大组件分别是Servlet程序、Filter过滤器、Listener监听器）
Servlet是运行在服务器上的一个Java小程序，它可以接收客户端发送过来的请求，并响应数据给客户端。
sun公司在这些API中提供了一个接口：Servlet，开发一个Servlet程序，只需完成两步：
1. 编写一个类，实现Servlet接口
2. 把开发好的Java类部署到web服务器

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

Servlet3.0

Servlet3.0支持注解配置（可以不需要web.xml）
创建JavaEE项目，选择Servlet版本3.0以上，可以不创建web.xml

定义一个类，实现Servlet接口

复写方法
在类上使用@WebServlet注解，进行配置
@WebServlet("资源路径")

2、HelloServlet

Servlet接口sun公司有两个默认的实现类：HttpServlet，GenericServlet。

Servlet接口

构建一个普通Maven项目，删除src目录，可在该项目中新建Moudel（这个空的项目Maven的主工程）

关于Maven父子工程的理解：

父项目中有

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

子项目中有

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

父项目中的Java子项目可以直接使用。

Maven环境优化
- 修改web.xml
- 将maven的结构搭建完整

编写Servlet程序

编写一个普通类

实现Servlet接口，继承HttpServlet

public class HelloServlet extends HttpServlet {
    //由于get或post只是请求实现的不同方式。可以相互调用，业务逻辑都一样。
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //super.doGet(req, resp);
        PrintWriter writer = resp.getWriter(); //响应流
        writer.print("Hello Servlet!");
    }

    @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.lskj.servlet.HelloServlet</servlet-class>
</servlet>
<!--Servlet的请求路径-->
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>

配置Tomact

配置项目发布的路径即可。
启动测试。

3、Servlet原理

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

Servlet原理

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>/hello</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello02</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello03</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>

指定后缀

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

优先级问题

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

5、ServletContext

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

ServletContext对象获取：

通过request对象获取request.getServletContext();
通过HttpServlet获取this.getServletContext();

MIME类型：在互联网通信过程中定义的一种文件数据类型。

格式：大类型/小类型 text/html image/jpeg

获取：String getMimeType(String file)

共享数据

在一个Servlet中保存的数据，可以在另外一个Servlet中拿到。

域对象：一个有作用范围的对象，可以在范围内共享数据。

request域：代表一次请求的范围，一般用于请求转发的多个资源中共享数据。

ServletContext对象范围：所有用户请求的数据。

方法：

setAttribute(String name,Object obj)：存储数据
getAttribute(String name)：通过键获取值
removeAttribute(String name)：通过键移除键值对

存放数据

public class ServletTest extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        /*this.getInitParameter();  //初始化参数
        this.getServletConfig();  //Servlet配置
        this.getServletContext(); //Servlet上下文*/
        ServletContext context = this.getServletContext();

        String str = "心若浮沉，浅笑安然。";
        //将一个数据保存在ServletContext中，名字为String 值为str
        context.setAttribute("String",str);

        System.out.println("Test");
    }

    @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");
        resp.setCharacterEncoding("UTF-8");
        ServletContext context = this.getServletContext();
        String str = (String)context.getAttribute("str");
        resp.getWriter().print("servlet中的str = "+str);
    }

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

web.xml

<servlet>
    <servlet-name>servletTest</servlet-name>
    <servlet-class>com.lskj.servlet.ServletTest</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>servletTest</servlet-name>
    <url-pattern>/servlet</url-pattern>
</servlet-mapping>

<servlet>
    <servlet-name>getServlet</servlet-name>
    <servlet-class>com.lskj.servlet.GetServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>getServlet</servlet-name>
    <url-pattern>/getServlet</url-pattern>
</servlet-mapping>

获取初始化参数
web.xml

<!--配置web应用的初始化参数-->
<context-param>
    <param-name>url</param-name>
    <param-value>jdbc:mysql://localhost:3306/test</param-value>
</context-param>

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

请求转发

转发与重定向

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        /*RequestDispatcher requestDispatcher =  context.getRequestDispatcher("/gp");  //转发的请求路径
        requestDispatcher.forward(req,resp);  //调用forward实现请求转发*/
        context.getRequestDispatcher("/gp").forward(req,resp);
    }

读取资源文件

在Java（需在bulid中配置resources）、resources目录下创建Properties文件会被打包到同一个路径下（classes），称为类路径（classpath）。
db.properties

username=张三
id=1001

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    InputStream is = this.getServletContext().getResourceAsStream("/WEB-INF/classes/db.properties");
    Properties properties = new Properties();
    properties.load(is);
    String username = properties.getProperty("username");
    String id = properties.getProperty("id");

    resp.getWriter().print(username);
    resp.getWriter().print(id);
}

获取文件真实（服务器）路径

getRealPath(String path)

例如：

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    ServletContext context = this.getServletContext();
    //获取文件的服务器路径
    String realPath = context.getRealPath("/WEB-INF/test.txt");  //web目录下资源访问
    System.out.println(realPath);
}

6、HttpServletResponse

web服务器接收到客户端的HTTP请求，针对这个请求，分别创建一个代表请求的HttpServletRequest对象，代表响应的一个HttpServletResponse。

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

6-1、简单分类

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-2、常见应用

向浏览器输出信息：getWrite().print()

下载文件

获取下载文件的路径
下载的文件名
设置使浏览器能够支持下载需下载的文件
获取下载文件的输入流
创建缓冲区
获取OutputStream对象
将FileOutputStream流写入到buffer缓冲区

使用OutputStream将缓冲区中的数据输出到客户端

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    //获取下载文件的路径
    String realPath = this.getServletContext().getRealPath("WEB-INF/classes/图片1.png");
    System.out.println("下载文件路径："+realPath);
    //下载的文件名
    String fileName = realPath.substring(realPath.lastIndexOf("\\") + 1);
    //设置使浏览器能够支持下载需下载的文件，中文文件名 URLEncoder.encode编码，否则可能会乱码
    resp.setHeader("Content-Disposition", "attachment;filename="+ URLEncoder.encode(fileName,"UTF-8"));
    //获取下载文件的输入流
    FileInputStream fis = new FileInputStream(realPath);
    //创建缓冲区
    int len = 0;
    byte[] buffer = new byte[1024];
    //获取OutputStream对象
    ServletOutputStream sos = resp.getOutputStream();
    //将FileOutputStream流写入到buffer缓冲区
    while((len = fis.read(buffer))>0){
        sos.write(buffer,0,len);
    }
    sos.close();
    fis.close();
}

验证码功能

前端实现

后端实现，需要用到Java的图片类，生成一张图片

package com.lskj.servlet;

import javax.imageio.ImageIO;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.Random;

/**
 * @author lskj
 * @create 2020/5/25 - 15:05
 */
public class ImageServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //使浏览器5秒自动刷新一次
        resp.setHeader("refresh","5");

        //在内存中创建一个图片
        BufferedImage image = new BufferedImage(80, 20, BufferedImage.TYPE_INT_RGB);
        //得到图片
        Graphics2D g = (Graphics2D)image.getGraphics();  //笔
        //设置图片的背景颜色
        g.setColor(Color.white);
        g.fillRect(0,0,80,30);
        //给图片写数据
        g.setColor(Color.blue);
        g.setFont(new Font(null,Font.BOLD,20));
        g.drawString(RandomNum(),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 RandomNum(){
        Random random = new Random();
        String number = random.nextInt(999999) + "";
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < 6-number.length(); i++) {
            sb.append("0");
        }
        String s = sb.toString()+number;
        return number;
    }

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

实现重定向

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

void sendRedirect(String var1) throws IOException;

测试

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    /*
        resp.setHeader("Location","/rs/image");
        resp.setStatus(SC_MOVED_TEMPORARILY);  //302
        */
    resp.sendRedirect("/rs/image"); //重定向
}

重定向与转发的区别
- 相同点：页面都会实现跳转
- 不同点：
  - 请求转发的时候，url不会产生变化（307）
  - 重定向时，url地址栏会发生变化（302）

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("/rs/success.jsp");
    }

<servlet>
    <servlet-name>request</servlet-name>
    <servlet-class>com.lskj.servlet.ResponseTest</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>request</servlet-name>
    <url-pattern>/login</url-pattern>
</servlet-mapping>

index.jsp

<html>
<body>
<h2>Hello World!</h2>

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

</body>
</html>

success.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登录成功</title>
</head>
<body>

<h1 align="center">登陆成功！</h1>

</body>
</html>

7、HttpServletRequest

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

URL：统一资源定位符（http://localhost/test/index)
URI：统一资源标识符(/test/index)

7-1、获取前端传递的参数

String getParameter(String var1);
String[] getParameterValues(String var1);

7-2、请求转发

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");
    String[] usergroup = req.getParameterValues("usergroup");

    System.out.println("-------------------------");
    System.out.println(username);
    System.out.println(password);
    System.out.println(Arrays.toString(usergroup));
    System.out.println("-------------------------");

    //通过请求转发
    req.getRequestDispatcher("/success.jsp").forward(req,resp); // /代表当前的web应用
}

1、会话

会话：（指一个终端用户与交互系统进行通讯的过程）用户打开一个浏览器，点击了很多超链接，访问多个web资源，关闭浏览器，这个过程可以称之为会话。

有状态会话：类似于一个同学来过教室，下次再来教室，就知道这个同学以前来过。

一个网站，怎么证明你来过？
    1、服务器端给客户端一个 信件，客户端下次访问服务器端带上信件就可以了。（cookie）
    2、服务器端登记你来过，下次你在来的时候进行匹配。（session）

2、保存会话的两种技术

cookie

客户端技术【响应（发给客户端），请求（带给服务器）】

session

服务器端技术，利用该技术可以保存用户的会话信息。可以把信息/数据放在session。

例如：网站登录之后，下次访问时不需要再进行登录。

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

Cookie[] cookies = req.getCookies();  //获得Cookie
cookie.getNmae();  //获得Cookie中的key
cookie.getValue();  //获得cookie中的value
new Cookie("lastLoginTime",System.currentTimeMillis()+"");  //新建一个cookie
cookie.setMaxAge(24*60*60);  //设置cookie的有效期
resp.addCookie(cookie);   //响应给客户端一个cookie

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

一个Cookie只能保存一个信息
一个web站点可以给浏览器发送多个cookie
cookie大小有限制

删除Cookie：

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

编码解码：

URLEncoder.encoder("中文","utf-8");
URLDecoder.decoder(cookie.getValue(),"utf-8");

4、Session*

Session

什么是Session？

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

Session与Cookie的区别：

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

package com.lskj.servlet;

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

/**
 * @author lskj
 * @create 2020/5/27 - 15:57
 */
public class SessionDemo01 extends HttpServlet {
    @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("str","心若浮沉，浅笑安然");

        //获取Session的ID
        String id = session.getId();

        //判断Session是否是新创建
        if (session.isNew()){
            resp.getWriter().write("session创建成功！id = " +id);
        }else{
            resp.getWriter().write("session已经存在于服务器中，id = "+id);
        }

        /*//Session创建时做了些什么
        Cookie cookie = new Cookie("JSESSIONID", id);
        resp.addCookie(cookie);*/
    }

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

手动注销Session

session.invalidate();

会话自动失效

<!--设置Session的默认失效时间-->
<session-config>
    <!--1分钟后Session自动失效，以分钟为单位-->
    <session-timeout>1</session-timeout>
</session-config>

八、JSP

Java Server Pages：Java服务器端页面，与Servlet一样用于动态web技术。

特点：

写JSP就像写HTML

HTML只给用户提供静态的数据
JSP页面中可以嵌入Java代码，为用户提供动态数据

1、JSP原理

tomact中有一个work目录，IDEA中使用Tomact会在IDEA的Tomact中产生一个work目录。

C:\Users\用户\.IntelliJIdea2019.3\system下的tomact目录是IDEA tomact的工作空间。

IDEA tomact的工作空间

C:\Users\用户\.IntelliJIdea2019.3\system\tomcat\项目\work\Catalina\localhost\cookie\org\apache\jsp页面转换成为了Java程序

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

JSP最终会被转换成一个Java类
JSP本质上是一个Servlet

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

//1、判断请求
//2、内置对象
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：当前页面
javax.servlet.jsp.JspWriter _jspx_out = null;
javax.servlet.jsp.PageContext _jspx_page_context = null;
HttpServletRequest request                            //请求
HttpServletResponse response                        //响应
//3、输出页面前增加的代码
response.setContentType("text/html");                //设置响应的页面类型
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原理

在JSP页面中：
    只要是Java代码就会原封不动地输出；
    如果是HTML代码，就会被转换为：out.write("<html>\r\n");格式输出到前端。

2、JSP基础语法

任何语言都有自己的语法，Java 中有，JSP作为Java技术的一种应用，它拥有一些扩充的语法，Java所有语法都支持。

JSP表达式

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

JSP脚本片段

<%--JSP脚本片段--%>
<%
    int sum = 0;
    for(int i =  0;i < 10;i++){
        sum += i;
    }
    out.println("<h2>Sum="+sum+"</h2>");
%>

脚本片段的再实现

<%
    int a = 1;
    out.println(a);
%>
<p>########</p>
<%
    int b = 2;
    out.println(b);
%>
<%--在代码中嵌入HTML元素--%>
<%
    for (int i = 0; i < 5; i++) {
%>
<h3>for循环第 <%=i%> 次。</h3>
<%
    }
%>

JSP声明

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

JSP声明会被编译到JSP生成Java的类中。其它的就会被生成到jspService方法中。

在JSP中嵌入Java代码即可！

<!--HTML注释-->
<%--JSP注释--%>
<%%>
<%=%>
<!%%>

JSP的注释，不会在客户端显示（浏览器查看源代码），HTML会。

3、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>网页主体02</h1>
<jsp:include page="common/footer.jsp" />

4、9大内置对象

PageContext
Request
Response
Session
Application【ServletContext】
config【ServletConfig】
out
page
exception

<%
    //保存的数据只在一个页面中有效
    pageContext.setAttribute("name01","zhangsan");
    //保存的数据只在一次请求中有效，请求转发会携带这个数据
    request.setAttribute("name02","lisi");
    //保存的数据只在一次会话中有效，从打开浏览器到关闭浏览器
    session.setAttribute("name03","wanger");
    //保存的数据只在服务器中有效，从打开服务器到关闭服务器
    application.setAttribute("name04","zhaowu");
%>

request：客户端向服务器发送请求，产生的数据，用户看完就没用了。

session：客户端向服务器发送请求，产生的数据，用户用完一会还有用。例如：购物车。

application：客户端向服务器发送请求，产生的数据，一个用户用完了，其它用户还可能使用。

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

<!--JSTL表达式的依赖-->
<dependency>
    <groupId>javax.servlet.jsp.jstl</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>

<!--standard标签库-->
<dependency>
    <groupId>taglibs</groupId>
    <artifactId>standard</artifactId>
    <version>1.1.2</version>
</dependency>

EL表达式：${}

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

JSP标签

<%--jsp:include--%>
<%--
http://localhost:8080/jspTag.jsp?id=10001&name=lskj
--%>
<jsp:forward page="jspTag02.jsp">
    <jsp:param name="id" value="10001"/>
    <jsp:param name="name" value="lskj"/>
</jsp:forward>

JSTL表达式
JSTL标签库的使用是为了弥补HTML标签的不足。它自定义了很多标签，可以供我们使用，标签的功能和Java代码一样。

核心标签
格式化标签
SQL标签
XML标签

JSTL标签库使用步骤：

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

c:if

<body>

<h3>if测试</h3>

<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

<body>

<%--定义一个变量score，值为21--%>
<c:set var="score" value="78" />
<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:when test="${score<60}">
        成绩较差
    </c:when>

</c:choose>

</body>

c:foreach

<body>

<%
    ArrayList<String> student = new ArrayList<>();
    student.add("张三");
    student.add("李四");
    student.add("王二");
    student.add("李明");
    request.setAttribute("list",student);
%>
<%--
    var每次遍历的变量
    items遍历的对象
    begin哪里开始
    end到哪里结束
    step步长
--%>
<c:forEach var="student" items="${list}">
    <c:out value="${student}" /> <hr>
</c:forEach>
<br>
<c:forEach var="student" items="${list}" begin="1" end="3" step="1">
    <c:out value="${student}" /> <hr>
</c:forEach>

</body>

九、JavaBean

实体类

JavaBean有特定的写法：

必须要有一个无参构造
属性必须私有化
必须有对应的get/set方法

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

ORM：对象关系映射

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

student表

id	name	age	grade
1	张三	18	92
2	李四	17	89
3	王二	19	98

class Student {
    private int id;
    private String name;
    private int age;
    private double grade;
}

class A{
    new Student(1,"张三",18,92);
    new Student(2,"李四",17,89);
    new Student(3,"王二",19,98);
}

十、MVC三层架构

MVC：Model、View、Controller【模型、视图、控制器】

1、以前的架构

以前的架构

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

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

Servlet和JSP都可以写Java代码。为了易于维护和使用：

Servlet专注于处理请求，以及控制视图跳转
JSP专注于显示数据

2、MVC三层架构

MVC三层架构

Model

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

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

Controller（Servlet）

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

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

十一、Filter*

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

处理中文乱码
登录验证

Filter

Filter开发步骤：

导包

编写过滤器

导包不要导错（import javax.servlet.*;）

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

public class CharacterEncodingFilter implements Filter {
    //初始化：web服务器启动。就已经初始化了，随时等待过滤对象出现！
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("CharacterEncodingFilter初始化！");
    }
    //chain：链
    /*
        1、过滤器中的所有代码，在过滤特定请求的时候都会执行
        2、必须让过滤器继续通行 filterChain.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("CharacterEncodingFilter执行前...");
        //让请求继续走，若不写，程序到这就会被拦截停止！
        filterChain.doFilter(request,response);
        System.out.println("CharacterEncodingFilter执行后...");
    }
    //销毁：web服务器关闭时，过滤销毁
    public void destroy() {
        System.out.println("CharacterEncodingFilter销毁！");
    }
}

在web.xml中配置Filter

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

十二、监听器

实现一个监听器的接口：（有很多种）

编写一个监听器

实现监听器的接口

//统计网站在线人数：统计session
public class OnlineCountListener implements HttpSessionListener {
    //创建session监听，一旦创建Session就会触发这个事件
    public void sessionCreated(HttpSessionEvent httpSessionEvent) {
        ServletContext servletContext = httpSessionEvent.getSession().getServletContext();
        System.out.println(httpSessionEvent.getSession().getId());
        Integer onlineCount = (Integer) servletContext.getAttribute("OnlineCount");

        if(onlineCount==null){
            onlineCount = new Integer(1);
        }else {
            int count = onlineCount.intValue();
            onlineCount = new Integer(count+1);
        }
        servletContext.setAttribute("OnlineCount",onlineCount);
    }
    //销毁session监听，一旦销毁Session就会触发这个事件
    public void sessionDestroyed(HttpSessionEvent httpSessionEvent) {
        ServletContext servletContext = httpSessionEvent.getSession().getServletContext();
        Integer onlineCount = (Integer) servletContext.getAttribute("OnlineCount");

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

    /*
        Session销毁：
            1、手动销毁  getSession().invalidate();
            2、自动销毁  web.xml中配置
     */
}

web.xml中注册监听器

<!--注册监听器-->
<listener>
    <listener-class>com.lskj.listener.OnlineCountListener</listener-class>
</listener>

视情况决定是否使用

十三、过滤器、监听器常见应用

监听器：GUI编程中经常使用。

public class TestPanel {
    public static void main(String[] args) {
        Frame frame = new Frame("节日快乐！");  //新建一个窗体
        Panel panel = new Panel(null); //面板
        frame.setLayout(null);  //设置窗体的布局

        frame.setBounds(300,300,500,500);
        frame.setBackground(new Color(0,0,255));

        panel.setBounds(50,50,300,300);
        panel.setBackground(new Color(0,0,0));

        frame.add(panel);
        frame.setVisible(true);

        //监听事件，监听关闭事件
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                super.windowClosing(e);
            }
        });
        /*frame.addWindowListener(new WindowListener() {
            public void windowOpened(WindowEvent e) {
                System.out.println("打开");
            }

            public void windowClosing(WindowEvent e) {
                System.out.println("关闭中......");
            }

            public void windowClosed(WindowEvent e) {
                System.out.println("已关闭");
            }

            public void windowIconified(WindowEvent e) {

            }

            public void windowDeiconified(WindowEvent e) {

            }

            public void windowActivated(WindowEvent e) {
                System.out.println("激活");
            }

            public void windowDeactivated(WindowEvent e) {
                System.out.println("未激活");
            }
        });*/
    }
}

用户登录之后才能进入主页，用户注销后退出主页。

用户登录之后，向Session中放入用户的数据。

进入主页的时候要判断用户是否已经登录（在过滤器中实现）。

HttpServletRequest request = (HttpServletRequest)servletRequest;
HttpServletResponse response = (HttpServletResponse)servletResponse;

if (request.getSession().getAttribute(Constant.USER_SESSION)==null){
    response.sendRedirect("/error.jsp");
}

filterChain.doFilter(servletRequest,servletResponse);

十四、JDBC

需要jar包支持：

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

实验环境搭建：

create table users(
    id int PRIMARY key,
    name varchar(40),
    password varchar(40),
    email varchar(60),
    birthday date
);
insert into users(id,name,password,email,birthday) values(1,'张三','123456','zhangsan@qq.com','1999-09-12');
insert into users(id,name,password,email,birthday) values(2,'李四','123456','lisi@qq.com','1998-08-22');
insert into users(id,name,password,email,birthday) values(3,'王五','123456','wangwu@qq.com','2000-01-04');
select * from users;

导入数据库依赖

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

IDEA中连接数据库。

JDBC编程六步

public static void main(String[] args) throws ClassNotFoundException, SQLException {
    //配置信息
    String url = "jdbc:mysql://localhost:3306/jdbc";
    String username = "root";
    String  password = "root";
    //1、加载驱动
    Class.forName("com.mysql.jdbc.Driver");
    //2、连接数据库
    Connection connection = DriverManager.getConnection(url, username, password);
    //3、获取数据库操作对象
    Statement statement = connection.createStatement();
    //4、编写并执行SQL语句
    String sql = "select * from users;";
    ResultSet resultSet = statement.executeQuery(sql);
    //5、处理查询结果集
    while (resultSet.next()){
        System.out.println("id  =   "+resultSet.getInt("id"));
        System.out.println("name =  "+resultSet.getString("name"));
        System.out.println("password    =   "+resultSet.getString("password"));
        System.out.println("email   =   "+resultSet.getString("email"));
        System.out.println("birthday    =   "+resultSet.getDate("birthday"));
    }
    //6、关闭资源
    resultSet.close();
    statement.close();
    connection.close();
}

预编译

public static void main(String[] args) throws Exception {
    String url = "jdbc:mysql://localhost:3306/jdbc";
    String username = "root";
    String password = "root";
    //1、注册驱动
    Class.forName("com.mysql.jdbc.Driver");
    //2、获取连接
    Connection connection = DriverManager.getConnection(url, username, password);
    //3、获取预编译的数据库操作对象
    String sql = "insert into users(id,name,password,email,birthday) values (?,?,?,?,?);";
    PreparedStatement ps = connection.prepareStatement(sql);
    //给占位符传值
    ps.setInt(1,4);
    ps.setString(2,"赵六");
    ps.setString(3,"123321");
    ps.setString(4,"zhaoliu@qq.com");
    ps.setDate(5,new Date(new java.util.Date().getTime()));
    //4、执行SQL语句
    int i = ps.executeUpdate();
    if(i>0){
        System.out.println("数据插入成功！");
    }
    //5、关闭资源
    ps.close();
    connection.close();
}

事务

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

原子性（Atomicity）、一致性（Consistency）、独立性（Isolation）、持久性（Durability）

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

Junit单元测试

依赖

<!--单元测试-->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>

简单使用

@Test注解只有在方法上有效，只要加了这个注解的方法，就可以直接运行。

@Test
public void test(){
    System.out.println("test!");
}

测试事务

create table account(
     id int PRIMARY key AUTO_INCREMENT,
     name varchar(20),
     money float
);
INSERT into account(name,money) values('A',10000);
insert into account(name,money) values('B',100030);
insert into account(name,money) values('C',200100);

@Test
public void test(){
    //useUnicode=true&characterEncoding=utf-8 解决中文乱码
    String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8";
    String username = "root";
    String password = "root";
    Connection connection = null;

    try {
        //注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //获取连接
        connection = DriverManager.getConnection(url, username, password);
        //通知数据库开启事务，false开启（关闭自动提交）
        connection.setAutoCommit(false);

        String sql = "update account set money = money-100 where name = 'A'";
        connection.prepareStatement(sql).executeUpdate();

        /*//制作错误
            int i = 1/0;*/

        String sql02 = "update account set money = money + 100 where name = 'B'";
        connection.prepareStatement(sql02).executeUpdate();

        //以上两条SQL都执行成功了，就提交事务
        connection.commit();
        System.out.println("success!");
    } catch (Exception e) {
        try {
            //如果出现异常，就通知数据库回滚事务
            connection.rollback();
        }catch (SQLException e1) {
            e1.printStackTrace();
        }
        e.printStackTrace();
    }finally {
        if (connection!=null){
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

十五、文件上传

对于文件上传，浏览器在上传的过程中是将文件以流的形式提交到服务器端的。

一般采用commons-fileupload这个文件上传组件，而commons-fileupload是依赖于commons-io这个包。

要有一个form标签，method=post请求
form标签的enctype属性值必须为multiparty/form-data值
在form标签中使用input type=file添加上传文件
编写服务器代码（Servlet程序）接受，处理上传的数据

enctype=multipart/form-data表示提交的数据，以多段（没一个表单项一个数据段）的形式进行拼接，然后以二进制流的形式发送给服务器。

文件上传注意事项

为保证服务器安全，上传文件应该放在外界无法直接访问的目录下，比如放于WEB-INF，目录下。
为防止文件覆盖的现象发生，要为上传文件产生一个唯一的文件名。
要限制上传文件的最大值。
可以限制上传文件的类型，在收到上传文件名时，判断后缀名是否合法。

需要用到的类：

ServletFileUpload负责处理上传的文件数据，并将表单中每个输入项封装成一个FileItem对象，在使用ServletFileUpload对象解析请求时，需要DiskFileItemFactory对象。所以，我们需要在进行解析工作前构造好DiskFileItemFactory对象，通过ServletFileUpload对象的构造方法或setFileItemFactoty()方法设置ServletFileUpload对象的filrItemFactory属性。

1、FileItem类

FileItem类，表示每一个表单项。

在HTML页面input必须有name。

表单如果包含一个文件上传输入项的话，这个表单的enctype属性必须设置为multipart/form-data。

浏览器表单的类型如果是multipart/form-data，在服务器端想获取数据就要通过流。
常用方法介绍

//判断当前上传的数据格式是否是多段的格式。
boolean ServletFileUpload.isMultipartContent(HttpServltRequest request);

//解析上传的数据
public List<FileItem> parseRequest(HttpServletRequest request)

//isFormField方法用于判断FileItem类对象封装的数据是一个普通文本表单
//还是一个文件表单，如果是普通表单字段则返回true，否则返回false
boolean FileItem.isFormField();

//getFieldName方法用于返回表单标签name属性的值。
String FileItem.getFieldName();
//getString方法用于FileItem对象中保存的数据流内容以一个字符串返回
String FileItem.getString();

//getName方法用于获取文件上传字段中的文件名
String FileItem.getName();

//以流的形式返回上传文件的数据内容
InputStream getInputStream()

//delete方法用于清空FileItem类对象中存放的主体内容
//如果主体内容被保存在临时文件中，delete方法将删除该临时文件。
void FileItem.delete();

2、ServletFileUpload类

ServletFileUpload负责处理上传的文件数据，并将表单中每个输入项封装成一个FileItem对象中，使用其parseRequest(HttpServletRequest)方法可以将通过表单中每一个HTML标签提交的数据封装成一个FielItem对象，然后以List列表的形式返回。使用该方法处理上传文件简单易用。

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws javax.servlet.ServletException, IOException {
    //判断上传的文件是普通表单还是带文件的表单
    if(!ServletFileUpload.isMultipartContent(request)){
        return;  //终止方法运行，说明这是一个普通表单
    }
    //创建上传文件的保存路径，建议在WEB-INF路径下，安全，用户无法直接访问上传的文件
    String uploadPath = this.getServletContext().getRealPath("/WEB-INF/upload");
    File uploadFile = new File(uploadPath);

    if(!uploadFile.exists()){
        uploadFile.mkdir();  //创建这个目录
    }

    //缓存，临时文件
    //临时文件，假如文件超过了预期的大小，就把它放到一个临时文件中，过几天自动删除，或者提醒用户转存为永久
    String tmpPath = this.getServletContext().getRealPath("/WEB-INF/tmp");
    File file = new File(tmpPath);

    if(!file.exists()){
        file.mkdir();  //创建这个临时目录
    }

    //处理上传的文件，一般都需要通过流来获取，可以使用request.getInputStream()，原生态的文件上传流获取，十分麻烦
    //建议使用Apache的文件上传组件来实现，common-fileupload，它需要依赖于common-io组件
    try {
        //1、创建DiskFileItemFactory对象，处理文件上传路径或者大小限制
        DiskFileItemFactory factory = getDiskFileItemFactory(file);
        //2、获取ServletFileUpload
        ServletFileUpload upload = getServletFileUpload(factory);
        //3、处理上传文件
        String msg = uploadParseRequest(upload,request,uploadPath);
        //servlet请求转发消息
        request.setAttribute("msg",msg);
        request.getRequestDispatcher("info.jsp").forward(request,response);
    }catch (FileUploadException e){
        e.printStackTrace();
    }
}

//1
public static DiskFileItemFactory getDiskFileItemFactory(File file){
    DiskFileItemFactory factory = new DiskFileItemFactory();
    //通过这个工厂设置一下缓冲区，当上传的文件大于这个缓冲区的时候，将他放到临时文件中
    factory.setSizeThreshold(1024*1024);  //缓冲区大小为1M
    factory.setRepository(file);   //临时目录的保存目录，需要一个file
    return factory;
}

//2
public static ServletFileUpload getServletFileUpload(DiskFileItemFactory factory){
    ServletFileUpload upload = new ServletFileUpload(factory);
    //监听文件上传进度
    upload.setProgressListener(new ProgressListener() {
        @Override
        //pBytesRead：已经读取到的文件大小
        //pContentLength：文件大小
        public void update(long pBytesRead, long pContentLength, int pItems) {
            System.out.println("总大小："+pContentLength+"已上传："+pBytesRead);
        }
    });

    //处理乱码问题
    upload.setHeaderEncoding("UTF-8");
    //设置单个文件的最大值
    upload.setFileSizeMax(1024*1024*10);
    //设置总共能够上传文件的大小
    upload.setSizeMax(1024*1024*10);
    return upload;
}

//3
public static String uploadParseRequest(ServletFileUpload upload,HttpServletRequest request,String uploadPath) throws FileUploadException, IOException {
    String msg = "";
    List<FileItem> fileItems = upload.parseRequest(request);
    for(FileItem fileItem : fileItems){
        if(fileItem.isFormField()) {  //判断上传的文件是普通的表单还是带文件的表单
            //getFieldName指的是前端表单的控件name
            String name = fileItem.getFieldName();
            String value = fileItem.getString("UTF-8");  //处理乱码
            System.out.println(name + ":" + value);
        }else{  //判断它是上传的文件

            //=======================处理文件========================

            //拿到文件名字
            String uploadFileName = fileItem.getName();
            System.out.println("上传的文件名："+uploadFileName);

            if(uploadFileName.trim().equals("")||uploadFileName==null){
                continue;
            }
            //获得上传的文件名
            String fileName = uploadFileName.substring(uploadFileName.lastIndexOf("/")+1);
            //获得文件的后缀名
            String fileExtName = uploadFileName.substring(uploadFileName.lastIndexOf(".")+1);
            /*
                    如果文件后缀名 fileExtName 不是我们所需要的
                    就直接return  不处理。告诉用户文件类型不对
                 */
            System.out.println("文件信息 [文件名："+fileName+"---文件类型"+fileExtName+"]");

            //可以使用UUID（唯一标识通用码），保证文件名唯一
            //UUID.randomUUID()，随机产生一个唯一识别的通用码
            String uuidPath = UUID.randomUUID().toString();
            //=======================处理文件完毕=====================

            //存到哪里？uploadPath
            //文件真实存在的路径realPath
            String realPath = uploadPath+"/"+uuidPath;
            //给每个文件创建一个对应的文件夹
            File realPathFile = new File(realPath);
            if (!realPathFile.exists()){
                realPathFile.mkdir();
            }
            //=======================存放地址完毕=====================

            //获得文件上传的流
            InputStream inputStream = fileItem.getInputStream();

            //创建一个文件输出流
            //realPath = 真是的文件夹
            //差了一个文件；加上输出文件的名字+"/"+uuidFileName
            FileOutputStream fos = new FileOutputStream(realPath+"/"+fileName);

            //创建一个缓冲区
            byte[] buffer = new byte[1024*1024];

            //判断是否读取完毕
            int len = 0;
            //如果大于0说明还存在数据
            while ((len = inputStream.read(buffer))>0){
                fos.write(buffer,0,len);
            }
            //关闭流
            fos.close();
            inputStream.close();

            msg = "文件上传成功！";
            fileItem.delete();  //上传成功，清除临时文件
        }
    }
    return msg;
}

十六、邮件收发

1、传输协议

SMTP协议

发送邮件：SMTP协议

通常把处理用户smtp请求（邮件发送请求）的服务器称之为SMTP服务器（邮件发送服务器）。

POP3协议

接收邮件：POP3协议

通常把处理用户pop3请求（邮件接受请求）的服务器称之为POP3服务器（邮件接收服务器）。

2、邮件收发原理

邮件收发原理

1、张三通过smtp协议连接smtp服务器，然后发送一封邮件给网易的邮件服务器

2、QQ分析发现需要去网易的邮件服务器，通过smtp协议将邮件转投给网易的smtp服务器

3、网易接受到的邮件存储在***@163.com这个邮件账号的空间中

4、李四通过pop3协议连接到pop3服务器收取邮件

5、从***@163.com这个邮件账号的空间中取出邮件

6、pop3服务器将取出来的邮件送到李四手中

注意：

（地址正确）有时可能收件箱服务器会拒收发送的邮件（例如认为你的邮件是广告），可能会在垃圾箱里找到，也有可能找不到。建议更换收件箱试试或重复的邮件内容不要多次发送。

3、Java发送邮件

Java发送E-Mail需要准备JavaMail API和Java Activation Framework。

mail.jar
activation.jar

发送一封简单的邮件，确保电脑可以连接网络。

创建包含邮件服务器的网络连接信息的Session对象。
创建代表邮件内容的Message对象。
创建Transport对象，连接服务器，发送Message，关闭连接。

四个核心类：

四个核心类

public static void main(String[] args) throws GeneralSecurityException, MessagingException {
    Properties prop = new Properties();
    prop.setProperty("mail.host","smtp.qq.com");  //设置QQ邮件服务器
    prop.setProperty("mail.transport.protocol","smtp");  //邮件发送协议
    prop.setProperty("mail.smtp.auth","true");   //需要验证用户名和密码

    //关于QQ邮箱，还要设置SSL加密，加上以下代码即可
    MailSSLSocketFactory sf = new MailSSLSocketFactory();
    sf.setTrustAllHosts(true);
    prop.put("mail.smtp.ssl.enable","true");
    prop.put("mail.smtp.ssl.socketFactory",sf);

    /*使用JavaMail发送邮件的5个步骤*/
    //1、创建定义整个应用程序所需的环境信息的Session对象

    //创建定义整个应用程序所需的环境信息的Session
    //QQ才有，其他邮箱就不用
    Session session = Session.getDefaultInstance(prop, new Authenticator() {
        @Override
        protected PasswordAuthentication getPasswordAuthentication() {
            //发件人邮件用户名、授权码
            return new PasswordAuthentication("QQ邮箱","授权码");
        }
    });

    /*//开启Session的debug模式，这样就可以查看到程序发送Email的运行状态
        session.setDebug(true);*/


    //2、通过Session得到transport对象
    Transport ts = session.getTransport();
    //3、使用邮箱的用户名和授权码连上邮件服务器
    ts.connect("smtp.qq.com","QQ邮箱","授权码");
    //4、创建邮件：写邮件
    MimeMessage message = new MimeMessage(session);
    message.setFrom(new InternetAddress("QQ邮箱"));  //指明邮件的发件人
    message.setRecipient(Message.RecipientType.TO,new InternetAddress("QQ邮箱"));//指明邮件的收件人
    message.setSubject("只包含文本的简单邮件");  //邮件的标题
    message.setContent("<h3 style='color:red'>你好呀！</h3>","text/html;charset=UTF-8");   //邮件的文本内容

    //5、发送邮件
    ts.sendMessage(message,message.getAllRecipients());
    //6、关闭连接
    ts.close();
}

4、带图片和附件的邮件

MIME（多用途互联网邮件扩展类型）

MimeBodyPart类

javax.mail.internet.MimeBodyPart类表示一个MIME消息，它和MimeMessage类一样都是从Part接口继承过来的。

MimeMultipart类

javax.mail.internet.MimeMultipart是抽象类Multipart的实现子类，它用来组合多个MIME消息。一个MimeMultipart对象可以包含多个代表MIME消息的MimeBodyPart对象。

Multipart

带图片的邮件

public static void main(String[] args) throws GeneralSecurityException, MessagingException {
    Properties prop = new Properties();
    prop.setProperty("mail.host","smtp.qq.com");  //设置QQ邮件服务器
    prop.setProperty("mail.transport.protocol","smtp");  //邮件发送协议
    prop.setProperty("mail.smtp.auth","true");   //需要验证用户名和密码

    //关于QQ邮箱，还要设置SSL加密，加上以下代码即可
    MailSSLSocketFactory sf = new MailSSLSocketFactory();
    sf.setTrustAllHosts(true);
    prop.put("mail.smtp.ssl.enable","true");
    prop.put("mail.smtp.ssl.socketFactory",sf);

    /*使用JavaMail发送邮件的5个步骤*/
    //1、创建定义整个应用程序所需的环境信息的Session对象

    //创建定义整个应用程序所需的环境信息的Session
    //QQ才有，其他邮箱就不用
    Session session = Session.getDefaultInstance(prop, new Authenticator() {
        @Override
        protected PasswordAuthentication getPasswordAuthentication() {
            //发件人邮件用户名、授权码
            return new PasswordAuthentication("QQ邮箱","授权码");
        }
    });

    //开启Session的debug模式，这样就可以查看到程序发送Email的运行状态
    session.setDebug(true);


    //2、通过Session得到transport对象
    Transport ts = session.getTransport();
    //3、使用邮箱的用户名和授权码连上邮件服务器
    ts.connect("smtp.qq.com","QQ邮箱","授权码");
    //4、创建邮件：写邮件
    MimeMessage message = new MimeMessage(session);
    message.setFrom(new InternetAddress("QQ邮箱"));  //指明邮件的发件人
    message.setRecipient(Message.RecipientType.TO,new InternetAddress("QQ邮箱"));//指明邮件的收件人
    message.setSubject("带图片的邮件");  //邮件的标题
    //==============================================================
    //准备图片数据
    MimeBodyPart image = new MimeBodyPart();
    //图片需要经过数据处理。DataHandler：数据处理
    DataHandler dh = new DataHandler(new FileDataSource("文件路径\\test.jpg"));
    image.setDataHandler(dh);  //Body中放入处理的图片数据
    image.setContentID("test.jpg");  //给图片设置一个ID

    //准备正文数据
    MimeBodyPart text = new MimeBodyPart();
    text.setContent("这是一封邮件正文带图片<img src='cid:test.jpg'>的邮件","text/html;charset=UTF-8");

    //描述数据关系
    MimeMultipart mm = new MimeMultipart();
    mm.addBodyPart(text);
    mm.addBodyPart(image);
    mm.setSubType("related");

    //设置到消息中，保存修改
    message.setContent(mm);  //把最后编辑好的邮件放到消息当中
    message.saveChanges();   //保存修改
    //==============================================================

    //5、发送邮件
    ts.sendMessage(message,message.getAllRecipients());
    //6、关闭连接
    ts.close();
}

带图片和附件的复杂邮件

public static void main(String[] args) throws GeneralSecurityException, MessagingException {
        Properties prop = new Properties();
        prop.setProperty("mail.host","smtp.qq.com");  //设置QQ邮件服务器
        prop.setProperty("mail.transport.protocol","smtp");  //邮件发送协议
        prop.setProperty("mail.smtp.auth","true");   //需要验证用户名和密码

        //关于QQ邮箱，还要设置SSL加密，加上以下代码即可
        MailSSLSocketFactory sf = new MailSSLSocketFactory();
        sf.setTrustAllHosts(true);
        prop.put("mail.smtp.ssl.enable","true");
        prop.put("mail.smtp.ssl.socketFactory",sf);

        /*使用JavaMail发送邮件的5个步骤*/
        //1、创建定义整个应用程序所需的环境信息的Session对象

        //创建定义整个应用程序所需的环境信息的Session
        //QQ才有，其他邮箱就不用
        Session session = Session.getDefaultInstance(prop, new Authenticator() {
            @Override
            protected PasswordAuthentication getPasswordAuthentication() {
                //发件人邮件用户名、授权码
                return new PasswordAuthentication("QQ邮箱","授权码");
            }
        });

        //开启Session的debug模式，这样就可以查看到程序发送Email的运行状态
        session.setDebug(true);


        //2、通过Session得到transport对象
        Transport ts = session.getTransport();
        //3、使用邮箱的用户名和授权码连上邮件服务器
        ts.connect("smtp.qq.com","QQ邮箱","授权码");
        //4、创建邮件：写邮件
        MimeMessage message = new MimeMessage(session);
        message.setFrom(new InternetAddress("QQ邮箱"));  //指明邮件的发件人
        message.setRecipient(Message.RecipientType.TO,new InternetAddress("QQ邮箱"));//指明邮件的收件人
        message.setSubject("带图片的邮件");  //邮件的标题
        //==============================================================
        /*
            编写邮件内容
            1、图片
            2、附件
            3、文本
         */
        //准备图片数据
        MimeBodyPart image = new MimeBodyPart();
        //图片需要经过数据处理。DataHandler：数据处理
        DataHandler dh = new DataHandler(new FileDataSource("文件路径\\test.jpg"));
        image.setDataHandler(dh);  //Body中放入处理的图片数据
        image.setContentID("test.jpg");  //给图片设置一个ID

        //准备正文数据
        MimeBodyPart text = new MimeBodyPart();
        text.setContent("这是一封邮件正文带图片<img src='cid:test.jpg'>","text/html;charset=UTF-8");

        //附件
        MimeBodyPart attachment = new MimeBodyPart();
        attachment.setDataHandler(new DataHandler(new FileDataSource("文件路径\\test.pdf")));
        attachment.setFileName("test.pdf");

        //拼接邮件正文内容
        MimeMultipart mm = new MimeMultipart();
        mm.addBodyPart(text); //文本
        mm.addBodyPart(image);  //图片
        mm.setSubType("related");

        //将拼接好的正文内容设置为主体
        MimeBodyPart contentText = new MimeBodyPart();
        contentText.setContent(mm);

        //拼接附件
        MimeMultipart allFile = new MimeMultipart();
        allFile.addBodyPart(attachment);  //附件
        allFile.addBodyPart(contentText);  //正文
        allFile.setSubType("mixed");  //正文和附件都存在邮件中，所有类型设置为mixed

        //设置到消息中，保存修改
        message.setContent(allFile);  //把最后编辑好的邮件放到消息当中
        message.saveChanges();   //保存修改
        //==============================================================

        //5、发送邮件
        ts.sendMessage(message,message.getAllRecipients());
        //6、关闭连接
        ts.close();
    }

5、JavaWeb发送邮件