JavaWeb笔记

2022-01-21

听完后的总结：编写javaweb的过程：
1.建Maven项目，引入jar包
2.建Maven的webapp项目，将web.xml的内容更新成固定模板

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
         http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
        version="4.0"
        metadata-complete="true">

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

</web-app>

3.写前端：jsp文件（项目路径：${pageContext.request.contextPath}）
4.写后端：class文件：
先extends HTTPServlet
然后Alt+Ins，重写doGet和DoPost方法（后者不需要的话可以直接调用前者）
在服务端输出用的函数：“sout”
在前端输出：out.write()
更改和查看服务器所发出包的内容（主要是更改）：resp.方法()（get/set/add+……）
更改和查看客户端的数据（主要是查看）：req.方法()（get/set/add+……）
路径：和后面在web.xml注册的路径有关，注册的内容可以当成一个文件来理解其绝对和相对路径，绝对路径是从此项目开始的。
5.注册网页：
在web.xml上写以下内容

<!--注册Servlet-->
    <servlet>
    	<!--注册名，可随便取-->
        <servlet-name>hello</servlet-name>
        <!--class文件路径，从java文件往下开始写-->
        <servlet-class>com.kuang.servlet.HelloServlet</servlet-class>
    </servlet>
    <!--Servlet的请求路径-->
    <servlet-mapping>
    	<!--注册名，必须和上面那个一样-->
        <servlet-name>hello</servlet-name>
        <!--访问路径，访问时需要先加上在tomcat里（或创建Maven时）配的这个项目的路径-->
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

6.配置Tomcat
点右上角编辑配置，选择tomcat-本地
填：“名称”“服务器”“默认浏览器”（下面的URL可以参考为路径）“JRE”“端口”
然后必须点“部署”，点“+”，点“工件”，导入对应的war包（很重要！）
点确定，点开始

正片：

1.1 web开发：
静态web：html，css。提供给所有人看的数据始终不会发生变化
动态web：常用技术栈：Servlet/JSP，ASP，PHP。我的理解：不同账号看到的信息不同。

在Java中，动态web次元开发的技术统称为JavaWeb

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

1.3 静态web
*.htm、*.htm

缺点：无法动态更新
轮播图：点击特效：伪动态
JavaScript、VBScript
无法和数据库交互

1.4 动态web

2.1 web服务器
ASP：微软：国内最早流行的。在HTML中嵌入了VB的脚本，ASP+COM。在ASP开发中，基本上一个页面都有几千行的业务逻辑代码，页面极其混乱，维护成本高（重构成本高）。C#。IIS服务器。
PHP：PHP开发速度很快，功能很强大，跨平台，代码很简单。无法承载大访问量的情况下（如果淘宝用PHP，双十一一天几亿的并发，秒炸），所以局限在中小型网站（占中国70%左右）
JSP/Servlet：sun公司开发。B/S架构：浏览器和服务器。基于Java语言的，所有大公司，或者一些开源组件，都是用Java写的。可以承载三高问题带来的影响。语法像ASP。

2.2 web服务器
IIS（微软）（Windows自带的和WebLog等）
Tomcat
文件目录：
bin：启动，关闭的脚本文件
conf：配置
lib：以来的jar包
logs：日志
webapps：存放网站
启动、关闭tomcat
startup.bat
shutdown.bat
(有时候会报错没有JAVA_HOME，就现在用户环境下建一个JAVA_HOME，然后在系统变量的Path下放一个%JAVA_HOME%)（或者直接改bat里的路径，但是会影响idea）

3.1目录：
conf：配置
server.xml:服务器核心配置
Connector：改端口（默认8080）
Host（不要碰Engine！）：改name能改访问的域名（原来为localhost），但是并没有改域名解析，所以暂时是无法访问的，可以改C:\Windows\System32\drivers\hosts可以解析上去（phpstudy应该就是这样做的），但不建议。改appBase可以修改网站目录
logs：日志（非常重要，可以看所有的传包的GET传参内容）
webapps：网站目录
ROOT：根目录
WEB-INF：下面有和web.xml。这个是安全目录，客户端无法访问，只有服务端可以访问的目录（可以把很多后端脚本扔进去，防止被访问到）。
访问顺序：如果访问index/这个目录，会先检索webapps目录，如果有index目录则访问其中的index.*，如果没有会检索ROOT目录的index目录
examples：例子目录（有大量源码，用于学习）
docs：tomcat的帮助文档
manager和host-manager：管理页面，需要登录

4.1 HTTP
HTTP/1.0
HTTP/1.1

头部参数（消息）
Accept：告诉浏览器所支持的数据类型
Accept-Encoding：支持哪种编码格式（GBK，UTF-8）
Accept-language：语言环境
Cache-Control：缓存控制
Connection：告诉浏览器请求完成是断开还是保持连接
HOST：主机
Refresh:多久刷新一次
Location：让网页重新定位

200：成功
3xx：重定向
4xx：资源不存在
5xx：服务器代码错误（502：网关错误）

5.Maven
为什么学习这个技术：
1.在Javaweb开发中，需要使用大量的jar包，我们手动去导入
2.如何能够让一个东西自动帮我们导入并配置这个jar包
5.1 Maven项目架构管理工具
目前用来导入jar包
核心思想：约定大于配置
有约束，不要去违反
Maven会规定好你该如何去编写我们的java代码，必须按照这个规范来
5.2安装Maven
下载zip包解压
然后配置镜像（mirror），不然下的死慢
配阿里云，从网上搜maven阿里云镜像，然后把一整格mirror标签扔进mirrors标签里

5.3配置环境变量
系统变量：
M2_HOME maven的bin目录
MAVEN_HOME maven的目录
Path中 maven的bin目录
测试：mvn -version

5.4 本地仓库
新建文件加maven-repo
在settings票签下建一个localRepository标签，然后把路径放进去
更新仓库

5.5 在IDEA中使用Maven
1.启动IDEA
2.创建一个Maven项目

5.6 在IDEA中使用MAVEN
1.启动IDEA
2.创建一个MavenWeb项目（勾选Create from archetype可以使用Maven的模板）
（选中maven-archetype-webapp，点击next，创建组和名，next，path选中maven，finish）
IDEA项目创建成功后，看一眼Maven的配置

5.7 创建一个普通的Maven项目
不勾选，直接走下一步（没有选仓库的位置，容易出问题，要改setting下的目录）

src目录下：
main：
java：放置java源代码
resources：放置配置文件
test：
java：测试使用

刚刚创建的Maven：
main：
webapp：
WEB-INF
index.jsp
所以要在main下加java和resources文件夹，然后标记java为源码目录，就可以创建class文件了，将resources目录标记为资源目录

5.8 在IDEA中配置Tomcat
1.点击右上角的“添加配置”，点击“+”
2.找到并选择Tomcat，用本地
3.名称：服务器启动名称，随便配
浏览器：
JRE：配java环境
端口：Tomcat的端口

底下会报错：未指定应用服务器。
是因为没选择tomcat目录
然后转到“部署”，点“+”，“工件”，新建第一个

4.启动Tomcat

访问端口就会显示index.jsp的内容

5.9 Maven侧边栏
点开右侧的Maven
“生命周期”下是Maven的命令行操作
“插件”：甚至可以删掉
“项目依赖”

5.10 pom文件
pom.xml 是Maven的核心配置文件
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>com.kuang</groupId>
  <artifactId>javaweb-01-maven</artifactId>
  <version>1.0-SNAPSHOT</version>
  <!--Package：项目的打包方式
  jar：java应用
  war：JavaWeb应用-->
  <packaging>war</packaging>

  <!--name可删-->
  <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包配置-->
    <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的高级之处在于它会帮你导入这个jar包所依赖的其他jar包

Maven由于约定大于配置，所以之后有可能会遇到自己写的配置文件，无法被导出或者生效的问题，解决方案：在build下面加一个resources（可以百度：Maven资源导出问题）

Maven右边栏打开后在最上行有一个“显示依赖项”，点击后可以生成目录的树，直接显示所有jar包的依赖关系（比如一个包出问题了，可以显示会影响到哪些包）

6.Servlet
6.1 Servlet简介
sun公司开发动态web的一门技术
sun公司在这些API中提供了一个接口叫：Servlet，如果想开发一个Servlet程序，只需要完成两个步骤：
编写一个来，实现Servlet接口
把开发好的Java类部署到Web服务器中
把实现了Servlet接口的Java程序叫做Servlet

6.2 HelloServlet
1.构建一个普通的Maven项目，删掉src目录，以后学习就在这个项目里建立Module;这个空的工程就是Maven的主工程（记得先把Maven的目录配置了）
2.导入依赖（百度：Maven Servlet jsp依赖）（Tomcat10+的依赖变为jakarta.servlet）（最好直接去Maven官网搜servlet API，jsp API）（貌似也搜到了tomcat Servlet API和tomcat jsp API）（询问过群里师傅发现，tomcat10是支持Servlet5.0版本的，但是servlet API只到4.0.1，所以只能用tomcat-servlet API）

快捷键：alt+ins：调出重写等选项的框
alt+enter：引入局部变量

3.新建一个module
Maven选webapp

4.编写一个类

package com.kuang.servlet;


import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.io.PrintWriter;

public class HelloServlet extends HttpServlet {
    //重写方法
    //由于GET和POST只是请求实现的不同方式，所以可以互相调用，因为业务逻辑都一样


    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("进入doGet方法");
        //ServletOutputStream outputStream = resp.getOutputStream();
        PrintWriter writer = resp.getWriter();//响应流
        writer.print("HEllo,Servlet");
    }

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

5.编写Servlet的映射
为什么要映射？
我们写的是java程序，但是要通过浏览器访问，而浏览器需要连接web服务器，所以我们需要在web中注册我们写的Servlet，还需要给他一个浏览器能够访问的路径（修改web.xml）

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
         http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
        version="4.0"
        metadata-complete="true">

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

6.配置tomcat
一定要在“工件”里导入war包！！！（第一次没有这个选项就重启idea）

7.启动测试
如果是tomcat10的话直接用Servlet的api会500，只能用tomcat-Servlet的api（或者jakarta.servlet.api，换名字了）（参考版本对比表）（需要删掉原api，重新调用）https://blog.csdn.net/m0_49500992/article/details/108452815

6.3 Servlet原理

6.4 Mapping
1.一个Servlet可以指定一个映射路径

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

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

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

3.一个Servlet可以指定通用的映射路径（通配符*）

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

特例：因为优先级更高，所以会直接覆盖index.jsp（少用）

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

4.指定一些后缀或前缀等等（可能会报错，*前面不能加项目映射的路径，包括/,意思是以这个结尾的所有路径）(很多网页都用do，是以前遗留的问题)

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

5.重写404页面

package com.kuang.servlet;

import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.io.PrintWriter;

//自己写报错页面
public class ErrorServlet extends HelloServlet{
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html");
        resp.setCharacterEncoding("utf-8");

        PrintWriter writer = resp.getWriter();
        writer.print("<h1>404<404>");

    }

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

web.xml:

<!--404-->
<servlet>
    <servlet-name>error</servlet-name>
    <servlet-class>com.kuang.servlet.ErrorServlet</servlet-class>
</servlet>
<!--Servlet的请求路径-->
<servlet-mapping>
    <servlet-name>error</servlet-name>
    <url-pattern>/*</url-pattern>
</servlet-mapping>

（理论上也包含了hello，但是并不影响，因为优先级问题）
6.优先级问题
置顶了固有的映射路径优先级更高（hello），如果找不到就会走默认的处理请求（通配符）

6.5 ServletContext
部署时保证war包只有一个，不然会重新打包一遍

web容器在启动的时候，它回味每个web程序都创建一个对应的ServletContext对象，它代表了当前的web应用
应用：
(1)共享数据
我在这个Servlet保存的数据，可以在另外一个Servlet中拿到

package com.kuang.servlet;

import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //this.getInitParameter() 初始化参数
        //this.getServletConfig() 配置
        //this.getServletContext() 上下文
        ServletContext context = this.getServletContext();
        String username="scr";//数据
        context.setAttribute("username",username);//将一个数据保存在一个servletcontext中
        System.out.println("hello");
    }

}

package com.kuang.servlet;

import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;

public class GetServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        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);
    }
}

web.xml:

<servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>com.kuang.servlet.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>
    
    <servlet>
        <servlet-name>getc</servlet-name>
        <servlet-class>com.kuang.servlet.GetServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>getc</servlet-name>
        <url-pattern>/getc</url-pattern>
    </servlet-mapping>

(2)配置和调用初始化参数：

package com.kuang.servlet;

import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;

public class ServletDemo03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        String url=context.getInitParameter("url");//获取参数
        resp.getWriter().print(url);

    }

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

web.xml:

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

<servlet>
    <servlet-name>gp</servlet-name>
    <servlet-class>com.kuang.servlet.ServletDemo03</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>gp</servlet-name>
    <url-pattern>/gp</url-pattern>
</servlet-mapping>

(3)请求转发(和重定向有区别，url路径没有变，返回值是200，不是300）：

package com.kuang.servlet;

import jakarta.servlet.RequestDispatcher;
import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;

public class ServletDemo04 extends HttpServlet {
    @Override
    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);
    }
}

<servlet>
    <servlet-name>sd4</servlet-name>
    <servlet-class>com.kuang.servlet.ServletDemo04</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>sd4</servlet-name>
    <url-pattern>/sd4</url-pattern>
</servlet-mapping>

(4)读取资源文件
Properties类
在java目录下新建properties
在resources目录下新建properties
发现：都被打包到了同一个路径下：classes，我们速成这个路径问classpath
思路：都需要一个文件流
资源文件：

1 2	username=root password=123456

public class ServletDemo05 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
InputStream is = this.getServletContext().getResourceAsStream("/WEB-INF/classes/com/kuang/servlet/aa.properties");
Properties prop = new Properties();
prop.load(is);
String user = prop.getProperty("username");
String pwd = prop.getProperty("password");
resp.getWriter().print(user+":"+pwd);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
doGet(req, resp);
}
}

6.6 httpServletResponse
web服务器接收到客户端的http请求，针对这个请求，分别创建一个代表请求的HTTPServletRequest对象，代表响应的一个HTTPServletResponse

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

1、简单分类
负责向浏览器发送数据的方法：
getOutputStream()
getWriter()

负责向浏览器发一些响应头的方法：
setCharacterEncoding()
setContentLength()
setContentLengthLong()
setContentType()
setDateHeader()
addDateHeader()
setHeader()
addHeader()
setIntHeader()
addIntHeader()
setStatus()

2.常见应用
1.向浏览器输出信息(略)
2.下载文件
获取下载路径
下载的文件名
设置想办法让浏览器能够支持下载我们需要的东西
获取下载的文件输入流
创建缓冲区
获取OutputStream对象
将FileOutputStraem流写入到buffer缓冲区
使用OutputStream将缓冲区中的数据输出到客户端

package com.kuang.servlet;

import jakarta.servlet.ServletException;
import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.FileInputStream;
import java.io.IOException;

public class FIleServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //1、获取下载文件的路径
        String realPath= "C:\\Users\\30389\\IdeaProjects\\javaweb-01-maven\\javaweb-02-servlet\\servlet-03\\src\\main\\resources\\1.png";
        System.out.println("下载的文件路径："+realPath);
        //2.下载的文件名
        String fileName = realPath.substring(realPath.lastIndexOf("\\") + 1);
        //3.设置想办法让浏览器能够支持下载我们需要的东西(百度：web下载文件的头信息https://www.cnblogs.com/huangui/p/12767965.html）
        resp.setHeader("Content-disposition","attachment;filename"+ fileName);
        //4.获取下载文件的输入流
        FileInputStream in = new FileInputStream(realPath);
        //5.创建缓冲区
        int len=0;
        byte[] buffer = new byte[1024];
        //6.获取输出流的对象
        ServletOutputStream out = resp.getOutputStream();
        //7.将FileOutputStream流写入到buffer缓冲区
        while((len=in.read(buffer))>0){
            out.write(buffer,0,len);
        }
        //关闭流
        in.close();
        out.close();


    }

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

3.验证码功能
前端实现
后端实现，需要用到Java的图片类，产生一个图片

package com.kuang.servlet;

import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.Random;

public class ImageServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //如何让浏览器5秒钟自动刷新一次；
        resp.setHeader("refresh","3");//设置服务器每三秒刷新一次
        //在内存中创建一个图片
        BufferedImage image = new BufferedImage(80, 20, BufferedImage.TYPE_INT_RGB);
        //得到图片
        Graphics2D g = (Graphics2D) image.getGraphics();//逼
        //设置图片的背景颜色
        g.setColor(Color.white);
        g.fillRect(0,0,80,20);
        //给图片写数据
        g.setColor(Color.BLUE);
        g.setFont(new Font(null,Font.ITALIC,20));
        g.drawString(makeNum(),0,20);

        //告诉浏览器，这个请求用图片的方式打开
        resp.setContentType("image/jpeg");
        //网站存在缓存，不让浏览器缓存
        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(9999)+"";
        StringBuffer sb = new StringBuffer();
        for(int i=0;i<4-num.length();i++){
            sb.append(0);
        }
        num=sb.toString()+num;
        return num;//这样才能保证数字一定是4位的，如果不是4位会用0填充，不然没法生成小于1000的数
    }

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

4.重定向（最重要的）
    url会变
    常见场景：用户登录
    方法：sendRedirect

package com.kuang.servlet;

import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;

public class RedirectServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.sendRedirect("/servlet_03_war/image");
    }

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

重定向（发两次请求，先向A发请求，获得B的路径，然后向B发请求）
转发（发一次请求，向A发请求，A获取B的内容后直接返回给客户端）

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

req.getContextPath()//获取项目路径（不是很好用，要确定它的根目录是什么）

补充：自己的理解：注册其实相当于创建一个文件，不如注册一个路径为/login，相当于在网页此项目上创建一个login文件，然后像是/index.jsp相当于和它同目录下的文件，所以互相访问可以用相对路径index.jsp和绝对路径/index.jsp

package com.kuang.servlet;

import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.util.Arrays;

public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        String[] hobby = req.getParameterValues("hobby");
        System.out.println(username);
        System.out.println(password);
        System.out.println(Arrays.toString(hobby));

        //通过请求转发(这里可以走相对路径，因为本文件相当于/login，所以相对路径就是success.jsp。也可以走绝对路径，因为网页根目录就是servlet-03，所以相对路径就是/success.jsp）
        req.getRequestDispatcher("success.jsp").forward(req,resp);
    }

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

<%--
  Created by IntelliJ IDEA.
  User: 30389
  Date: 2022/1/24
  Time: 14:50
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登录</title>
</head>
<body>
<h1>登录</h1>
<div style="text-align:center">
    <%--这里表单表示的意思：以post方式提交表单，提交到我们的Login请求(定位到login目录)--%>
    <form action="${pageContext.request.contextPath}/login" method="post">
        用户名：<input type="text" name="username"><br>
        密码：<input type="text" name="password"><br>
        爱好：
        <input type="checkbox" name="hobby" value="唱歌">唱歌
        <input type="checkbox" name="hobby" value="跳舞">跳舞
        <input type="checkbox" name="hobby" value="篮球">篮球
        <br>
        <input type="submit">
    </form>
</div>

</body>
</html>

<%--
  Created by IntelliJ IDEA.
  User: 30389
  Date: 2022/1/24
  Time: 14:58
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>登陆成功</h1>
</body>
</html>

<servlet>
    <servlet-name>LoginServlet</servlet-name>
    <servlet-class>com.kuang.servlet.LoginServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>LoginServlet</servlet-name>
    <url-pattern>/login</url-pattern>
</servlet-mapping>

7.Cookie、Session
Cookie:服务端发给客户端，保存在客户端上的
Session：服务器自己保存客户端的访问信息，保存在服务器上

7.2 保存会话的两种技术
cookie
客户端技术（响应，请求）
session
服务器技术，可以保存用户的会话信息，我们可以把信息或者数据放在Session中

常见：登录维持

cookie：

package com.kuang.servlet;

import jakarta.servlet.ServletException;
import jakarta.servlet.http.Cookie;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;

//保存用户上一次访问的时间
public class CookieDemo01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //解决中文乱码问题
        req.setCharacterEncoding("utf-8");
        resp.setContentType("text/html");
        resp.setCharacterEncoding("utf-8");
        PrintWriter out= resp.getWriter();
        //从客户端获取cookie
        Cookie[] cookies = req.getCookies();
        //判断cookie是否存在
        if(cookies!=null){
            out.write("上一次访问的时间：");
            for(Cookie cookie:cookies){
                //获取cookie取得的名字,并判断是否为"lastLoginTime"
                if(cookie.getName().equals("lastLoginTime")){
                    //获取cookie中的值
                    long l = Long.parseLong(cookie.getValue());
                    Date data=new Date(l);//将cookie.getValue()的值转换为Date（时间）类型
                    out.write(String.valueOf(data));//将Date类型转换为string
                    out.write("<br>"+cookie.getValue());
                }
            }
        }else{
            out.write("这是第一次访问");
        }
        //服务器给客户端相应一个cookie
        Cookie cookie = new Cookie("lastLoginTime", System.currentTimeMillis()+"");//该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。
        cookie.setMaxAge(24*60*60);//设置有效期为1天
        resp.addCookie(cookie);
    }

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

可以用这个程序测试cookie特性：当浏览器关闭（整个关闭）后，就不会再保存cookie了，会再次显示“这是第一次访问”

（这种方法只是设置了cookie在浏览器的生存周期，cookie内容的有效期验证在服务端，根据cookie的内容等信息进行验证）

一个cookie只能存一个信息
一个web站点可以给浏览器发送多个cookie，最多存放20个cookie
cookie大小限制4kb
300个cookie是浏览器的上限

删除cookie：
1.不设置有效期，关闭浏览器自动失效
2.设置有效期时间为0（不想动程序主要代码，让cookie暂时失效的方法）

7.4 Session
什么是Session？
服务器会给每个用户（浏览器）常见Session对象
一个Session独占一个浏览器，只要浏览器没有关闭，这个Session就存在

Session和Cookie的区别：
session:我的理解：在客户端部分其实就是一个cookie，会获取一段数据，然后服务器也存储了这段数据，并且这段数据在服务器上对应着一些信息


创建session

创建一个对象：

1	查询session：

1	注销session：

1 2	设置session默认的超时时间：


8、JSP
8.1 什么是JSP
Java Server Pages：Java服务器页面，也和Servlet一样，用于动态Web技术
（相当于把整个语句用out.write()打印）
最大特点：写JSP就像在写HTML
区别：HTML只给用户提供静态的数据，JSP页面中可以嵌入Java代码，为用户提供动态数据

8.2 JSP原理
思路：JSP是怎么执行的
tomcat中有一个work目录，IDEA中使用Tomcat的会在IDEA的tomcat中生产一个work目录
JSP最后会转换成一个JAVA类

8.3 JSP基础语法和指令
导入包（maven）
Servlet，jsp，jstl


JSP语法基础
注释:```<%--hcfakscjnaso--%>```(不会在客户端显示)
JSP表达式(这就是ssrf的原因)

1	JSP脚本片段```<%= java代码%>```：作用域为方法

1	JSP声明 ```<%! java代码%>```：作用域为类

1
2
3

JSP声明会被编译到生成的JAVA类的类中，JSP脚本片段会被生成到_jspService方法中

简化：用```$```符号取数（ssrf的另一种你那个用法）（EL表达式）


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

定制错误页面 ```<%@ page errorPage="500.jsp" %>```错误时直接跳转到自定义的500.jsp页面
（可以在web.xml里进一步配置error界面）


文件包含：```<%@ include file="common/header.jsp"%>```
文件包含（JSP标签）```<jsp:include page="common/header.jsp"/>```


8.5 9大内置对象
PageContext ：存东西
Request ：存东西哦
Response
Session ： 存东西
Application  :存东西（ServletContext）
config ：（ServletConfig）
out
page
excepetion

用法举例：```<%@ page import = "java.util.Date"%>```
存东西：(取东西就是get，省略)

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


8.6 jsp标签，jstl标签，el标签

el表达式： ```${}```
	获取数据
	执行运算
	获取web开发的常用对象


jsp标签：

<jsp:include page=”” />
<jsp:forward page=”” />

<jsp:forward page=”” >
<jsp:param name=”name” value=”kuang”>
<jsp:param name=”age” value=”1”>


jstl表达式：
jstl标签库的使用就是为了弥补html标签的不足，它自定义了许多的标签，可以供我们使用，标签的功能和java代码一样
（菜鸟教程：https://www.runoob.com/jsp/jsp-jstl.html ）
核心标签
格式化标签
sql标签
xml标签

例：


9.JavaBean
实体类
JavaBean有特定的写法：
	必须要有一个无参构造
	属性必须私有化
	必须有对应的get/set方法
一般用来和数据库的字段做映射 ORM
ORM：对象关系映射
	表->类
	字段->属性
	行记录->对象

<jsp:useBean id=”people” class=”” scope=”page”/> //class的参数是自己设置的实体类，里面存的数据，可以理解为数据库
<jsp:setProperty name=”people” property=”name” value=”kuang”/> //存数据
<jsp:getProperty name=”people” property=”name” /> //查数据


10、MVC三层架构：
什么是MVC：Model  View  Controller  模型、视图、控制器

（没有什么事多加一层不能解决的）

11.JDBC(抽时间补，通过url的方式访问mysql)
导入mysql-connect-java的接口

String url=”jdbc:mysql://localhost:3306/jdbc?useUnicode=true&charaterEncode=utf-8&useSSL=true”;
String username=”root”;
String password=”123456”;
Connection connection= DriverManager.getConnection(url,username,password);//通过访问端口的方式连接sql
Statement statement=connection.createStatement();//执行sql的对象
String sql=”SELECT * FROM users”;
ResultSet resultSet = statement.executeQuery(sql);//查询并返回结果
//打印
while(resultSet.next()){
System.out.println(resultSet.getObject(“id”));
}
//释放连接
resultSet.close();
statement.close();
connection.close();
```