Javaweb基础

1.基本概念

web开发：

• web：网页的意思
• 静态web
  • html，css
  • 提供给别人的数据不会发生变化
• 动态web
  • 淘宝
  • 提供给别人的数据始终会发生变
  • 技术栈：Servlet/jsp asp php

1.2.web应用程序

• 一个·web应用由多部分组成(静态web， 动态web)
  • html，css
  • jsp，servlet
  • java程序
  • jar包
  • 配置文件
• 若想给外界访问，需要一个服务器

1.3、静态web

• htm，html这些都是网页的后缀。如果服务器存在，我们就可以直接读取。

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aLZgCHuN-1642506947467)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211124143654542.png)]

• 静态web的缺点

  • web页面无法动态更新，所有用户看到的都是同一个页面
  • 轮播图，点击特效
  • JavaScript（实际中用的多）
  • VBScript
  • 它无法和数据库交互（数据无法持久化，用户无法交互）

1.4、动态web

页面会动态展示：‘’web的页面展示的效果因人而异‘’

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mBz2h9WO-1642506947468)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211124144827780.png)]

file system：电脑里的文件系统

缺点：

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

优点：

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

2.Web服务器

ASP

• 微软：国内最早流行的就是ASP

• 在html中嵌入了vb的脚本，ASP+COM:

• 在ASP的开发中基于一个页面都有几千行的代码，页面极其混乱

• 维护成本高

• c#

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ztRfBiQB-1642506947468)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211124151357925.png)]

  PHP

• PHP开发速度很快，功能很强大，跨平台，代码很简单（70%）

• 无法承载大的访问量（局限性）

JSP/Servlet：

B/S:浏览和服务器

C/S:客户端和服务器

• sun公司主推的B/S架构
• 基于java语言的（所有大公司，或者开源的组件，都是用java写的）
• 可以承载三高问题带来的影响（高并发，高实现，高效）
• 语法像ASP,ASP–>JSP 功能很强大

2.2Web服务器

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

lls

微软的，Windows中自带的

3.Tomcat

面向百度编程

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

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

诀窍是，当配置正确时，Apache 为HTML页面服务，而Tomcat 实际上运行JSP 页面和Servlet。Tomcat最新版本为10.0.5**。**

工作3-5年，可以尝试手写tomcat服务器

下载tomcat

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8XBy4fDI-1642506947468)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211124152511768.png)]

jdk下的jre存放着jar包，其中rt.jar是java中最核心的jar包

3.1tomcat启动

• tomcat目录结构
• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hqtpGSKY-1642506947468)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211124153454663.png)]

启动，关闭tomcat

3.3、配置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nDUQMjTZ-1642506947469)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211124155450740.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CPqU3sxf-1642506947469)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211124155807392.png)]

可以通过这个文件配置：1. 启动的端口号（8080）

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ncsdJ9iU-1642506947470)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211124155552669.png)]

2.主机的名称（localhost）

• 默认的主机名为：localhost-》127.0.0.1
• 默认网站存放位置：webapps

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G04uzMNX-1642506947470)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211124155600390.png)]

3.INDEX.jsp里面可以更改页面显示的内容

高难度面试题：

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

1. 输入一个域名；回车

2. 检查本机的 C:\Windows\System32\drivers\etc\hosts配置文件下有没有这个域名的映射；

   1. 有：直接返回对应的ip地址

      127.0.0.1  		www.yaohai.com
      

   2. 没有：去dns服务器（全世界的域名都在这里面管理），找到就返回，找不到就g

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-i7oejOyX-1642506947470)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211124161736488.png)]

4.可以配置环境变量（可选性）

3.4、发布一个web网站

不会就先模仿

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

网站应该有的结构

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

HTTP协议：面试

maven：构建工具

• maven安装包

servlet 入门

• hellowrold！
• servlet配置
• 原理

4.http

4.1.什么是http

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

• 文本：html，字符串，-…
• 超文本：图片，音乐，视频，定位，地图…
• 80端口

HTTPS：安全的

• 443

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					状态码：
Remote Address: 182.61.200.7: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
Host: www.baidu.com

1、请求行[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ePnznVEC-1642506947470)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211124171046773.png)]

• 请求行中的请求方式：GET
• 请求方式：Get，Post，head，delete，put，tract
  • get：请求能够携带的参数比较少，大小有限制，会在浏览器url地址栏显示数据，但是高效
  • post：请求能够携带的参数没有限制，大小没有限制，不会在浏览器url地址栏显示数据，安全，但是不高效。

2.消息头

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

4.4、HTTP响应

服务器–响应–客户端

百度：

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

1.响应体

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

2.响应状态码

200：请求响应成功

3xx：请求重定向

• 重定向：

4xx：找不到资源 404

• 资源不存在

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

常见面试题

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

5、Maven

我为什么要学习这个技术？

1.在javaweb开发中，需要使用大量的jar包 ，我们手动去导入：

2.如何能够让一个东西自动给帮我导入和配置这个jar包

由此，maven诞生

5.1 maven 项目架构管理工具

我们目前用来就是方便导入jar包

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

• 有约束，不要违反

maven会规定好你该如何去编写我们的Java代码，必须要按照这个规范来：（ 目录规范）

5.2、配置环境变量

系统变量创建两个目录变量：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EeDHooR3-1642506947471)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211126010633558.png)]

之后再path中设置路径：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vFuCc9ea-1642506947471)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211126010653240.png)]

或者%MAVEN_HOME%\bin

5.3、阿里云镜像

在apache-maven配置文件中。conf目录下的settings.xml中添加

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

下载jar包可以节省很多时间。

5.4、本地仓库

在本地的仓库，远程仓库；

建立一个本地仓库（localRepository）。

<!-- localRepository
   | The path to the local repository maven will use to store artifacts.
   |
   | Default: ${user.home}/.m2/repository
  <localRepository>/path/to/local/repo</localRepository>
  -->
//可以自己指定一个地址，用来存放下载过的jar包，以方便以后使用

5.6、在idea中使用maven

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qxHXgITh-1642506947471)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211126012927896.png)]

5.7、创建一个普通的maven项目

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2y8nN3fL-1642506947472)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211126013049732.png)]

不点create 。。。 模板生成

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AE0tBm0O-1642506947472)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211126013150949.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bpt1AuIp-1642506947472)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211126013416103.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O4TvZsYb-1642506947472)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211126013602704.png)]

普通的maven创建不会生成模板

5.8、标记文件夹功能

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3trFiOYY-1642506947473)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211126013709740.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-06747ju3-1642506947473)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211126013942923.png)]

约束，每个目录有每个目录的作用

5.9、在maven项目中配置tomcat

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-I6jv3le3-1642506947473)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211126014247211.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nKsg3G7x-1642506947473)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211126014306437.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jMwVwYHB-1642506947474)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211126014451461.png)]

解决一下artifact警告问题

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vLMPmAH1-1642506947474)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211126014627044.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uIJpHqiI-1642506947474)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211126015002806.png)]

点击运行tomcat

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qlQ5Vv2W-1642506947474)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211126015144446.png)]

5.10、pom.xml文件

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XbakvkFf-1642506947475)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211126015430410.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pWjY0VnN-1642506947475)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211126020827136.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vAdHGeql-1642506947475)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211126021216794.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C9yGdF27-1642506947475)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211126022601754.png)]

maven由于它的约定大于配置，我们之后可能会遇到我们写的配置文件，无法被导出或者生效的问题，解决方案：

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

5.11、结构树[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LY9rd1TV-1642506947476)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211126022347471.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0xOyCbFo-1642506947476)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211126022336608.png)]

jar包的结构体系

5.12、每次进入idea都要重新配置maven

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TL6t22yd-1642506947476)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211127145443546.png)]

这样就可以解决

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vbLpnEEi-1642506947476)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211127150959880.png)]

6.Servlet

6.1、servlet简介

• servlet就是sun公司开发动态的web的一种技术
• sun在这些api中提供了一个接口：servlet，如果你想开发一个servlet程序，只需要完成两个小步骤：
  • 编写一个类，实现servlet接口
  • 把开发好的Java类部署到web服务器中。

把实现的servlet接口的程序叫做，servlet

6.2、HelloServlet

Servlet接口在Sun公司有两个默认的实现类:HttpServlet, GenericServlet

1.构建一个普通maven项目，删除里面的src目录，以后我们的学习就在这个项目里面建立moudle；这个空的工程就是maven的主工程

2.关于maven父子工程的理解：

父项目中会有一个moudol

 <modules>
        <module>maven_01</module>
    </modules>

子项目中会有：

<parent>
        <artifactId>pt_maven</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>

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

son extens father

3.maven环境优化

​ 1.修改web.xml为最新的

​ 2.将maven的结构构建完整

4.编写一个servlet程序

1. 编写一个普通类
2. 实现servlet接口，这里我们直接继承Httpservlet

package com.yao.servlet;

import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

public class HelloServlet extends HttpServlet {
    //因为doget和dopost都是一种请求方式，可以互相调用，业务逻辑都一样

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

        //ServletOutputStream stream= resp.getOutputStream();
        PrintWriter writer = resp.getWriter();
        writer.println("hello world");
    }

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

5.编写servlet映射

为什么需要映射：因为我们写的是java程序，但是要通过浏览器访问，而浏览器需要连接web服务器，所以我们需要web服务中注册我们写的servlet，还需要给他一个浏览器访问的路径

6.配置tomcat

​ 注意：配置项目发布的路径就可以了

7.启动测试，ok！！

6.3、servlet原理

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-25DXAwml-1642506947477)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211205234903354.png)]

6.4、mapping问题

1. 一个servlet可以指定一个映射路径
2. 一个servlet可以指定多个映射路径
3. 一个servlet可以指定通用的映射路径
4. 指定一些前缀或则后缀

<!--可以自定义后缀实现请求映射-->
<servlet-mapping>
    <servlet-name>Hello</servlet-name>
    <url-pattern>*.sasad</url-pattern>
  </servlet-mapping>

5. 默认请求路径

万能
<servlet-mapping>
    <servlet-name>Hello</servlet-name>
    <url-pattern>/*</url-pattern>
  </servlet-mapping>

6. 优先级问题

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

6.5、servletcontext

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

1、共享数据

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

import javax.naming.Context;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.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() servlet配置
        //this.getServletContext() servlet上下文  返回的是一个对象!servlet Context


        ServletContext context = this.getServletContext();
        String username = "姚海";//数据
        context.setAttribute("username",username);



    }
}

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.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.setCharacterEncoding("utf-8");
        resp.setContentType("text/html");
        resp.getWriter().print("名字"+username);
    }
}

 <!--注册servlet-->
  <servlet>
    <servlet-name>Hello</servlet-name>
    <servlet-class>HelloServlet</servlet-class>

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

  <servlet>
    <servlet-name>get</servlet-name>
    <servlet-class>Getservlet</servlet-class>

  </servlet>
  <servlet-mapping>
    <servlet-name>get</servlet-name>
    <url-pattern>/get01</url-pattern>
  </servlet-mapping>

测试访问结果

2.获取初始化参数

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

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class ServletDemo01 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);
    }
}

3.请求转发

请求转发url路径不会发生改变

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        RequestDispatcher requestDispatcher = context.getRequestDispatcher("/sd1");
        requestDispatcher.forward(req,resp);
    }

4.读取资源文件

Properties类

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

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

思路：需要一个文件流

public class ServletDemo03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        InputStream io = this.getServletContext().getResourceAsStream("/WEB-INF/classes/db.properties");
        Properties properties = new Properties();
        properties.load(io);
        String user =properties.getProperty("username");
        String psd =properties.getProperty("password");
        resp.getWriter().print(user+":"+psd);
    }
}

6.6、HttpServletResponse

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

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

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;

2.常见应用

1. 向浏览器输出消息
2. 下载文件
   1. 要获取下载文件的路径
   2. 下载的文件名
   3. 设置想办法让浏览器能够支持下载我们需要的东西
   4. 获取下载文件的输入流
   5. 创建缓冲区
   6. 获取OutputStream对象
   7. 将FileOutStream流写入buffer缓冲区
   8. 使用OutputStream将缓冲区的数据输出到客户端、
3. 下载文件的实现过程

import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.URLEncoder;

public class FileServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//        1. 要获取下载文件的路径
        String realPath ="D:\\untitled\\maven-01\\pt_maven\\maven_03\\target\\classes\\1.png";
        System.out.println("下载的文件路径"+realPath);
//        2. 下载的文件名
        String filename = realPath.substring(realPath.lastIndexOf("\\")+1);
//        3. 设置想办法让浏览器能够支持下载我们需要的东西
        resp.setHeader("Content-disposition","attachment;filename="+ URLEncoder.encode(filename));
//        4. 获取下载文件的输入流
        FileInputStream in = new FileInputStream(realPath);
//        5. 创建缓冲区
        int len =0;
        byte[] buffer = new byte[1024];
//        6. 获取OutputStream对象
        ServletOutputStream out=resp.getOutputStream();
//        7. 将FileOutStream流写入buffer缓冲区,使用OutputStream将缓冲区的数据输出到客户端、
        while ((len=in.read(buffer))>0){
            out.write(buffer,0,len);
        }
        in.close();
        out.close();

    }
}

3.response验证码实现

验证怎么来的

• 前端实现
• 后端实现，需要用到java的图片类，生产一个图片
• 验证码代码

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;

public class ImageServlet extends HttpServlet {
    @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.white);
        g.fillRect(0,0,80,20);
        //给图片写数据
        g.setColor(Color.BLUE);
        g.setFont(new Font(null,Font.BOLD,20));
        g.drawString(makeNum(),0,20);

        //告诉浏览器，这个请求用图片的方式打开
        resp.setContentType("image/jpeg");
        //网站存在缓存，不让浏览器缓存
        resp.setDateHeader("expires",-1);
        resp.setHeader("Cache-Control","no-cache");
        resp.setHeader("pragme","no-cache");

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

    //生成随机数
    private String makeNum(){
        Random rd = new Random();
        String s = rd.nextInt(9999999) + "";
        StringBuffer sb=new StringBuffer();
        for(int i=0;i<7-s.length();i++){
            sb.append("0");
        }
        s = sb.toString() + s;
        return s;
    }

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

4.（重点）实现重定向

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GQjsJXI5-1642506947477)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211207163101711.png)]

常见场景：

• 用户登录

  ​ void sendRedirect(String var1) throws IOException;

• 测试：

  protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
          /*
          resp.setHead("Location","/r/img");
          resp.setStatus(302);
          * */
  
  
          resp.sendRedirect("/maven_03_war/image");
  
      }
  
  

  面试题：请你聊聊重定向和转发的区别？

  相同点

• 页面都会跳转

不同点

• 请求转发的时候，url地址不会发生改变
• 重定向的时候，url地址会产生变化

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class RequestText extends HttpServlet {
    @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);
        resp.sendRedirect("/r/success.jsp");
    }

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

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<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>

<%--
  Created by IntelliJ IDEA.
  User: 宁智波带土
  Date: 2021/12/7
  Time: 17:05
  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>success</h1>
</body>
</html>

6.7、HttpServletRequest

HttpServletRequest代表客户端请求，用户通过Http协议访问服务器，http请求中的所有信息会被封装到HttpServletRequest

通过这个HttpServletRequest的方法，获得客户端的所有信息

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uDa8iKvM-1642506947477)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211207171452293.png)]

1、获取前端传递的参数,请求转发

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xKV94Sr0-1642506947478)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211207171941420.png)]

​ request.getParameter()

​ requsst.getParameterValues()

public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");

        String username = req.getParameter("username");
        String password = req.getParameter("password");
        String[] hobbys = req.getParameterValues("hobbys");
        System.out.println("=====================");
        System.out.println(username);
        System.out.println(password);
        System.out.println(Arrays.toString(hobbys));
        System.out.println("=====================");
        System.out.println(req.getContextPath());
        //通过请求转发
        //这里的 /代表当前的web应用
        req.getRequestDispatcher("/success.jsp").forward(req,resp);

    }

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

面试题：请你聊聊请求和转发的区别

相同点

• 页面都会实现跳转

不同点

• 请求转发的时候，url地址不会发生改变
• 重定向的时候，url地址不会产生变化

Session

Cooike

JSP --》前端知识！！ HTML + JS

过滤器

三层架构

7.Cookie、Session

7.1、会话

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

会话（Session）跟踪是Web程序中常用的技术，用来跟踪用户的整个会话。常用的会话跟踪技术是Cookie与Session。Cookie通过在客户端记录信息确定用户身份，Session通过在服务器端记录信息确定用户身份。

有状态会话

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

客户端 服务端

1.服务端给客户端一个 信件，客户下次访问服务器带上信件就可以了；cookie

2.服务器登记你来过了，下次你来我匹配你；session

7.2、保存会话的两种数据.

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-evfb7UnT-1642506947478)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211208153709281.png)]

cookie：

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

session：

• 服务器技术，利用这个技术，可以保存用户的会话信息？我们可以把信息或者数据保存在session中！！

​ 常见：网站登录之后，下次进入不需要再登陆

7.3、Cookie

Cookie机制是通过检查客户身上的“通行证”来确定客户身份的话，那么Session机制就是通过检查服务器上的“客户明细表”来确认客户身份。Session相当于程序在服务器上建立的一份客户档案，客户来访的时候只需要查询客户档案表就可以了。

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

Cookie[] cookies = req.getCookies();//这里返回数组，说明cookie可能存在多个   获取cookie
ccokie.getName();//获得cookie中的key
cookie.getValue();//获取cookie中的value
new Cookie("lastLoginTime",System.currentTimeMillis()+"");  //创建一个cookie
resp.addCookie(cookie);//相应一个cookie
cookie.setMaxAge(24*60*60);//设置cookie的有效期

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

一个网站的cookie是否存在上限

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

删除cookie:

• 不设置有效期
• 设置有效期为0

编码解码：

编码方式:

Cookie cookie = new Cookie("name", URLEncoder.encode("yaohai","utf-8"));

解码方式：

pw.write(URLDecoder.decode(cookie.getValue(),"utf-8"));

7.4、Session（重点）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0By6Yi8P-1642506947478)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211208153647102.png)]

什么是session:（会话）

• 服务器会给每一个用户（浏览器）创建一个session对象
• Session是服务器端使用的一种记录客户端状态的机制
• 一个Session独占一个浏览器，只要浏览器没有关闭，这个session就存在
• 用户登录之后，整个网站都可以访问！–》》保存用户的信息；保存购物车的信息

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2gi1bZXW-1642506947478)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211208151637135.png)]

Session和Cookie的区别：

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

使用场景：

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

使用session

package com.yao.cookie;

import com.yao.pojo.Person;

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

public class SessionDemo01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //解决中文乱码
        req.setCharacterEncoding("UTF-8");
        resp.setContentType("text/html;charset=utf-8");


        //得到session
        HttpSession session = req.getSession();
        //给session中存东西
        session.setAttribute("name",new Person("姚海",41));
        //获取session的id
        String id = session.getId();
        //判断session是不是新创建
        if(session.isNew()){
            resp.getWriter().write("session创建成功"+id);
        }else {
            resp.getWriter().write("session已经存在"+id);
        }
        //session创建的时候为什么会出现cookie？？？
        //session创建的时候做了什么事情
//        Cookie cookie=new Cookie("JESSIONID",id);
//        resp.addCookie(cookie);
    }
}

得到session

package com.yao.cookie;

import com.yao.pojo.Person;

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

public class SessionDemo02 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //解决中文乱码
        req.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);

    }
}

清除session

package com.yao.cookie;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

public class SessionDemo03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        HttpSession session = req.getSession();
        session.removeAttribute("name");
        //手动注销Session
        session.invalidate();
    }
}

类person

package com.yao.pojo;

public class Person {
    private String name;
    private int age;
    public Person(){

    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

会话自动过期：web.xml中配置

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

8.JSP

8.1、什么是JSP

Java Servlet Pages: Java服务器端页面，也和servlet一样，用于动态web技术！！

最大的特点：

• 写jsp就像在写html
• 区别：
  • HTML只给用户提供静态的数据
  • jsp页面可以嵌入Java代码，为用户提供动态数据;

8.2、jsp原理

思路：jsp到底是怎么执行的呢

• 代码层面没有任何问题

• 服务器内部工作

  tomcat中有一个work目录；

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

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Eh4wNs48-1642506947479)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211208162508498.png)]

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tQGPioKx-1642506947479)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211209154240656.png)]

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

访问jsp页面web容器会进行转化，将他转化成java文件，编译成class传给web容器返回给用户，所以本质就是servlet

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

JSP本质就是一个servlet

jsp继承了httpservlet

//初始化
public void _jspInit() {
  }
//销毁
  public void _jspDestroy() {
  }
//JSPService
  public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.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当前页
   	HttpServletRequest request							//请求
       HttpServletResponse response						//响应
   

3. 输出页面前增加的代码

   response.setContentType("text/html;charset=ISO-8859-1");//设置响应的页面类型
         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;
   

4. 以上的这些对象我们可以在jsp页面中直接使用！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U67l2f4Q-1642506947479)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211209161243935.png)]

在JSP页面中；

只要是JAVA代码就会原封不动的输出；

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

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

这样的格式，渲染到前端

8.3、jsp基础语法

任何语言都有自己的语法，Java中有。jsp作为java技术的一种应用，它拥有自己扩充的语法(了解，知道即可)，java所有语法都支持

JSP表达式

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

jsp脚本片段

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

%>

<%--在代码块嵌入HTml元素--%>
<%--${i}是EL表达式的一种写法--%>
<%
for(int i=0;i<5;i++){
   <% 
	<h1>hello,world<%=i%> ${i}

</h1>
%>
}
%>

jsp声明

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

jsp声明：会被编译到jsp生成java的类中！其他的，就会被生成到jsp的规范中，进入_jspService方法中!!作用域的不同

在jsp中，嵌入Java代码即可！！

<%%>
<%=%>
    <%!%>
    
    <%--注释--%>
    <!--html注释-->

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

8.4、JSP指令

<%@ page args....%>
<%--定制错误页面,跳转到--%>
<%--<%@ page errorPage="index.jsp" %>--%>
<%--显示声明这是一个错误页面--%>
<%--<%@ page isErrorPage="false" %>--%>

<%--将别的jsp页面嵌入到当前jsp页面--%>
<%@ incluede file="common/header.jsp"%>
<h1>网页主题</h1>
<%@ incluede file="common/forter.jsp"%>

<%--jsp标签--%>
<jsp:include page="/common/header.jsp"/>
<h1>网页主题</h1>
<jsp:include page="/common/forter.jsp"/>

<%--这两个区别是不使用jsp标签实际上成为一个页面，而jsp始终是三个页面--%>

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

8.5、9大内置对象

• PageContext 存东西
• Request 存东西
• response
• Session 存东西
• Application [ServletContext] 存东西
• config [servletconfig] 配置一些东西
• out
• page
• exception

 	//请求排序的顺序
    pageContext.setAttribute("name", "fas");//保存的数据只在一个页面中有效
    request.setAttribute("name1", "value");//保存的数据只在一次请求中有效，请求转发会携带这个数据，即完成一个完整的请求转发过程才有效；
    session.setAttribute("name2", "value");//保存的数据只在一次会话中有效，从打开浏览器到关闭浏览器
    application.setAttribute("name3", "value");//保存的数据在服务器中有效，从打开服务器到关闭服务器

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

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

application：客户端向服务器发送请求，产生的数据，一个用户用完了，其他用户还可能用，比如：聊天数据

• 顺序测试

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

<html>
<%--定制错误页面,跳转到--%>
<%--<%@ page errorPage="index.jsp" %>--%>
<%--显示声明这是一个错误页面--%>
<%--<%@ page isErrorPage="false" %>--%>
<head>
    <title>Title</title>
</head>
<body>
<%--内置对象--%>

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

<%--脚本片段中的代码，会被原封不动的生成到.jsp.java
要求？：这里面的代码要符合java代码的规>范性
--%>
<%
    //从pagecontext取出，我们通过寻找的方式
    //从底层到高层    page-->request-->session-->application
    String name = (String) pageContext.findAttribute("name");
    String name1 = (String) pageContext.findAttribute("name1");
    String name2 = (String) pageContext.findAttribute("name2");
    String name3 = (String) pageContext.findAttribute("name3");
    pageContext.forward("/pagecontextDemo02.jsp");
%>
<%--使用el表达式，输出--%>
<h1>取出的为：</h1>
<h1>${name}</h1>
<h1>${name1}</h1>
<h1>${name2}</h1>
<h1>${name3}</h1>
</body>
</html>

    
    
    
    
    
    
    
    
    
    <%--
  Created by IntelliJ IDEA.
  User: 宁智波带土
  Date: 2021/12/11
  Time: 20:50
  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>
  <%
    //从pagecontext取出，我们通过寻找的方式
    //从底层到高层    page-->request-->session-->application
    String name = (String) pageContext.findAttribute("name");
    String name1 = (String) pageContext.findAttribute("name1");
    String name2 = (String) pageContext.findAttribute("name2");
    String name3 = (String) pageContext.findAttribute("name3");


  %>
  <%--使用el表达式，输出--%>
  <h1>取出的为：</h1>
  <h1>${name}</h1>
  <h1>${name1}</h1>
  <h1>${name2}</h1>
  <h1>${name3}</h1>
  </body>
</html>

8.6、jsp标签、JSTL标签、EL表达式

引入jar包

EL表达式：${}

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

JSP标签

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
<%--<jsp:include page=""></jsp:include>--%>
  <jsp:forward page="/jsplable1.jsp">
    <jsp:param name="name" value="123"/>
    <jsp:param name="age" value="456"/>
  </jsp:forward>
  </body>
</html>

JSTL表达式

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

引入jstl核心标签库，我们才能使用jstl标签 ，c代表core

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

核心标签（掌握部分）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cLQmKAy4-1642506947480)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211211223141381.png)]

格式化标签

sql标签

xml标签

• 标签使用方法，c：out c：if

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
  <head>
    <title>if测试</title>
  </head>
  <body>
<form action="/Jstl01.jsp" method="get">
  <%--
  EL表达式获取表单中的数据
  ${parme.参数名}
  --%>
  <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:out>
</c:if>
<c:out value="${isAdmin}"></c:out>
  </body>
</html>

• c:set

  <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
  
  <%--
    Created by IntelliJ IDEA.
    User: 宁智波带土
    Date: 2021/12/11
    Time: 23:07
    To change this template use File | Settings | File Templates.
  --%>
  <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  <html>
  <head>
      <title>set测试</title>
  </head>
  <body>
  <c:set var="score" value="55"></c:set>
  <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>
  </html>
  
  

• c:foreach

  <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
  <%@ page import="java.util.ArrayList" %><%--
    Created by IntelliJ IDEA.
    User: 宁智波带土
    Date: 2021/12/11
    Time: 23:14
    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>
  <%
      ArrayList<String> people = new ArrayList<>();
      people.add(0,"张三");
      people.add(1,"李四");
      people.add(2,"王五");
      people.add(3,"田七");
      request.setAttribute("list",people);
  %>
  <%--
  var  ,每一次遍历出来的变量
  items，要遍历的对象
  begin  哪里开始
  end  到哪里
  step  步长
  
  
  
  --%>
  <c:forEach var="people" items="${list}">
      <c:out value="${people}"></c:out>
  </c:forEach>
  
  <c:forEach var="people" items="${list}" begin="1" end="3" step="2">
      <c:out value="${people}"></c:out>
  </c:forEach>
  </body>
  </html>
  
  

9.JavaBean

实体类

javabean有特定的写法:

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

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

ORM:对象关系映射

• 表–》类
• 字段–》属性
• 行记录–》类的对象

people表

id	name	age	address
1	要害	3	西安
2	蛤科	5	西安
3	瑶海	6	西安

class people(){
    private int id;
     private string name;
    private int age;
    private String address;
    
}


class a{
    new people(1,"要害",3,"西安");
    new people(2,"要害",3,"西安");
    new people(3,"要害",3,"西安");
}

<%@ page import="com.yao.pojo.Person" %><%--
  Created by IntelliJ IDEA.
  User: 宁智波带土
  Date: 2021/12/12
  Time: 10:57
  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>
<%
    /*Person person =new Person();
    person.setAge();
    person.setName();
    等价于下面的代码
    */
%>
<jsp:useBean id="people" class="com.yao.pojo.people" scope="page">
</jsp:useBean>
<jsp:setProperty name="people" property="id" value="1"></jsp:setProperty>
<jsp:setProperty name="people" property="name" value="要害"></jsp:setProperty>
<jsp:setProperty name="people" property="age" value="3"></jsp:setProperty>
<jsp:getProperty name="people" property="id"/>
<jsp:getProperty name="people" property="name"/>
<jsp:getProperty name="people" property="age"/>
</body>
</html>

• 过滤器
• 文件上传
• 邮件发送
• JDBC复习

10、MVC三层架构

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

10.1、早些年

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5uMAy1Uh-1642506947480)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211212145859691.png)]

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

servlet--CRUD-->数据库里面的对象
弊端：crud的代码也要写到servlet里面，十分臃肿，不利于维护；
servlet的代码中：处理请求、响应、视图跳转、处理jdbc、处理业务代码、处理逻辑代码
    
架构：没有什么是加一层解决不了的
程序员调用
    
JDBC
    
MYSQL Oracle SqlServer ...

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9fi7SqRe-1642506947480)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211212162808255.png)]

Moudel:

• 业务处理：业务逻辑（service）
• 数据持久层：CRUD

View

• 展示数据
• 提供链接发起servlet请求(a ，form ， img…)

Controller:(Servlet)

• 接收用户的请求(req:请求参数、Session信息…)

• 交给业务层对应的代码

• 控制视图的跳转

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

11、Filter（过滤器）

Filter：过滤器，用来过滤网站信息

• 处理中文乱码
• 登录验证

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZXIAPyOR-1642506947480)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211212162939926.png)]

Filter开发步骤：

1. 导包
2. 编写过滤器

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

package com.yao.Filter;

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

public class CharacterEncodingFilter implements Filter {
    //初始化：wer服务器启动，就可以初始化了，随时等待过滤器对象出现
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("初始化");
    }

    //chain:链
    /*
    * 1.过滤中的所有代码，在过滤特定请求的时候都会执行
    * 2.必须要让过滤器继续执行
    * filterChain.doFilter(servletRequest,servletResponse);
    * */
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        servletRequest.setCharacterEncoding("utf-8");
        servletResponse.setCharacterEncoding("utf-8");
        servletResponse.setContentType("text/html;charset=UTF-8");
        System.out.println("执行前");
        filterChain.doFilter(servletRequest,servletResponse);
        System.out.println("执行后");
    }

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



//这是实体类
public class text extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("中文可以吗");
    }
}

3.在web.xml中配置filter

  <filter>
    <filter-name>filter</filter-name>
    <filter-class>com.yao.Filter.CharacterEncodingFilter</filter-class>
  </filter>


  <filter-mapping>

    <filter-name>filter</filter-name>
<!--只要是/text的任何请求，都会经过这个过滤器-->
    <url-pattern>/text/*</url-pattern>
  </filter-mapping>

12.Listener(监听器)(重点)

实现一个监听器的接口：（有N种方法）

1. 编写一个监听器…

package com.yao.listener;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

//统计网站在线人数：统计session
public class OnlineCountListener implements HttpSessionListener {
    //创建session的监听：看你的一举一动
    //一旦创建session就出触发一举一动这个事件！！

    @Override
    public void sessionCreated(HttpSessionEvent se) {

        ServletContext ctx = se.getSession().getServletContext();
        Integer count = (Integer) ctx.getAttribute("count");
        if(count==null){
            count = new Integer("1");
        }else {
            int cc = count.intValue();
            count =new Integer(count+1);

        }
        ctx.setAttribute("count",count);

    }
    //销毁session的监听：看你的一举一动
    //一旦销毁session就出触发一举一动这个事件！！
    @Override
    public void sessionDestroyed(HttpSessionEvent se) {
        ServletContext ctx = se.getSession().getServletContext();
        Integer count = (Integer) ctx.getAttribute("count");
        if(count==null){
            count = new Integer(0);
        }else {
            int cc = count.intValue();
            count =new Integer(count-1);

        }
        ctx.setAttribute("count",count);
    }
    /*
    Session销毁
    1.手动销毁：  getsession().invalidate();
    2.自动销毁
    */
}

2. web.xml注册监听器

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

3. 看情况是否使用

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

监听器：GUI编程中经常使用（图形界面编程）

package com.yao.listener;

import java.awt.*;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

public class Textlistener {
    public static void main(String[] args) {
        Frame frame=new Frame("中秋节快乐！");//新建一个窗体
        Panel p =new Panel(null);//面板
        frame.setLayout(null);

        frame.setBounds(300,300,500,500);
        frame.setBackground(new Color(0,0,255));//设置背景色

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

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

        //监听关闭时间
        frame.addWindowListener(new WindowListener() {
            @Override
            public void windowOpened(WindowEvent e) {
                System.out.println("打开");
            }

            @Override
            public void windowClosing(WindowEvent e) {
                System.out.println("关闭ing");
                System.exit(0);//0和1 1为非正常关闭
            }

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

            @Override
            public void windowIconified(WindowEvent e) {
                System.out.println("打开");
            }

            @Override
            public void windowDeiconified(WindowEvent e) {

            }

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

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

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

1. 用户登录之后，向session中放入用户的数据

2. 进入主页的时候要判断是否已经登录；要求：在过滤器中实现！

   public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
           //servletrequest    httpservletrequest
           HttpServletRequest request =(HttpServletRequest)servletRequest;
           HttpServletResponse response =(HttpServletResponse) servletResponse;
           Object user_session=request.getSession().getAttribute("USER_SESSION");
           if(user_session==null){
               response.sendRedirect("/login.jsp");
           }else {
               response.sendRedirect("/login.jsp");
           }
       filterChain.doFilter(request,response);
       
       }
   

14.JDBC

什么是jdbc：Java连接数据库

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xrgTUhHo-1642506947481)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211213010701589.png)]

需要的jar包支持：

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

实现环境搭建：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hEn5crM3-1642506947481)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20211213180836807.png)]

导入数据库依赖：

<dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.47</version>
    </dependency>

JDBC固定步骤：

1.加载驱动

2.连接数据库

3.向数据库发送sql的对象Statement：CRUD

4.编写sql（根据业务，不同的sql）

5.执行SQL

6.关闭连接

import java.sql.*;

public class TestJdbc {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //配置信息
        String url  = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&charsetEncoding=utf-8";
        String username ="root";
        String password="root";
        //加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2.连接数据库,代表数据库
        Connection connection= DriverManager.getConnection(url,username,password);
        //3.向数据库发送SQL对象Statement :CRUD
        Statement statement = connection.createStatement();
        //4.编写sql
        String sql = "create dsadas";
        //执行查询sql  返回一个ResultSet  ：结果集
        ResultSet rs= statement.executeQuery(sql);
        while (rs.next()){
            System.out.println("id="+rs.getObject("id"));


        }
        //6.关闭连接
        statement.close();
        rs.close();
        connection.close();


    }
}

preparedStatement使用防止sql注入

import java.sql.*;

public class Testjdbc02 {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
//配置信息
        String url  = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&charsetEncoding=utf-8";
        String username ="root";
        String password="root";
        //加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2.连接数据库,代表数据库
        Connection connection= DriverManager.getConnection(url,username,password);
        //3.编写SQL
        String sql = "select from users";
        //4.预编译
        PreparedStatement statement = connection.prepareStatement(sql);
        //5.插入数据
        statement.setString(1,"sds");
        //6.关闭连接
        ResultSet resultSet = statement.executeQuery();
        while (resultSet.next()){
            System.out.println(resultSet.getObject("name"));
    }
        statement.close();

        connection.close();

    }

事务：

要么都成功要么都失败

ACID原则：保证数据安全

Junit单元测试

依赖

<!--单元测试-->
<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

简单使用

@Test注解只有在方法上有效，只要加了这个注解就可以直接使用

固定步骤：

1.加载驱动

2.连接数据库

3.向数据库发送sql的对象Statement：CRUD

4.编写sql（根据业务，不同的sql）

5.执行SQL

6.关闭连接

import java.sql.*;

public class TestJdbc {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //配置信息
        String url  = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&charsetEncoding=utf-8";
        String username ="root";
        String password="root";
        //加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2.连接数据库,代表数据库
        Connection connection= DriverManager.getConnection(url,username,password);
        //3.向数据库发送SQL对象Statement :CRUD
        Statement statement = connection.createStatement();
        //4.编写sql
        String sql = "create dsadas";
        //执行查询sql  返回一个ResultSet  ：结果集
        ResultSet rs= statement.executeQuery(sql);
        while (rs.next()){
            System.out.println("id="+rs.getObject("id"));


        }
        //6.关闭连接
        statement.close();
        rs.close();
        connection.close();


    }
}

preparedStatement使用防止sql注入

import java.sql.*;

public class Testjdbc02 {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
//配置信息
        String url  = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&charsetEncoding=utf-8";
        String username ="root";
        String password="root";
        //加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2.连接数据库,代表数据库
        Connection connection= DriverManager.getConnection(url,username,password);
        //3.编写SQL
        String sql = "select from users";
        //4.预编译
        PreparedStatement statement = connection.prepareStatement(sql);
        //5.插入数据
        statement.setString(1,"sds");
        //6.关闭连接
        ResultSet resultSet = statement.executeQuery();
        while (resultSet.next()){
            System.out.println(resultSet.getObject("name"));
    }
        statement.close();

        connection.close();

    }

事务：

要么都成功要么都失败

ACID原则：保证数据安全

Junit单元测试

依赖

<!--单元测试-->
<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

简单使用

@Test注解只有在方法上有效，只要加了这个注解就可以直接使用