JavaWeb

dddyyy_123

已于 2023-04-03 17:37:54 修改

阅读量679

点赞数

文章标签： java 前端 servlet

于 2023-03-24 18:10:04 首次发布

本文链接：https://blog.csdn.net/weixin_55376192/article/details/129756120

版权

JavaWeb

java Web

1、基本概念

1.1前言

web开发：

web,网页的意思，www。baidu.com
静态web
- html，css
- 提高給所有人看的数据始终不会发生变化
动态web
- 淘宝，几乎是所有的网站
- 提供给所有人看的数据始终会发生变化，每个人在不同的时间，不同的地点看到的信息各不相同
- 技术栈：Servert/JSP,ASP,PHP

在java中，动态web资源开发的技术统称为javaWeb

1.2web应用程序

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

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

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

1.3静态web

.htm,.html,这些都是网页的后缀，如果服务器上一直存在这些东西，我们就可以直接进行读取。通络。

静态web存在的缺点
- web页面无法动态更新，所有用户看到都是同一个页面
  - 轮播图，点击特效：伪动态
  - javaScript【实际开发中，它用的最多】
  - VBScript

它无法和数据库交互（数据无法持久化，用户无法交互）

1.4动态web

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

缺点：

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

优点：

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

2、web服务器

2.1技术讲解

ASP:

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

php

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

JSP/Servlet:

B/S:浏览器和服务器

C/S:客户端和服务器

sun公司主推的B/S架构
基于java语言的（所有的大公司，或者一些开源的组件，都是用java写的）
可以承载三高问题带来的影响
语法ASP,ASP–>JSP,加强市场强度

2.2web服务器

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

IIS

微软的;ASP…,Windws中自带的

Tomcat

面向百度编程

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

Tomcat 服务器是一个免费的开放源代码的Web 应用服务器，属于轻量级应用服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP 程序的首选。对于一个初学者来说，可以这样认为，当在一台机器上配置好Apache 服务器，可利用它响应HTML（标准通用标记语言下的一个应用）页面的访问请求。实际上Tomcat是Apache 服务器的扩展，但运行时它是独立运行的，所以当你运行tomcat 时，它实际上作为一个与Apache 独立的进程单独运行的。

诀窍是，当配置正确时，Apache 为HTML页面服务，而Tomcat 实际上运行JSP 页面和Servlet。另外，Tomcat和IIS等Web服务器一样，具有处理HTML页面的功能，另外它还是一个Servlet和JSP容器，独立的Servlet容器是Tomcat的默认模式。不过，Tomcat处理静态HTML的能力不如Apache服务器。Tomcat最新版本为10.0.23**。**

下载tomcat:

1.安装 or 解压

2.了解配置文件及目录结构

3.这个东西的作用

3、Tomcat

3.1安装Tomcat

3.2Tomcat启动配置

启动，关闭Tomcat

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

可能问题：

1.java环境变量没有配置

2、闪退问题；需要配置兼容性

3、乱码问题：配置文件中设置

3.3配置

可以配置主机启动的端口号

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

可以配置主机的名称

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

host

高难度面试题：

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

1、输入一个域名；回车

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

有：直接返回对应的ip地址，这个地址中，有我们需要访问的web程序，可以直接访问
```
127.0.0.1 www.baidu.com
```
没有：去DNS服务器找，找到的话就返回，找不到就返回找不到；

3.可以配置一下环境变量（可选性）

发布一个web网站

不会就先模仿

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

网站应该有的结构

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

4、http

4.1什么是HTTP

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

http（超文本传输协议）是一个简单的请求响应协议，它通常运行在TCP之上
文本，html，字符串，~…
超文本：图片，音乐，视频，定位，地图…
80

https：安全的

4.2两个时代

http1.0
- HTTP/1.0：客户端可以与web服务端连接后，只能获得一个web资源，断开连接
http2.0
- HTTP/1.1: 客户端可以与web服务器连接后，可以获得多个web资源

4.3http请求

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

百度：

Request URL: https://www.baidu.com/ 请求地址
Request Method: GET  get方法/post方法
Status Code: 200 OK  状态码：200
Remote Address: 110.242.68.3:443
Referrer Policy: strict-origin-when-cross-origin

Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9  语言
Cache-Control: max-age=0
Connection: keep-alive

1、请求行

请求行中的请求方式：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:主机

4.4http响应

服务器-响应–客户端

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

X-Ua-Compatible: IE=Edge,chrome=1

1.响应体

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

2.响应状态码

200 ：请求响应成功

3**:请求重定向

重定向：你重新到我给你新位置去；

404：找不到资源

资源不存在；

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

常见面试问题：

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

5.Maven

为什么要学习这个技术?

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

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

由此，Maven诞生了

5.1Maven项目架构管理工具

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

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

有约束，不要去违反

Maven会规定好你该如何去编写我们的java代码，必须要按照这个规范来；

5.2下载安装Maven

https://maven.apache.org/download.cgi

5.3配置环境变量

在我们的系统环境变量中

配置如下配置：

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

5.4阿里云镜像

镜像：mirrors
- 作用：加速：加速我们的下载
国内建议使用阿里云的镜像

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

5.5本地仓库

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

建立一个仓库：localRepository

5.6在idea中使用Maven

1.启动IDEA

2.创建一个Maven项目

3.等待系统下载

4.查看maven路径

5.7创建一个普通的maven

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VgXWUyAJ-1679652463071)(JavaWeb.assets/0A3BC029846A077FB53C51AB3756EC5C.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NFgOAT4t-1679652463072)(JavaWeb.assets/0BE136063E75E9C3F06A38B4FBFC44DD-1677922394374.png)]

这个只有在web应用才会有

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TsUfqvce-1679652463074)(JavaWeb.assets/F16ADD1AFFE792EE5CD1A2B486CFB35C.png)]

5.8标记文件夹功能

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IK5bW6YO-1679652463078)(JavaWeb.assets/24CC52D471C2931B77F9B0EE06C242EE-1677923605933.png)]

5.9在idea中配置Tomcat

解决警告问题

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

假如写了一个/dai,localhost:8080/kuang 这个过程叫虚拟路径映射

5.10 porn文件

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

<?xml version="1.0" encoding="UTF-8"?>
<!--Maven 版本和头文件-->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
<!--这里就是我们刚才配置的GAV-->
  <groupId>com.dai</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包配置文件-->
    <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由于他的约定大于配置，我们之后可以能遇到我们写的配置文件，无法被导出或者生效的问题，解决方案

5.12IDEA操作

5.13解决遇到的问题

1.Maven 3.6.2

减低版本

2.Tomcat问题

3.IDEA中每次都要重复配置Maven

在IDEA中的全局默认配置中去配置

4.Maven项目中Tomcat无法配置

5.maven默认web项目中的web.xml版本问题

6.替换为webapp4.0版本和Tomcat一致

7.MAVEN仓库的使用

6.Servlet

6.1servlet简介

Sevlet就是sun公司开发动态web的一门技术
Sun在这些API提供一个接口叫做：Servlet，如果你想开发一个Servlet程序，只需要完成两个小步骤：
- 编写一个类，实现Servlet接口
- 把开发好的java类部署到web服务器中

把实现了Serlet接口java程序叫做，Servlet

6.2HelloServlet

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

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

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

父项目中会有

<modules>
     <module>serlet-01</module>
</modules>

子项目会有

<parent>
<groupId>com.dai</groupId>
  <artifactId>servlet-01</artifactId>
  <version>1.0-SNAPSHOT</version>
  </parent>

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

son extends father

3.Maven环境优化

1.修改web.xml为最新的

2.将maven的结构搭建完整

4.编写一个Servlet程序

1.编写一个普通类

2.实现SerVlet接口，这里我们直接继承HttpServlet

package com.dai.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 {
    //由于get或者post只是请求实现的不同的方式，可以相互调用，业务逻辑都一样
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
      //  ServletOutputStream outputStream = resp.getOutputStream();
     PrintWriter writer = resp.getWriter();//响应流
        writer.print("Hello,Serlvet");
    }

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

5.编写Servlet的映射

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

6.配置Tomcat

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

7.启动测试，OK

6.3Servlet原理

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

6.4Mapping问题

1.一个Servle可以指定一个映射路径

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

4.默认请求路径

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

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

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

6.优先级问题

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

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

public class ErrorServlet  extends HttpServlet {
    @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</h1>");


    }

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

6.5ServletContext

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

1.共享数据

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

package com.dai.servlet;

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

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

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

    }
}

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                      http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1"
         metadata-complete="true">
  <servlet>
    <servlet-name>hello</servlet-name>
  <servlet-class>com.dai.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.dai.servlet.HelloServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>getc</servlet-name>
    <url-pattern>/getc</url-pattern>
  </servlet-mapping>
</web-app>

测试访问结果；

2.获取初始化参数

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

protected  void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       ServletContext context =  this.getServletContext();
       String url = context.getInitParameter("url");

       resp.getWriter().print(url);
    }

3.请求转发

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

4.读取资源文件

Properties

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

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

思路：需要一个文件流

username=root
password=123456
#classpath

package com.dai.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Properties;

public class ServletDemo05 extends HttpServlet {


    private InputStream is;

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
     this.getServletContext().getResourceAsStream("/WEB-INF/classes/com/db.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 {
  
    }
}

访问测试即可

6.6HttpServletResponse

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

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

1.简单分类

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

servletOutputStream getOutputStream() throws IOException;
PrintWriter getWriter() throws IOExcption;

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

void setcharacterEncoding(string var1);
void setcontentLength(int var1);
void setcontentLengthLong(1ong var1);
void setcontentType(string var1);
void setDateHeader(string var1，1ong var2);
void addDateHeader(string var1，1ong 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);|

响应的状态码

2.常见应用

向浏览器输出消息
下载文件

1.要获取下载文件的路径

2.下载的文件名是啥?

3.设置想办法让浏览器能够支持下载我们需要的东西

4.获取下载文件的输入流

5.创建缓冲区

6.获取QutputStream对象

7.将FileOutputStream流写入到buffer缓冲区

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

package com.dai.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.FileInputStream;
import java.io.IOException;

public class FileServet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//        1.要获取下载文件的路径
    String realPath = this.getClass().getClassLoader().getResource("1.png").getPath();
        System.out.println("下载文件的路径："+ realPath);
//        2.下载的文件名是啥?
String fileName = realPath.substring(realPath.lastIndexOf("\\")+1);
//        3.设置想办法让浏览器能够支持下载我们需要的东西 下载我们需要的东西，中文文件名URLEncoder。encode编码，否则可能乱码
resp.setHeader("Content-Disposition","attachment;filename="+fileName);
//        4.获取下载文件的输入流
        FileInputStream in = new FileInputStream(realPath);
//        5.创建缓冲区
        int len  = 0;
        byte[] buffer = new byte[1024];
//        6.获取QutputStream对象
   ServletOutputStream out = resp.getOutputStream();
//        7.将FileOutputStream流写入到buffer缓冲区 8.使用OutputStream将缓冲区中的数据输出到客户端!
    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 {

    }
}

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                      http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1"
         metadata-complete="true">
<servlet>
  <servlet-name>filedown</servlet-name>
  <servlet-class>com.dai.servlet.FileServet</servlet-class>
</servlet>
<servlet-mapping>
  <servlet-name>filedown</servlet-name>
  <url-pattern>/down</url-pattern>
</servlet-mapping>

</web-app>

3.验证码功能

验证怎么来的？

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

package com.dai.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;

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("Pragma","no-cache");

        //把图片写给浏览器
        ImageIO.write(image,"jpg",resp.getOutputStream());
    }
   //生成随机数
    private String makeNum(){
       Random random = new Random();
       String num = random.nextInt(999999)+"";
     StringBuffer sb = new StringBuffer();
     for (int i = 0; i< 7-num.length();i++){
         sb.append("0");
     }
     num = sb.toString() +num;
     return num;
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req, resp);
    }
}

4.实现重定向

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

常见场景：

用户登录

void sendRedirect(String varl) throws IOException;

测试：

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  /*
    resp.setHeader("Localtion","/r/img");
    resp.setStatus(302);
   */
  
   resp.sendRedirect("/r/img");//重定向
    
}

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

相同点

页面都会实现跳转

不同点

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

package com.dai.servlet;

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 RequestTest extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("进入这个请求");
        //处理请求
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        
        System.out.println(username+":"+password);
        //重定向的时候一定要注意，路径问题，否则404；
        resp.sendRedirect("/r/success.jsp");
        
    }

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

<html>
<body>

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

6.7HttpServletRequest

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

获取前端传递的参数，请求转发

package com.dai.servlet;

import com.sun.net.httpserver.HttpServer;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.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 {
        req.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("==================");

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

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

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

相同点

页面都会实现跳转

不同点

请求转发的时候，url不会产生变化 307
重定向时候,url地址栏会发生变化 302

request和response作用

req（request）和（response）对象起到了服务器与客户机之间的信息传递作用。
req对象用于接收客户端浏览器提交的数据，从浏览器端发出请求 ，取得数据。
resp对象将服务器端的数据发送到客户端浏览器。

7.Cookie、 Session

什么是 cookie

cookie，有时我们也用其复数形式 cookies，是服务端保存在浏览器端的数据片段。以 key/value的形式进行保存。每次请求的时候，请求头会自动包含本网站此目录下的 cookie 数据。网站经常使用这个技术来识别用户是否登陆等功能。

Session：在计算机中，尤其是在网络应用中，称为“会话控制”。Session对象存储特定用户会话所需的属性及配置信息。这样，当用户在应用程序的Web页之间跳转时，存储在Session对象中的变量将不会丢失，而是在整个用户会话中一直存在下去。

7.1会话

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

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

你能怎么证明你是西开的学生?

你西开

1.发票西开给你发票

2.学校登记西开标记你来过了

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

客户端服务端

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

2.服务器登记你俩过了，下次你来的时候我来匹配你;seesion

7.2保存会话的两种技术

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

session

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

常见常见：网站登录后，你下次不用再登录了，第二次访问直接就上去了！

7.3cookie

1.从请求中拿到cookie信息

2.服务器响应给客户端cookie

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

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

一个网站cookie是否存在上限!聊聊细节问题

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

删除cookie：

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

编码解码：

 req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");

测试

package com.dai.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.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.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
        PrintWriter out = resp.getWriter();

        //Cookie,服务器端从客户端获取呀；
        Cookie[] cookies = req.getCookies();//这里返回数组，说明Cookie可能存在多个

        //判断Cookie是否存在
        if (cookies !=null){
            //如果存在怎么办
            out.write("你上次访问的时间是：");
            for (int i = 0; i < cookies.length; i++) {
                Cookie cookie = cookies[i];
                //获取cookie的名字
                if (cookie.getName().equals("lastLoginTime")){
                    //获取cookie中的值
                    long lastLoginTime = Long.parseLong(cookie.getValue());
                    Date date = new Date(lastLoginTime);
                    out.write(date.toLocaleString());
                }
            }

        }else{
            out.write("这是一个访问本站");
        }

        //服务给客户端响应一个cookie:
        Cookie cookie = new Cookie("lastLoginTime", System.currentTimeMillis()+"");

        //cookie有效期1天
        cookie.setMaxAge(24*60*60);
        resp.addCookie(cookie);
    }

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

7.4Session(重点)

什么是Sesion:

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

Session和cookie的区别：

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

使用场景：

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

使用Session：

package com.dai.servlet;

import com.dai.pojo.Person;

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

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的ID
       session.setAttribute("name",new Person("代",1));
        //给Session的ID
        String sessionId = session.getId();

        //判断Session是不是新创建
        if (session.isNew()){
            resp.getWriter().write("session创建成功,ID:"+sessionId);
        }else{
            resp.getWriter().write("session以及在服务器中存在了，ID"+ sessionId);
        }
//        //Session创建的时候做了什么事情
//        Cookie cookie = new Cookie("JSESSIONID",sessionId);
//        resp.addCookie(cookie);
    }

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

package com.dai.servlet;

import com.dai.pojo.Person;

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

        Person person = (Person)  session.getAttribute("name");
        System.out.println(person.toString());
     }

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

package com.dai.servlet;

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

    }

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

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

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

8.JSP

8.1什么是JSP

java Sever Pages: java服务器端页面。也和Servlet一样，用于动态Web技术！

最大的特点：

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

8.2JSP原理

思路：JSP到底怎么执行

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

tomacat中有一个work目录；

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

我的电脑地址：

发现页面转变了java程序

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

JSP最终会被转换成JAVA类

JSP本质上就是一个Servlet

//初始化
public void_jspInit(){

}
//销毁
public void _jspDestroy{

}
//JSPService
public void _jspService{

}

1.判断请求

2.内置一些对象

对象	类型	说明
request	javax.servlet.http.HttpServletRequest	获取用户请求信息
response	javax.servlet.http.HttpServletResponse	响应客户端请求，并将处理信息返回到客户端
out	javax.servlet.jsp.JspWriter	输出内容到 HTML 中
session	javax.servlet.http.HttpSession	用来保存用户信息
application	javax.servlet.ServletContext	所有用户共享信息
config	javax.servlet.ServletConfig	这是一个 Servlet 配置对象，用于 Servlet 和页面的初始化参数
pageContext	javax.servlet.jsp.PageContext	JSP 的页面容器，页面上下文。用于访问 page、request、application 和 session 的属性
page	javax.servlet.jsp.HttpJspPage	类似于 Java 类的 this 关键字，表示当前 JSP 页面
exception	java.lang.Throwable	该对象用于处理 JSP 文件执行时发生的错误和异常；只有在 JSP 页面的 page 指令中指定 isErrorPage 的取值 true 时，才可以在本页面使用 exception 对象。

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

response. setcontentType("text/htm1");
//设置响应的页面类型
pagecontext = _jspxFactory.getPagecontext(this，request，response,
nu17，true，8192，true);
_jspx_page_context = pagecontext;
application = pagecontext. getservletcontext(;
config = pagecontext.getservletconfig(;
session = pagecontext. getsession;
out = pagecontext.getout(;
_jspx_out = out;

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

在JSP页面中；

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

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

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

这样的格式，输出到前端

8.3JSP基础语法

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

JSP表达式

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

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

JSP脚本片段

%@ page contentType="text/html; charset=UTF-8" language="java" %>>
<html>
<head>$Title$</head>
<body>
<%--jsp表达式
作用：用来将程序的输出，输出到客户端
<%=变量或者表达式%>--%>

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

 <%
     int x =10;
     out.println(x);
 %>

脚本片段的再实现

<%
     int x =10;
     out.println(x);
 %>
<p>这是一个JSP文档</p>
<%
    int y = 2;
    out.println(y);
%>
<hr>
<%--在代码嵌入HTML元素--%>
<%
    for (int i = 0; i <5;i++){
     %>   <h1>Hello,World <%=i%></h1>
<%
    }
%>

JSP声明

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

------------------------------------------------------------
<%
    for (int i = 0; i <5;i++){
     %>   <h1>Hello,World${i}</h1>
<%
    }
%>

JSp声明：会被编译到JSP生产java的类中！其他的，就会被生成到.jspService方法中

在jsp，嵌入java代码即可!

<%%>
<%=%>
<%!%>

<%----%>

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

8.4JSP指令

<%--
  Created by IntelliJ IDEA.
  User: 25966
  Date: 2023/3/14
  Time: 22:49
  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>
<%--include会将两个页面合二为一--%>
<%@include file=".../common/header.jsp"%>
<h1>网页主体</h1>
<%@include file=".../common/header.jsp"%>

<hr>
<%--jsp标签
jsp:include:拼接页面，本质还是三个--%>
<jsp:include page=".../common/header.jsp"/>
<h1>网页主体</h1>
<jsp:include page=".../common/footer.jsp"/>
</body>
</html>

8.5 9大内置对象

PageContext 存东西
Request 存东西
Response
Session 存东西
Application 【SerlvetContext】存东西
config 【SerlvetConfig】
out
page
exception

pageContext.setAttribute("name1","1号");//保存的数据只在一个页面中有效
request.setAttribute("name2","2号");//保存的数据只在一次请求中有效，请求转发会携带这个数据
session.setAttribute("name3","3号");//保存的数据只在一次会话中有效，从打开浏览器到关闭浏览器
application.setAttribute("name4","4号");//保存的数据只在服务器中有效，从打开浏览器到关闭浏览器

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

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

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

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

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

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

EL表达式: ${}

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

JSP标签

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>1</h1>
<%--jsp:include--%>
<%----%>

<jsp:forward page="jsptag2.jsp">
    <jsp:param name="name" value="dai"></jsp:param>
    <jsp:param name="age" value="12"></jsp:param>
</jsp:forward>

</body>
</html>

JSTL标签式

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

核心标签（掌握部分）

JSTL标签库使用步骤

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

<%--
  Created by IntelliJ IDEA.
  User: 25966
  Date: 2023/3/16
  Time: 21:08
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<html>
<head>
    <title>Title</title>
</head>
<body>
<h4>if测试</h4>
<hr>
<form action="coreif.jsp" method="get">
<%--    
EL表达式获取表单中的数据
${paraam.参数名}}
--%>
    <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>
</html>

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%--
  Created by IntelliJ IDEA.
  User: 25966
  Date: 2023/3/16
  Time: 21:12
  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>
<%--定义一个变量score,职为85--%>
<c:set var="score" value="85"/>

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

<%@ page import="java.util.ArrayList" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%--
  Created by IntelliJ IDEA.
  User: 25966
  Date: 2023/3/16
  Time: 21:12
  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(1,"张三");
    people.add(2,"李四");
    people.add(3,"王五");
    people.add(4,"赵六");
    people.add(7,"田六");
    request.setAttribute("list",people);

%>

<%--
var,每一次遍历出来的变量
items，要遍历的对象
begin, 哪里开始
end， 到哪里
step,岁长
--%>
<c:forEach var="people" items="${list}">
    <c:out value="${people}"/> <br>
</c:forEach>

<hr>
<c:forEach var="people" items="${list}" begin="1" end="3" step="">

</c:forEach>
</body>
</html>

格式化标签

SQL标签

XML标签

9. JavaBean

实体类

JavaBean有特定的写法：

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

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

ORM : 对象关系映射

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

id	name	age	address
1
2
3

package com.dai.pojo;
//实体类：我们一般都是和数据库中的表结构一一对应
public class People {

    //
    //
    private int id;
    private String name;
    private int age;
    private String addrress;

    public People() {
    }

    public People(int id, String name, int age, String addrress) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.addrress = addrress;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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 String getAddrress() {
        return addrress;
    }

    public void setAddrress(String addrress) {
        this.addrress = addrress;
    }

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

<%--
  Created by IntelliJ IDEA.
  User: 25966
  Date: 2023/3/16
  Time: 22:00
  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>
<%-- People people =  new People();--%>
<%-- people.setAddress();--%>
<%--people.setId();--%>
<%--people.setAge();--%>
<%--people.setName();--%>

<jsp:useBean id="people" class="com.dai.pojo.People" scope="page"/>
<jsp:setProperty name="people" property="addrress" value="重庆"/>
<jsp:setProperty name="people" property="id" value="1"/>
<jsp:setProperty name="people" property="age" value="3"/>
<jsp:setProperty name="people" property="name" value="dai"/>
<%--<%=people.getAddrress()%>--%>
姓名：<jsp:getProperty name="people" property="name"/>
id：<jsp:getProperty name="people" property="id"/>
年龄：<jsp:getProperty name="people" property="age"/>
姓名：<jsp:getProperty name="people" property="addrress"/>
</body>
</html>

过滤器
文件上传
邮件发送
JDBC复习：如何使用JDBC,JDBC crud jdbc事务

10.MVC三层架构

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

10.1早些年

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

servlet--CRUD--->数据库
弊端：程序十分臃肿，不利于维护
servlet的代码中，处理请求、响应、视图跳转、处理JDBC、处理业务代码、处理逻辑代码
    
    
架构：没有什么是加一层解决不了的
程序猿调用
|
JDBC
|   
Mysql Oracle SqlServer...

10.2MVC三层架构

Model

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

View

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

Controller（Servlet)

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

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

11.Filter(重点)

filter:过滤器，用来过滤网站的数据；

处理中文乱码
登录验证

1、导包

2、编写过滤器

1.导包不要导错了

2.实现Fileter接口，重写对应的方法接口即可

public class CharacterEncodingFilter implements Filter {

    //初始化：web 服务器启动，就以及初始化了随时等待过滤对象出现
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("初始化");
    }
//chain 链
/*
1.过滤器中所有的代码，在过滤特定请求的时候都会执行
2.必须要让过滤器继续同行
Chain.doFilter(Request,Response);
 */
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
      request.setCharacterEncoding("utf-8");
      response.setCharacterEncoding("utf-8");
      response.setContentType("text/html;charset=UTF-8");
        System.out.println("执行前");
        chain.doFilter(request,response);//让我们的请求继续走，如果不写，程序到这里就被拦截停止!
        System.out.println("执行后");
    }
//销毁
    public void destroy() {
       System.out.println("CharacterEncodingFilter销毁");

    }
}

3.在web.xml中配置

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

12.监听器

实现一个监听的接口

1.编写一个监听器、实现监听器的接口

package com.dai.listener;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
// 统计网站在线人数： 统计session
public class OnlineCountListener  implements HttpSessionListener {
    //创建session监听，看你的一举一动
    //一旦创建Session就会触发一次这个事件
    public void sessionCreated(HttpSessionEvent se) {
        ServletContext ctx = se.getSession().getServletContext();

       Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount");

       if (onlineCount==null){
           onlineCount = new Integer(1);
       }else{
           int count = onlineCount.intValue();
           onlineCount = new Integer(count+1);
       }

       ctx.setAttribute("OnlineCount",onlineCount);
    }
   //销毁session监听
    //一旦销毁Session避免触发一次这个事件
    public void sessionDestroyed(HttpSessionEvent se) {
        ServletContext ctx = se.getSession().getServletContext();

        Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount");

        if (onlineCount==null){
            onlineCount = new Integer(1);
        }else{
            int count = onlineCount.intValue();
            onlineCount = new Integer(count-1);
        }

        ctx.setAttribute("OnlineCount",onlineCount);
    }
/*
1.手动销毁  getSesion().invalidate();
2.自动销毁
 */
}

2.配置监听器

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

3.看情况是否使用

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

package com.dai.listener;

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

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,255,0));//设置背景颜色
        
        frame.add(panel);
        
        frame.setVisible(true);
        
        //监听事件，监听关闭事件
        frame.addWindowListener(new WindowListener() {
            public void windowOpened(WindowEvent e) {
                System.out.println("打开");
            }

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

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

            public void windowIconified(WindowEvent e) {

            }

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

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

            }

            public void windowDeactivated(WindowEvent e) {

            }
        });
        
    }
}

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

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

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

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

14、JDBC

什么是JDBC: java连接数据库

需要jar包的支持

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

实验环境搭建

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Puo0aN3k-1679652485259)(null)]

导入数据库依赖

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7vHJBxlJ-1679652463099)(JavaWeb.assets/image-20230319213614593.png)]

IDEAl连接数据库

JDBC固定步骤：
1.加载驱动

2.连接数据库，代表数据库

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

4.编写SQL(根据业务，不同的SQL)

5.执行SQL

6.关闭连接

预编译SQL

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cdIG8NiA-1679652486190)(null)]

事务

要么都成功，要么都失败

ACID原则；保证数据的安全

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

转账：
A:1000
B:1000

A(900)-->B(1100)

Junit单元测试

依赖

简单使用

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

@Test
public void test()
System.out.println("hello")

失败的时候是红色的

搭建一个环境

中实现

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

dddyyy_123

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
JavaWeb

web开发：web,网页的意思，www。baidu.com静态webhtml，css提高給所有人看的数据始终不会发生变化动态web淘宝，几乎是所有的网站提供给所有人看的数据始终会发生变化，每个人在不同的时间，不同的地点看到的信息各不相同技术栈：Servert/JSP,ASP,PHP在java中，动态web资源开发的技术统称为javaWebhttp（超文本传输协议）是一个简单的请求，响应协议，它通常运行在TCP之上。
复制链接

扫一扫