JavaWeb
文章目录
前言
即使再小的帆也能远航
一、web的基本概念
1. 基本概念
- 静态web：html，css3
- 动态web：（技术栈）servlet/jsp，asp，php
2. web应用程序
- 能访问到的任何一个页面或者资源，都存在与这个世界上的某一个角落的计算机上
- url
- 这些统一的web资源会被放在同一个文件夹下web–>tomcat：服务器
- web应用的组成：
- 静态web：html，css，js
- 动态web：jsp，servlet
- java程序
- jar包
- 配置文件 Properties
服务器统一管理，提供外界使用
3. 静态web
- 网页后缀：
*.htm
*.html - 通过网络
一次请求request
一次响应response - 缺点：
- web页面无法动态更新，所有用户看到的都是同一个页面
- 无法动态更新、伪动态
- JS（实际开发中用的最多的）
- VBScript
- 无法和数据库交互，数据无法持久化，用户无法交互
- web页面无法动态更新，所有用户看到的都是同一个页面
4. 动态web
- 页面效果动态展示，因人而异（例如：淘宝的猜你喜欢）
- 缺点：加入服务器的动态Web资源出现了错误，就需要重新编写发布
- 优点：可以动态更新，可以与数据库交互（数据持久化：注册，商品信息）
二、web服务器讲解
1. web服务器
- ASP：
- 微软，国内最早流行
- 在HTML中嵌入了VB脚本，ASP+COM
- 在ASP开发中，基本一个页面都有几千行的业务代码，页面极其混乱
- 维护成本高！
- C#
- iis
- php：
- 开发速度快，功能强大，跨平台，代码简单
- 无法承载大访问量（局限性）
- jsp：
- 本质是servlet
- 主推B/S架构（B/S 浏览器和服务器，C/S：客户端和服务器）
- 基于Java语言
- 可以承载三高问题带来的影响（高并发，高可用，高性能）
- 语法像ASP，ASP–>JSP，加强市场强度
2. web服务器
- 服务器是一种被动的操作，用来处理用户的一些请求和给用户一些响应信息
- IIS：微软的，ASP、Windows中自带的
- Tomcat
- 重要思想：面向百度编程
- 下载Tomcat：
- 安装 or 解压
- 了解配置文件及目录结构
- 这个东西的作用
- 核心：rt.jar
三、Tomcat详解
1. 安装
tomcat官网：https://tomcat.apache.org/
解压Tomcat压缩包
2. 启动与配置
（解压后的压缩包内的）文件夹的作用：
bin：一些启动和关闭的脚本文件
conf：配置
lib：一些插件，即依赖的jar包
logs：日志（把控制台的文本输出为文本文件）
temp：一些临时文件+
webapps：存放网站
work：工作目录
启动：startup.bat
关闭：shutdown.bat
访问测试：https://localhost:8080/
可能遇到的问题：
1.Java环境变量没有配置
2.闪退问题：需要配置兼容性
3.乱码文图：配置文件中设置（logs里的一个文件里的UTF8改成GBK）
即将conf目录下的logging属性文件中控制台编码改为GBK就行了
3. 配置
- conf里的server.xml(服务器核心配置文件)
- webapps的ROOT里的index.jsp
- 可以配置启动的端口号connector的port（server.xml）
- tomcat的默认端口号为：8080
- mysql：3306
- http：80
- https：443
- 可以配置主机的名字
- 默认主机名：loca–>127.0.0.1
- 默认网站应存放的位置为：webapps
- 修改localhost：drive–>etc–>hosts
- 高难度面试题
请你谈谈网站是如何进行访问的- 输入一个域名，回车
- 检查本机的C:\Windows\System32\drivers\etc\hosts配置文件下有没有这个域名映射
- 有：直接返回对应的ip地址（例如：127.0.0.1 --> localhost）
- 没有：去DNS（全世界的域名都在这里管理）服务器找，找到就返回，找不到就返回找不到
- 可以配置一下环境变量（可选项）
4. 发布一个web网站
不会就先模仿
- 将自己写的网站，放到服务器中指定的web应用的文件夹（webapps）下，就可以访问网站应该有的结构了
- webapps ： Tomcat服务器的web目录
- ROOT ：网站的目录名
- WEB-INF
- classes ： java程序
- lib ：web应用所依赖的jar包
- web.xml : 网站配置文件
- index.html ：默认的首页
- static
- css
- style.css
- js
- img
- css
- …
- WEB-INF
- ROOT ：网站的目录名
- webapps ： Tomcat服务器的web目录
四、HTTP
- HTTP协议：面试
- Maven：构建工具
- Maven安装包
- servlet入门：
- helloworld
- servlet配置
-
原理
1. 什么是HTTP
- HTTP:（超文本传输协议）是一个简单的请求-响应协议，它通常运行在tcp之上
- 文本：html，字符串…
- 超文本：图片，音乐，视频，定位，地图…
- 端口：80
- Https：安全的
- 443
2. HTTP的两个时代
http1.0：HTTP/1.0：短连接！客户端与web服务器连接后，只能获得一个web资源，断开连接
http2.0：HTTP/1.1：长连接！客户端与web服务器连接后，可以获得多个web资源
3. http请求
- 客户端->发请求 Request ->服务器
- 以百度为例
Request URL: https://www.baidu.com/ 请求地址
Request Method: GET get方法/post方法
Status Code: 200 OK 状态码：200 3-- 5-- 4-- 等
Remote Address: 14.215.177.39:443 远程地址（+端口）
Accept:text/html
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9 语言
Cache-Control: max-age=0
Connection: keep-alive
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. http响应
- 服务器->响应response->客户端
- 以百度为例
Cache-Control: private 缓存控制
Connection: keep-alive 连接：保持连接（活着）
Content-Encoding: gzip 编码
Content-Type: text/html;charset=utf-8 类型
1. 响应头
2. 响应体
- Accept: 告诉浏览器，他所支持的数据类型
Accept-Encoding: 支持哪种编码格式 GBK UTF-8 GB2312 ISO8859-1
Accept-Language: 告诉浏览器，它的语言环境
Cache-Control: 缓存控制
Connection: 告诉浏览器，请求完成是断开还是保持连接
HOST：主机…
Refresh：定时刷新，告诉客户端，多久刷新一次
Location：让网页重新定位
3. 响应状态码
200 请求响应成功
3** 请求重定向（重定向：你重新到我给你的新位置去）
4** 找不到资源，404资源不存在
5** 服务器代码错误 500 502网关错误
常见面试题：
当你的浏览器中地址栏输入地址并回车的一瞬间到页面能够展示回来，经历了什么？
五、Maven
0. 我为什么要学习这个技术？
- 在JavaWeb开发中，需要使用大量的jar包，需要我们手动去导入；
- 如何能够让一个东西自动帮我导入和配置这个jar包
- 由此，Maven诞生了
1. Maven项目架构管理工具
- 用来方便自动导入配置jar包的！
- Maven的核心思想：约定大于配置，有约束，不要去违反
- Maven会规定好你该如何去编写我们的java代码，必须要按照这个规范来；
2. 下载安装Maven
官网 https://maven.apache.org/
下载完成后，解压即可
修改setting.xml下的mirrors
3. 配置环境变量
maven目录，以及maven下的bin目录
测试Maven是否配置成功，保证必须配置完毕 cmd–>mvn -version
4. 阿里云镜像
- 镜像 mirrors
- 作用：加速我们的下载
- 国内建议使用阿里云镜像
5. 本地仓库
本地仓库，远程仓库
建立本地仓库localRepository
自己新建一个文件夹maven-repo
6. IDEA中Maven的操作
- 启动IDEA
- 创建一个MavenWeb项目
- 等待项目初始化完毕
- 观察Maven仓库中多了什么东西
- IDEA中的Maven设置
注意：IDEA项目创建成功后，检查一下这里的Maven配置
7. 创建一个普通的Maven项目
8. 标记文件夹功能
9. 在IDEA中配置Tomcat
启动成功后跳出页面显示 hello world
10. pom文件
pom.xml是Maven的核心配置文件
<?xml version="1.0" encoding="UTF-8"?>
<!--Maven版本和头文件-->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.zretc</groupId>
<artifactId>javaweb-01-maven</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
<!--Package:项目的打包方式
jar：Java应用
war：JavaWeb应用
-->
<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>
<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中配置resources，来防止我们资源导出失败的问题 -->
<resources>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
</resources>
</build>
</project>
maven由于它的约定大于配置，我们之后可能遇到我们写的配置文件，无法被导出或者生效的问题，解决方法：
<build>
<resources>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
</resources>
</build>
11. IDEA操作
12. 解决遇到的问题
-
Maven3.6.2
Unable to import maven project:See logs for detail
解决方法：降级为3.6.1 -
Tomcat闪退
在startup.bat中setlocal – end 里，end前添加pause ，运行后不闪退了即可删掉pause -
IDEA中每次都要重复配置Maven
在IDEA的全局默认配置中去配置
-
Maven项目中Tomcat无法配置
-
maven默认web项目中的web.xml版本问题
复制tomcat文件夹下webapp里的ROOT文件里的web.xml的文本 -
替换为webapp4.0版本，和tomcat一致
-
Maven仓库的使用
地址：http://mvnrepository.com/
六、Servlet
按住Ctrl+鼠标左键，可以在重写方法里同时选中doGet和doPost方法
1. Servlet简介
- Servlet就是sun公司开发动态web的一门技术 HTTPServlet GenericServlet
- Sun在这些API中提供了一个接口，叫做：Servlet，如果你想开发一个Servlet程序，只需要完成两个小步骤：
- 编写一个类，实现Servlet接口
- 把开发好的Java类部署到web服务器中
- 把实现了Servlet接口的Java程序叫做，Servlet
2. HelloServlet
- 创建一个普通的Maven项目，删掉里面的src目录，以后我们的学习就在这个项目里面建立Moudel；这个空的工程就是Maven主工程；
- 关于Maven父子工程的理解；
父项目中会有module
子项目中会有parent
父项目中的jar包子项目可以直接使用
son extends father
- Maven环境优化
- 修改web.xml为最新的
- 将maven的结构搭建完整
- 编写一个Servlet程序
Servlet接口 --> GenericServlet --> HTTPServlet --> 我们自己的类只需要继承HTTPServlet即可
package com.zretc.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.PrintWriter;
public class HelloServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
PrintWriter writer = resp.getWriter();
writer.print("hello,servlet!");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
- 编写Servlet的映射
为什么需要映射：我们写的是Java程序，但是要通过浏览器访问，而浏览器需要连接web服务器，所以我们需要在web服务中注册我们写的Servlet，还需要给他一个浏览器能够访问的地址
<!-- 注册Servlet-->
<servlet>
<servlet-name>hello</servlet-name>
<servlet-class>com.zretc.servlet.HelloServlet</servlet-class>
</servlet>
<!-- Servlet的请求路径，映射路径-->
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
- 配置Tomcat
注意：配置项目发布的路径就可以了 - 启动测试：OK！
3. Servlet原理
Servlet是由Web服务器调用，web服务器在收到浏览器请求之后，会调用Service处理请求和响应
4. Mapping问题
- 一个Servlet可以指定一个映射路径
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
- 一个Servlet可以指定多个映射路径
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello2</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello3</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello4</url-pattern>
</servlet-mapping>
- 一个Servlet可以指定通用映射路径
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello/*</url-pattern>
</servlet-mapping>
- 默认请求路径（运行任何网页都会优先执行这个网页）
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
- 指定一些后缀或者前缀等等…
<!-- 可以自定义后缀实现请求映射
注意点：*前面不能加项目映射的路径
-->
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>*.zretc</url-pattern>//此处有/没*，有*没/
</servlet-mapping>
- 优先级问题
指定了固有的映射路径优先级最高，如果找不到就会走默认的处理请求
<!-- 404-->
<servlet>
<servlet-name>error</servlet-name>
<servlet-class>ErrorServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>error</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
5. ServletContext
web容器在启动的时候，它会为每个web程序都创建一个对应的ServletContext对象，他代表了当前的web应用；
1. 共享数据
我在这个Servlet中保存的数据，可以在另外一个servlet中拿到；
package com.zretc.servlet;
import javax.servlet.ServletConfig;
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上下文
ServletContext context = this.getServletContext();
String username = "恰恰";//数据
context.setAttribute("username",username);
//将一个数据保存在ServletContext中，名字key为：username，值value：username
//servletcontext是多个Servlet都能拿到
System.out.println("hello");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
package com.zretc.servlet;
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 {
resp.setContentType("text/html");
resp.setCharacterEncoding("utf-8");
// resp.setContentType("text/html;utf-8"); //合起来只写这一句（一次性写两个参数）也可以
ServletContext context = this.getServletContext();
String username = (String) context.getAttribute("username");
resp.getWriter().print("名字："+username);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
<servlet>
<servlet-name>getc</servlet-name>
<servlet-class>com.zretc.servlet.GetServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>getc</servlet-name>
<url-pattern>/getc</url-pattern>
</servlet-mapping>
测试访问结果.
2. 获取初始化参数
package com.zretc.servlet;
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 ServletDemo03 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
ServletContext context = this.getServletContext();
String url = context.getInitParameter("url");
resp.getWriter().print(url);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
<!-- 配置一些web应用初始化参数-->
<context-param>
<param-name>url</param-name>
<param-value>jdbc:mysql://localhost:3306/mybatis</param-value>
</context-param>
<servlet>
<servlet-name>gp</servlet-name>
<servlet-class>com.zretc.servlet.ServletDemo03</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>gp</servlet-name>
<url-pattern>/gp</url-pattern>
</servlet-mapping>
3. 请求转发 getRequestDispatcher
package com.zretc.servlet;
import javax.servlet.RequestDispatcher;
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 ServletDemo04 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
ServletContext context = this.getServletContext();
System.out.println("进入了ServletDemo04");
context.getRequestDispatcher("/gp").forward(req,resp);
// RequestDispatcher requestDispatcher = context.getRequestDispatcher("/gp");//转发的请求路径
// requestDispatcher.forward(req,resp);//调用forward实现请求转发
//这种方式的转发请求，路径不会变，url会显示sd4，但页面内容已经跳转到gp
//转发，顾客买烟，售货员拿烟，售货员给顾客。售货员是实际接触的人，所以url是售货员，不是烟（找人帮拿）
//重定向，消费者买牛肉，前台售货员说生鲜区有牛肉，消费者自己去拿牛肉。牛肉实际接触的，所以url是牛肉，不再是售货员（别人告诉你自己拿）
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
<servlet>
<servlet-name>sd4</servlet-name>
<servlet-class>com.zretc.servlet.ServletDemo04</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>sd4</servlet-name>
<url-pattern>/sd4</url-pattern>
</servlet-mapping>
4. 读取资源文件
- Properties
- 在Java目录下新建properties
- 在resources目录下新建properties
- 发现：都被打包到了同一个路径下：classes，我们俗称这个路径为classpath
<!-- 在build中配置resources，来防止我们资源导出失败的问题 -->
<build>
<resources>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
</resources>
</build>
/ 的当前路径
username=root
password=123456
思路：需要一个文件流 getResourceAsStream
package com.zretc.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.util.Properties;
public class ServletDemo05 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// InputStream is = this.getServletContext().getResourceAsStream("/WEB-INF/classes/db.properties");//第一条杠/代表当前web应用
InputStream is = this.getServletContext().getResourceAsStream("/WEB-INF/classes/com/zretc/servlet/aa.properties");//第一条杠/代表当前web应用
Properties properties = new Properties();
properties.load(is);
String username = properties.getProperty("username");
String password = properties.getProperty("password");
resp.getWriter().print(username+":"+password);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
<servlet>
<servlet-name>sd5</servlet-name>
<servlet-class>com.zretc.servlet.ServletDemo05</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>sd5</servlet-name>
<url-pattern>/sd5</url-pattern>
</servlet-mapping>
访问测试即可；
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. 下载文件
- 向浏览器输出消息
- 下载文件
- 要获取下载文件的路径
- 下载的文件名是啥
- 设置想办法让浏览器能够支持下载我们需要的东西
- 获取下载文件的输入流
- 创建缓冲区
- 获取OutputStream对象
- 将FileOutputStream流写入到buffer缓冲区
- 使用OutputStream将缓冲区中的数据输出到客户端！
package com.zretc.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.FileOutputStream;
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 = this.getServletContext().getRealPath("/WEB-INF/2.png");//失败
// String realPath = "E:\\其他\\2.png";
System.out.println("下载文件的路径："+realPath);
//2. 下载的文件名是啥
String filename = realPath.substring(realPath.lastIndexOf("\\") + 1);
//3. 设置想办法让浏览器能够支持下载我们需要的东西
resp.setHeader("Content-Disposition","attachment;"+ URLEncoder.encode(filename,"UTF-8"));
//4. 获取下载文件的输入流
FileInputStream fis = new FileInputStream(realPath);
//5. 创建缓冲区
int len = 0;
byte[] buffer = new byte[1024];
//6. 获取OutputStream对象
ServletOutputStream os = resp.getOutputStream();
//7. 将FileOutputStream流写入到buffer缓冲区，使用OutputStream将缓冲区中的数据输出到客户端！
while ((len=fis.read(buffer))>0){
os.write(buffer,0,len);
}
os.close();
fis.close();
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
<servlet>
<servlet-name>filedown</servlet-name>
<servlet-class>com.zretc.servlet.FileServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>filedown</servlet-name>
<url-pattern>/down</url-pattern>
</servlet-mapping>
3. 验证码功能
- 前端
- 略
- 后端
package com.zretc.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(9999999) + "";
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 {
doGet(req, resp);
}
}
<servlet>
<servlet-name>ImageServlet</servlet-name>
<servlet-class>com.zretc.servlet.ImageServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>ImageServlet</servlet-name>
<url-pattern>/img</url-pattern>
</servlet-mapping>
4. 实现重定向
- B一个web资源收到客户端A请求后，B他会通知A客户端去访问另一个web资源C，这个过程叫重定向
- 常见场景：
- 用户登录（后跳转到另一个页面）
void sendRedirect(String var1) throws IOException;
测试：
package com.zretc.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 RedirectServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//测试
resp.setHeader("Location","/r/img");
resp.setStatus(HttpServletResponse.SC_MOVED_TEMPORARILY);//302
//重定向
resp.sendRedirect("/resp/img");
// resp.sendRedirect("./img");
// resp.sendRedirect("img");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
<servlet>
<servlet-name>RedirectServlet</servlet-name>
<servlet-class>com.zretc.servlet.RedirectServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>RedirectServlet</servlet-name>
<url-pattern>/red</url-pattern>
</servlet-mapping>
- 面试题：请你聊聊重定向和转发的区别？
- 相同点
- 页面都会实现跳转
- 不同点
- 请求转发的时候，url不会产生变化
- 重定向时候，url地址栏会发生变化
用户登录测试页面跳转
- 相同点
package com.zretc.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("./success.jsp");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<body>
<h2>Hello World!</h2>
<%--这里提交的路径，需要寻找到项目的路径--%>
<%--${pageContext.request.contextPath}代表当前的项目--%>
<%--<form action="/resp/login" method="get">--%>
<form action="${pageContext.request.contextPath}/login" method="get">
用户名：<input type="text" name="username"><br>
密码：<input type="password" name="password"><br>
<%--测试行：--%>
<%--<input type="text" value="${pageContext.request.contextPath}">--%>
<%--${pageContext.request.contextPath}如果未被识别，可能是web.xml2.3版本无法识别原因，则修改为web.xml4.0版本--%>
<input type="submit">
</form>
</body>
</html>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Success</title>
</head>
<body>
Success
</body>
</html>
7. HttpServletRequest
HttpServletRequest代表客户端的请求，用户通过Http协议访问服务器，HTTP请求中的所有信息会被封装到HttpServletRequest，通过这个HttpServletRequest的方法，获得客户端的所有信息；
get~
String getAuthType();
Cookie[] getCookies();
long getDateHeader(String var1);
String getHeader(String var1);
Enumeration getHeaders(String var1);
Enumeration getHeaderNames();
int getIntHeader(String var1);
String getMethod();
String getPathInfo();
String getPathTranslated();
String getContextPath();
String getQueryString();
String getRemoteUser();
Principal getUserPrincipal();
String getRequestedSessionId();
String getRequestURI();
StringBuffer getRequestURL();
String getServletPath();
HttpSession getSession(boolean var1);
HttpSession getSession();
1. 获取前端传递的参数
String getParameter(String var1);
String[] getParameterValues(String var1);
2. 请求转发
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h1>登录</h1>
<div style="text-align: center">
<form action="${pageContext.request.contextPath}/login" method="post">
用户名：<input type="text" name="username"><br>
密码：<input type="password" name="password"><br>
爱好：
<input type="checkbox" name="hobby" value="女孩">女孩
<input type="checkbox" name="hobby" value="代码">代码
<input type="checkbox" name="hobby" value="唱歌">唱歌
<input type="checkbox" name="hobby" value="电影">电影
<br>
<input type="submit">
</form>
</div>
</body>
</html>
package com.zretc.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.util.Arrays;
public class LoginServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doPost(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//防止中文乱码
req.setCharacterEncoding("utf-8");
resp.setContentType("text/html;utf-8");
String username = req.getParameter("username");
String password = req.getParameter("password");
String[] hobbies = req.getParameterValues("hobby");
System.out.println("============");
System.out.println(username);
System.out.println(password);
System.out.println(Arrays.toString(hobbies));
System.out.println("============");
//通过请求转发
req.getRequestDispatcher("/success.jsp").forward(req,resp);
//getRequestDispatcher只需写"/success.jsp"，无需"/req/success.jsp";
//getRequestDispatcher的html内容都是success的，url是原来的
// request.getRequestDispatcher("/资源名 URI").forward(request,response);
// 转发时"/"代表的是本应用程序的根目录【root】
// response.send("/web应用/资源名 URI");
// 重定向时"/"代表的是webapps目录
// getRequestDispatcher分成两种，可以用request调用，也可以用getServletContext()调用，不同的是：
// request.getRequestDispatcher(url)的url可以是相对路径，也可以是绝对路径
// this.getServletContext().getRequestDispatcher(url)的url只能是绝对路径
}
}
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Success</title>
</head>
<body>
<h1>登陆成功</h1>
</body>
</html>
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<servlet>
<servlet-name>LoginServlet</servlet-name>
<servlet-class>com.zretc.servlet.LoginServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>LoginServlet</servlet-name>
<url-pattern>/login</url-pattern>
</servlet-mapping>
</web-app>
面试题：请你聊聊重定向和转发的区别？
- 相同点：
- 页面都会实现跳转
- 不同点：
- 请求转发的时候，url不会产生变化 307
- 重定向时候，url地址栏会发生变化 302
Session
Cookie
JSP --> 前端知识！HTML + JS
过滤器
MVC三层架构
dao
service
controller
七、Cookie、Session
1. 会话
会话：用户打开一个浏览器，点击了很多超链接，访问多个web资源，关闭浏览器，这个过程可以称之为会话
**有状态会话：**如一个同学来过教室，下次再来教师，我们会知道这个同学，曾经来过
一个网站，怎么证明你来过
客户端 服务端
1.服务端给客户端一个小饼干，客户端下次访问服务端带上小饼干就可以了；cookie
2.服务器等级你来过了，下次你来的时候我来匹配你；session
session：三顾茅庐；cookie：凭票看电影
2. 保存会话的两种技术
-
cookie
客户端技术 （：响应，请求） -
session
服务器技术（行为），利用这个技术，可以保存用户的会话信息。我们可以把信息或者数据放在session中！
常见场景：网站登陆之后，你下次不再登陆了，第二次访问直接就上去了！
3. Cookie
1.从请求中拿到cookie信息
2.服务器响应给客户端cookie
Cookie[] cookies = req.getCookies();//获得cookie
cookie.getName();//获得cookie中的key
cookie.getValue();//获得cookie中的value
new Cookie("lastLoginTime", System.currentTimeMillis()+"");//新建一个cookie
cookie.setMaxAge(24*60*60);//设置cookie的有效期（以秒为单位）
resp.addCookie(cookie);//响应给客户端一个cookie
package com.zretc.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.setContentType("text/html;charset=utf-8");
PrintWriter out = resp.getWriter();
//out是jsp的内置对象
//Cookie，服务器端从客户端获取
Cookie[] cookies = req.getCookies();//这类返回数组，说明Cookie可能存在多个
//判断Cookie是否存在
if (cookies!=null){
boolean flag = false;//默认没有lastLoginTime的cookie
//增强forEach循环：只能取值
// for (Cookie cookie : cookies) { }
//普通for循环：能对每一个下标进行操作
for (int i = 0; i < cookies.length; i++) {
Cookie cookie = cookies[i];
//获取cookie的名字
if (cookie.getName().equals("lastLoginTime")) {//cookie的getName可能是null
out.write("你上次访问的时间是：");
//获取cookie中的值（String-->long-->Date）
long lastLoginTime = Long.parseLong(cookie.getValue());
Date date = new Date(lastLoginTime);
out.write(date.toLocaleString());
flag = true;//有了lastLoginTime的cookie
}
}
if (flag==false){
out.write("这是你第一次访问本站");
}
} else {
out.write("无cookie~~~");
}
//服务端给客户端响应一个cookie（只能是String类型的值）
Cookie cookie = new Cookie("lastLoginTime", System.currentTimeMillis()+"");
//给cookie设置有效期（以秒为单位）
cookie.setMaxAge(24*60*60);
resp.addCookie(cookie);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
<servlet>
<servlet-name>CookieDemo01</servlet-name>
<servlet-class>com.zretc.servlet.CookieDemo01</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>CookieDemo01</servlet-name>
<url-pattern>/c1</url-pattern>
</servlet-mapping>
cookie：一般会保存在本地的用户目录下的 appdata;
一个网站cookie是否存在上限！聊聊细节问题
- 一个cookie只能保存一个信息；
- 一个web站点可以给浏览器发送多个cookie，每个站点最多存放20个cookie；
- cookie大小有限制4kb；
- 300个cookie浏览器上限
删除cookie：
- 不设置有效期，关闭浏览器，自动失效；
- 设置有效期时间为0；
- 手动删除（开发者工具（审查元素）–> Application --> Cookies）
package com.zretc.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;
//保存用户上一次访问的时间
public class CookieDemo02 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//创建一个cookie，名字必须要和要删除的名字一致
Cookie cookie = new Cookie("lastLoginTime", System.currentTimeMillis() + "");
//将cookie有效期设置为0，立马过期
cookie.setMaxAge(0);
resp.addCookie(cookie);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
<servlet>
<servlet-name>CookieDemo02</servlet-name>
<servlet-class>com.zretc.servlet.CookieDemo02</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>CookieDemo02</servlet-name>
<url-pattern>/c2</url-pattern>
</servlet-mapping>
中文数据防乱码（编码，解码）
URLEncoder.encode("兔兔","utf-8");//编码
URLDecoder.decode(cookie.getValue(),"utf-8");//解码
package com.zretc.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.net.URLDecoder;
import java.net.URLEncoder;
import java.util.Date;
//中文数据传递
public class CookieDemo03 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
req.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
PrintWriter out = resp.getWriter();
//Cookie，服务器端从客户端获取
Cookie[] cookies = req.getCookies();//这类返回数组，说明Cookie可能存在多个
//判断Cookie是否存在
if (cookies!=null){
boolean flag = false;//默认没有name的cookie
//普通for循环：能对每一个下标进行操作
for (int i = 0; i < cookies.length; i++) {
Cookie cookie = cookies[i];
//获取cookie的名字
if (cookie.getName().equals("name")) {//cookie的getName可能是null
//获取cookie中的值
//解码 URLDecoder.decode
out.write(URLDecoder.decode(cookie.getValue(),"utf-8"));
// out.write(cookie.getValue());
flag = true;//有了name的cookie
}
}
if (flag==false){
out.write("no find~~~");
}
}
// Cookie cookie = new Cookie("name", "兔兔");
//中文数据最好用 URLEncoder.encode("","utf-8")
//编码
Cookie cookie = new Cookie("name", URLEncoder.encode("兔兔","utf-8"));
resp.addCookie(cookie);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
<servlet>
<servlet-name>CookieDemo03</servlet-name>
<servlet-class>com.zretc.servlet.CookieDemo03</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>CookieDemo03</servlet-name>
<url-pattern>/c3</url-pattern>
</servlet-mapping>
4. Session（重点）
什么是Session：
- 服务器会给每一个用户（浏览器）创建一个Session对象；
- 一个Session独占一个浏览器，只要浏览器没有关闭，这个Session就存在；
- 用户登录之后，整个网站他都可以访问！–> 保存用户的信息；保存购物车的信息…
<!--使用WebServlet注解的依赖-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
</dependency>
package com.zretc.servlet;
import com.zretc.pojo.Person;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.*;
import java.io.IOException;
@WebServlet("/s1")
public class SessionDemo01 extends HttpServlet {
//按住Ctrl+鼠标左键，可以在重写方法里同时选中doGet和doPost方法
//为什么重写这两个方法：因为HttpServlet中的doGet和doPost方法只有原生的req，resp，实现页面的数据交互的本质是重写方法，操作req，resp
@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");//浏览器响应的格式。如需响应回去页面，需写resp.setContentType("text/html");否则setCharacterEncoding即可
//得到Session
HttpSession session = req.getSession();
//给Session中存东西 可以是String，也可以是Object
session.setAttribute("name","兔兔");
// session.setAttribute("person",new Person("兔兔",18));
//获取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);//Session和Cookie互不冲突
// resp.addCookie(cookie);
//cookie（客户端），session（服务器端）
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
package com.zretc.servlet;
import com.zretc.pojo.Person;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
@WebServlet("/s2")
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();
String name = (String)session.getAttribute("name");
resp.getWriter().write("name:"+name);
// if (session.getAttribute("person")!=null) {//不加if判空，会导致未先访问s1时有空指针错误
// Person person = (Person) session.getAttribute("person");
// resp.getWriter().write(person.toString());
// }else{
// resp.getWriter().write("null~~~");
// }
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
package com.zretc.pojo;
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
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;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package com.zretc.servlet;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
@WebServlet("/s3")
public class SessionDemo03 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
HttpSession session = req.getSession();
session.removeAttribute("name");//remove取消
session.invalidate();//（手动）注销
//web.xml可以设置Session默认的失效时间。一般不建议设置太久，以免用户量大、服务器会崩，设置长时间保存可以用Cookie，Cookie可以持久化保存在客户端
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
<!--设置Session默认的失效时间-->
<session-config>
<!--15分钟后Session自动失效，以分钟为单位-->
<session-timeout>15</session-timeout>
</session-config>
Session的setAttribute和getAttribute可以实现跨Servlet，前面讲的ServletContext也可以，但是尽量使用Session
Session和Cookie的区别：
- Cookie是把用户的数据写给用户的浏览器，浏览器保存（可以保存多个）
- Session把用户的数据写到用户独占Session中，服务器端保存（保存重要的信息，减少服务器资源的浪费）
- Session对象由服务创建
使用场景：
- 保存一个登录用户的信息
- 购物车信息
- 在整个网站中经常会使用的数据，我们将它保存在
Session中
使用Session：
HttpSession session = req.getSession();//得到Session
session.setAttribute("name","兔兔");//给Session中存东西 可以是String，也可以是Object
String sessionId = session.getId();//获取Session的ID\
session.isNew();//判断Session是不是新创建的
session.getAttribute("name");//获取Session
session.removeAttribute("name");//remove取消
session.invalidate();//（手动）注销
会话自动过期：web.xml配置，可以设置Session默认的失效时间。
一般不建议设置太久，以免用户量大、服务器会崩，设置长时间保存可以用Cookie，Cookie可以持久化保存在客户端
<!--设置Session默认的失效时间-->
<session-config>
<!--15分钟后Session自动失效，以分钟为单位-->
<session-timeout>15</session-timeout>
</session-config>
八、JSP
1. 什么是JSP
- Java Server Pages ：Java服务器端页面，也和Servlet一样，用于动态Web技术！
- 最大的特点：
- 写JSP就像在写HTML
- 区别：
- HTML只给用户提供静态的数据
- JSP页面中可以嵌入JAVA代码，为用户提供动态数据
2. JSP原理
思路：JSP到底是怎么执行的！
- 代码层面没有任何问题
- 服务器内部工作
-
服务器走完了，work工作目录下的文件才出来（动态生成）
-
Tomcat文件夹下的work目录就是Tomcat工作的目录
D:\BaiduNetdisk\apache-tomcat-8.5.38\work\Catalina\localhost\ROOT\org\apache\jsp
-
IDEA中使用Tomcat，会在IDEA的tomcat中生产一个work目录
（查找IDEA中tomcat文件目录的位置：可以通过运行tomcat查看Server中显示的CATALINA_BASE找到对应路径。
）
C:\Users\24975\AppData\Local\JetBrains\IntelliJIdea2020.1\tomcat\Unnamed_javaweb-session-cookie\work\Catalina\localhost\ROOT\org\apache\jsp
发现页面转变成了java程序！
浏览器向服务器发送请求，不管访问什么资源，其实都是在访问Servlet！
JSP最终也会被转换成为一个Java类！
JSP本质上就是一个Servlet
-
看 index_jsp.java 源码：
org.apache.jasper.runtime.HttpJspBase;
//初始化
public void _jspInit() {}
//销毁
public void _jspDestroy() {}
//JSPService，本质上是Servlet的儿子
public void _jspService(HttpServletRequest request, HttpServletResponse response)
1.判断请求
2.内置了一些对象
final javax.servlet.jsp.PageContext pageContext;//页面上下文
javax.servlet.http.HttpSession session = null;//session
final javax.servlet.ServletContext application;//applicationContext
final javax.servlet.ServletConfig config;//config
javax.servlet.jsp.JspWriter out = null;//out
final java.lang.Object page = this;//page：当前
HttpServletRequest request//请求
HttpServletResponse response//响应
3.输出页面前增加的代码
response.setContentType("text/html");//设置响应】的页面类型
pageContext = _jspxFactory.getPageContext(this, request, response,
null, true, 8192, true);
_jspx_page_context = pageContext;
application = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
_jspx_out = out;
4.以上的这些个对象我们可以在JSP页面中直接使用！
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<body>
<h2>Hello World!</h2>
</body>
四大作用域：page，request，session，application
${pageContext}
${pageScope}
${requestScope}
${sessionScope}
${applicationScope}
<%
out.print("这里可以写Java代码");
session.setAttribute("name","兔兔");
//JSP的九个内置对象，可以直接使用
//本质上相当于一个继承了HttpServlet的实现类，里面把对象都实例化了一遍
%>
</html>
Web容器进行 -->.jsp --> .java -->.class（即本质是个Servlet） -->JVM运行文件
在JSP页面中，只要是JAVA代码就会原封不动的输出
如果是HTML代码，就会被转换为
out.write("<html>\n");
out.write("<body>\n");
out.write("<h2>Hello World!</h2>\n");
out.write("</body>\n");
out.write("</html>\n");
这样的格式，输出到前端！
新建一个普通（未勾选）Maven项目后，
项目中没有webapp文件夹，点击添加框架支持
选择web application，勾选web.xml
创建webapp文件夹
3. JSP基础语法
任何语言都有自己的语法，Java中有。JSP作为Java技术的一种应用，它拥有一些自己的扩充的语法，Java所有语法都支持！
<%--<%@ page import="java.util.Date" %>--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>$Title$</title>
</head>
<body>
<%-- 1. JSP 注解--%>
<!-- HTML注解 -->
<%-- 2. JSP 表达式--%>
<%= new java.util.Date() %>
<%-- <%= new Date() %>--%>
<%out.print("3. JSP脚本（Java代码）");%>
<%--可以脚本与HTML元素互相嵌套使用--%>
<%-- JSP 灵活，但高耦合--%>
<%-- 4. JSP声明 --%>
<%!
static {
System.out.println("Loading Servlet!");
}
private int globalVar = 0; //全局变量
public void method(){
System.out.println("进入了方法！");
}
%>
</body>
</html>
在声明里写的会编译到java文件的最上面
脚本文件作用域会在 jspService 方法里
- JSP表达式
- JSP脚本片段
- JSP声明
区别：
JSP声明 会被编译到JSP生成Java的类中！其他的，就会被生成到_jspService方法中！
<%-- JSP 注释 --%>
<!-- HTML注释 -->
JSP的注释，不会在客户端显示，HTML会！
在源代码 .java 文件中可以查看到HTML代码，不会看到JSP代码
4. JSP指令
<%@page args %>
<%@include file=""%>
errorPage
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--定制错误页面--%>
<%--<%@page errorPage="error/500.jsp" %>--%>
<%--显式的声明这是一个错误页面--%>
<%@page isErrorPage="true" %>
<%@page pageEncoding="UTF-8" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%
int x = 1/0;
%>
</body>
</html>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<img src="../img/500.jpg" alt="500错误">
</body>
</html>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<img src="../img/404.jpg" alt="404错误">
</body>
</html>
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<error-page>
<error-code>404</error-code>
<location>/error/404.jsp</location>
<!-- /表示当前项目 -->
</error-page>
<error-page>
<error-code>500</error-code>
<location>/error/500.jsp</location>
</error-page>
</web-app>
静态包含 和 动态包含
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--<%@include file=""%>--%>
<html>
<head>
<title>Title</title>
</head>
<body>
<%--静态包含，会将两个页面合二为一，代码的直接拼接--%>
<%@include file="common/header.jsp"%>
<h1>网页主体</h1>
<%@include file="common/footer.jsp"%>
<hr>
<%--动态包含，拼接页面，本质还是三个页面--%>
<%--JSP标签--%>
<jsp:include page="common/header.jsp"/>
<h1>网页主体</h1>
<jsp:include page="common/footer.jsp"/>
</body>
</html>
注意文件夹结构
5. 九大内置对象
- PageContext 存东西
- Request 存东西
- Response
- Session 存东西
- Application 【ServletContext】存东西
- config 【ServletConfig】
- out
- page，不用了解
- exception
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%--内置对象--%>
<%
pageContext.setAttribute("name1","兔兔1号");//保存的数据只在一个页面中有效
request.setAttribute("name2","兔兔2号");//保存的数据只在一次请求中有效，请求转发会携带这个数据（重定向是2次请求，不能携带数据）
session.setAttribute("name3","兔兔3号");//保存的数据只在一次会话中有效，从打开浏览器到关闭浏览器
application.setAttribute("name4","兔兔4号");//保存的数据只在一次服务器中有效，从打开服务器到关闭服务器
%>
<%--jsp脚本代码，必须保证Java语法的正确性，以免生成 .java 文件时报500错误等--%>
<%
//从pageContext取出，可以通过寻找的方式来
//从低层到高层（作用域）：page --> request --> session --> application
//类似 JVM：双亲委派机制；（先向上溯源找到根，不断往下使用（顺序相反，这个往下，上面那个往上），classNotfound）
String name1 = (String)pageContext.findAttribute("name1");
String name2 = (String)pageContext.findAttribute("name2");
String name3 = (String)pageContext.findAttribute("name3");
String name4 = (String)pageContext.findAttribute("name4");
String name5 = (String)pageContext.findAttribute("name5");//不存在
// pageContext.forward("pageDemo02.jsp"); //请求转发，pageDemo02就可以访问到request的数据了
%>
<%--使用EL表达式输出 ${}--%>
<h1>取出的值为：</h1>
<h3>${name1}</h3>
<h3>${name2}</h3>
<h3>${name3}</h3>
<h3>${name4}</h3>
<%--区别：--%>
<h3>${name5}</h3><%--不显示--%>
<h3><%=name5%>></h3><%--显示null--%>
</body>
</html>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%--因为作用域不同，并未都能取出--%>
<%
String name1 = (String)pageContext.findAttribute("name1");
String name2 = (String)pageContext.findAttribute("name2");
String name3 = (String)pageContext.findAttribute("name3");
String name4 = (String)pageContext.findAttribute("name4");
%>
<h1>取出的值为：</h1>
<h3>${name1}</h3>
<h3>${name2}</h3>
<h3>${name3}</h3>
<h3>${name4}</h3>
</body>
</html>
application应用场景（多台浏览器）：
几个人都要从库中取出商品
统计在线人数
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%--
public static final int PAGE_SCOPE = 1;
public static final int REQUEST_SCOPE = 2;
public static final int SESSION_SCOPE = 3;
public static final int APPLICATION_SCOPE = 4;
public void setAttribute (String name,
Object attribute,
int scope){
switch (scope) {
case PAGE_SCOPE:
mPage.put (name, attribute);
break;
case REQUEST_SCOPE:
mRequest.put (name, attribute);
break;
case SESSION_SCOPE:
mSession.put (name, attribute);
break;
case APPLICATION_SCOPE:
mApp.put (name, attribute);
break;
default:
throw new IllegalArgumentException ("Bad scope " + scope);
}
}
--%>
<%
pageContext.setAttribute("name","value",PageContext.SESSION_SCOPE);
session.setAttribute("name","value");
%>
</body>
</html>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%--转发--%>
<%
pageContext.forward("index.jsp");//前端页面这样写
// request.getRequestDispatcher("index.jsp").forward(request,response);//Servlet页面这样写
%>
</body>
</html>
request：客户端向服务器发送请求，产生的数据，用户看完，就没用了的
session：客户端向服务器发送请求，产生的数据，用户看完，一会还有用的（没存到数据库）
application：客户端向服务器发送请求，产生的数据，一个用户看完，其他用户还可能使用的（存到了数据库里）
6. JSP标签、JSTL标签、EL标签
需要导包
<!--JSTL表达式 依赖-->
<dependency>
<groupId>javax.servlet.jsp.jstl</groupId>
<artifactId>jstl-api</artifactId>
<version>1.2</version>
</dependency>
<!--standard标签库 依赖-->
<dependency>
<groupId>taglibs</groupId>
<artifactId>standard</artifactId>
<version>1.1.2</version>
</dependency>
- EL标签：${ }
- 获取数据
- 执行运算
- 获取web开发的常用对象
调用java方法
- JSP标签
<%--jsp:include--%>
<jsp:forward page="jsptag2.jsp">
<jsp:param name="name" value="tutu"/>
<jsp:param name="age" value="18"/>
</jsp:forward>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h1>1</h1>
<%--jsp:include--%>
<%-- 相当于： http://localhost:8080/jsptag.jsp？name=tutu&age=18 （不要在forward标签里写注释，否则报500错误）--%>
<jsp:forward page="jsptag2.jsp">
<jsp:param name="name" value="tutu"/>
<jsp:param name="age" value="18"/>
</jsp:forward>
<%--<jsp:forward page="/jsptag2.jsp"></jsp:forward>--%>
<%--加“/”，从根目录，即web目录下开始找；不加“/”，代表使用相对路径，从当前目录开始找。恰好当前目录就是根目录加不加就都可以--%>
</body>
</html>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h1>2</h1>
<%--取出参数--%>
name:<%=request.getAttribute("name")%>
age:<%=request.getAttribute("age")%>
</body>
</html>
- JSTL表达式
JSTL标签库的使用就是为了弥补HTML标签的不足；他自定义了许多标签，可以供我们使用，标签的功能和Java代码一样！- 核心标签（掌握部分）
<%@ taglib prefix=“c” uri=“http://java.sun.com/jsp/jstl/core” %>
- 格式化标签
- SQL标签
- XML标签
- JSTL 函数
- 核心标签（掌握部分）
- JSTL标签库使用步骤
- 引入对应的 taglib
- 使用其中的方法
- 在Tomcat中也需要引入jstl的包，否则会报错：JSTL解析错误
c:if
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--引入JSTL标签库，我们才能使用JSTL标签 prefix="c" core--%>
<%@ 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表达式获取表单中的数据
${param.参数名}
--%>
<input type="text" name="username" value="${param.username}">
<input type="submit" value="登录">
</form>
<%--页面500报错，手动复制粘贴两个jar包到Tomcat的lib下，即可--%>
<%--判断如果提交的用户是管理员，则登录成功--%>
<%--<%--%>
<%-- if (request.getParameter("username").equals("admin")){--%>
<%-- out.print("登录成功");--%>
<%-- }--%>
<%--%>--%>
<c:if test="${param.username=='admin'}" var="isAdmin">
<c:out value="管理员欢迎您"/>
</c:if>
<c:out value="${isAdmin}"></c:out>
</body>
</html>
c:when
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ 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>=85}">
你的成绩为优秀
</c:when>
<c:when test="${score>=70}">
你的成绩为良好
</c:when>
<c:when test="${score>=60}">
你的成绩为及格
</c:when>
<c:when test="${score<60}">
你的成绩为不及格
</c:when>
</c:choose>
</body>
</html>
c:forEach
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page import="java.util.ArrayList" %><%--
Created by IntelliJ IDEA.
User: 24975
Date: 2022-09-11
Time: 23:21
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,"赵六");
people.add(4,"田七");
request.setAttribute("list",people);
// for (String person : people) {
//
// }
//
// for (int i = 0; i < people.size(); i++) {
//
// }
%>
<%--
var：每一次遍历出来的变量
items：要遍历的对象
begin：从数组下标多少开始
end：到数组下标多少结束
step：步进
--%>
<c:forEach var="people" items="${list}">
<c:out value="${people}"/><br>
</c:forEach>
<br>
<c:forEach var="people" items="${list}" begin="1" end="4" step="2">
<c:out value="${people}"/><br>
</c:forEach>
</body>
</html>
九、JavaBean
- 实体类
一般用来和数据库的字段做映射 ORM；
JavaBean有特定的写法：- 必须要有一个无参构造
- 属性必须私有化
- 必须有对应的get/set方法
- ORM：对象关系映射
- 表 --> 类
- 字段 --> 属性
- 行记录 --> 对象
- POJO：Plain Ordinary Java Object
package com.zretc.pojo;
//实体类 我们一般都是和数据库中的表结构一一对应！
public class People {
private int id;
private String name;
private int age;
private String address;
public People() {
}
public People(int id, String name, int age, String address) {
this.id = id;
this.name = name;
this.age = age;
this.address = address;
}
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 getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "People{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
", address='" + address + '\'' +
'}';
}
}
- 过滤器
- 文件上传
- 邮件发送
- JDBC复习：如何使用JDBC，JDBC crud（增删改查），JDBC事务
十、MVC三层架构
什么是MVC：Model,View,Controller 模型、视图、控制器
高内聚：高度独立性，独立性强。意思就是支持主体正常运行的各个模块相对独立，相互之间没啥关联，各司其职。比如一台电脑主机，由机箱，CPU，主板，内存，显卡，电源各种部件组成，大家各做各的事有自己的职责，互不干涉，一起支撑主机的运行。
低耦合：低量联系。就是这些部件没有很强的关系，比如我把嫌弃原来的显卡太低端，斥巨资换上了2080ti，并不会导致我的cpu.内存、主板挂掉，大家还是能和谐运行。不过低耦合不是没耦合，比如如果我的主板很垃圾，然后换了个很牛的CPU，主板带不动，电脑可能运行起来会有点问题。
1. 早些年
- 控制器：Controller（Servlet）
- 接收用户的请求
- 响应给客户端内容
- 视图跳转：重定向或者转发
- 视图层：View(JSP)
- 展示数据
- 提供可以供我们操作的请求
- 【Servlet 和 JSP 都可以写Java代码（用户访问servlet和jsp效果都差不多）；为了易于维护和使用，通常规定Servlet专注于处理请求以及控制视图跳转，JSP专注于显示数据】
- 实体层：JavaBean（pojo、entity、vo、dto…）
- 数据库
用户直接访问控制层，控制层就可以直接操作数据库；
servlet --> crud --> 数据库
弊端：程序十分臃肿，不利于维护
servlet的代码中：处理请求、响应、视图跳转、处理JDBC、处理业务代码、处理逻辑代码
|
架构：没有什么是加一层解决不了的！
|
程序员调用
|
JDBC
|
Mysql Oracle sqlserver…
2. MVC三层架构
- View（JSP）：视图层
- 展示数据模型
- 提供用户操作
- Controller（Servlet）：控制器
- 接收用户的请求
- 交给业务层去做（返回数据）
- 视图跳转
【Servlet 和 JSP 之间进行操作，转发或者重定向】
- Model：控制业务操作、保存数据、修改数据、删除数据、查询数据
- 实体层：JavaBean（pojo、entity）
- 业务层：service（login、logout、查询全部用户…）
- 数据访问层：Dao（sql）
【JDBC：Java数据库连接】
- 数据库
小结
- Model
- 业务处理：业务逻辑（Service）
- 数据持久层：CRUD（Dao）
- View
- 展示数据
- 提供链接发起Servlet请求（a、form、img…）
- Controller（Servlet）
- 接受用户的请求：（req：其你去参数、Session信息…）
- 交给业务层处理对应的代码
- 控制视图的跳转
如： 登录【视图层】
–> 接收用户的登录请求【控制层】
–> 处理用户的请求（获取用户登录的参数：username，password）【控制层】
–> 交给【业务层】处理登录业务（判断用户名、密码是否正确（【service】：事务））
–> 【Dao层】查询用户名和密码是否正确
–> 数据库
十一、Filter过滤器（重点）
（Shiro）
（架构：没有什么是加一层解决不了的）
1. Filter过滤器
Filter：过滤器，用来过滤网站的数据。web服务有一些垃圾请求，后台不应该处理，或者应该报错。（如：处理乱码问题、登录验证、脏话过滤成*号 等）
Web浏览器 --> Web服务器 --> 过滤器 --> Servlet（…）
2. Filter开发步骤：
1.导包
2.编写过滤器
2.1.导包不要错
import javax.servlet.*;
public class CharacterEncodingFilter implements Filter {}
2.2.实现Filter接口，重写对应的方法即可
package com.zretc.filter;
import javax.servlet.*;
import java.io.IOException;
public class CharacterEncodingFilter implements Filter {
//初始化：web服务器启动，就已经初始化了，随时等待过滤对象出现！
public void init(FilterConfig filterConfig) throws ServletException {
// filterConfig.getServletContext().setAttribute();
System.out.println("CharacterEncodingFilter初始化");
}
//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("CharacterEncodingFilter执行前...");
chain.doFilter(request, response);//让我们的请求继续走，如果不写，程序到这里就会被拦截停止！
System.out.println("CharacterEncodingFilter执行后...");
}
//销毁：web服务器关闭的时候，过滤器会销毁
public void destroy() {
// System.gc();
System.out.println("CharacterEncodingFilter销毁");
}
}
2.3.在web.xml中配置Filter
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<servlet>
<servlet-name>ShowServlet</servlet-name>
<servlet-class>com.zretc.servlet.ShowServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>ShowServlet</servlet-name>
<url-pattern>/servlet/show</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>ShowServlet</servlet-name>
<url-pattern>/show</url-pattern>
</servlet-mapping>
<filter>
<filter-name>CharacterEncodingFilter</filter-name>
<filter-class>com.zretc.filter.CharacterEncodingFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<url-pattern>/servlet/*</url-pattern>
</filter-mapping>
</web-app>
package com.zretc.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 ShowServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.getWriter().write("你好呀，世界！");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
十二、监听器
实现一个监听器的接口；（有n种监听器）
1.编写一个监听器
实现监听器的接口
package com.zretc.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();
System.out.println(se.getSession().getId());
Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount");
if (onlineCount==null){
onlineCount = new Integer(1);
}else {
int count = onlineCount.intValue();
onlineCount = new Integer(count+1);
}
ctx.setAttribute("OnlineCount",onlineCount);
}
//销毁session监听
//一旦销毁session就会触发一次这个事件！
public void sessionDestroyed(HttpSessionEvent se) {
ServletContext ctx = se.getSession().getServletContext();
// se.getSession().invalidate();
Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount");
if (onlineCount==null){
onlineCount = new Integer(0);
}else {
int count = onlineCount.intValue();
onlineCount = new Integer(count-1);
}
ctx.setAttribute("OnlineCount",onlineCount);
}
/*
Session销毁：
1. 手动销毁 se.getSession().invalidate();
2. 自动销毁 web.xml
<!--session自动销毁，以分钟为单位-->
<session-config>
<session-timeout>1</session-timeout>
</session-config>
*/
}
2.web.xml中注册监听器
<!--session自动销毁，以分钟为单位-->
<session-config>
<session-timeout>1</session-timeout>
</session-config>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>hello</title>
</head>
<body>
<h1>当前有<span><%=this.getServletConfig().getServletContext().getAttribute("OnlineCount")%></span>人在线</h1>
</body>
</html>
3.看情况是否使用
十三、过滤器、监听器常见应用
1. 监听器：GUI编程中经常使用
package com.zretc.listener;
import java.awt.*;
import java.awt.event.WindowAdapter;
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 WindowAdapter() {
@Override
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
// frame.addWindowListener(new WindowListener() {
//
// public void windowOpened(WindowEvent e) {
// System.out.println("打开窗口");
// }
//
// public void windowClosing(WindowEvent e) {
// System.out.println("窗口正在关闭时");
// System.exit(0);
// }
//
// public void windowClosed(WindowEvent e) {
// System.out.println("关闭窗口");
// }
//
// public void windowIconified(WindowEvent e) {
// System.out.println("窗口最小化");
// }
//
// public void windowDeiconified(WindowEvent e) {
// System.out.println("窗口从最小化中恢复");
// }
//
// public void windowActivated(WindowEvent e) {
// System.out.println("窗口被选中（激活）");
// }
//
// public void windowDeactivated(WindowEvent e) {
// System.out.println("取消窗口选中");
// }
// });
}
}
2. Filter实现权限拦截
用户登录之后才能进入主页！用户注销之后就不能进入主页了！（判断用户是否登录成功，拦截判断）
1.用户登录之后，向Session中放入用户数据
2.进入主页的时候要判断用户是否已经登录；要求：在过滤器中实现！
预登录
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%--预登录页面--%>
<h1>登录</h1>
<form action="/servlet/login" method="post">
<input type="text" name="username">
<input type="submit">
</form>
</body>
</html>
常量类，登录状态 记为 USER_SESSION
package com.zretc.util;
//常量类，通常用来放一些常量 const-ant
public class Constant {
public final static String USER_SESSION = "USER_SESSION";
}
/*
User
id
name
level
vip1
vip2
vip3
vip4
*/
登录时判断
package com.zretc.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 LoginServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//获取前端请求的参数
String username = req.getParameter("username");
if (username.equals("admin")){//登录成功
req.getSession().setAttribute("USR_SESSION",req.getSession().getId());
//req.getSession()..放到session里，可以让其他页面也获取到登录状态的值，登录状态持久化
resp.sendRedirect("/sys/success.jsp");
}else {//登录失败
resp.sendRedirect("/error.jsp");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
登录成功
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%--<%--%>
<%-- Object userSession = request.getSession().getAttribute("USER_SESSION");--%>
<%-- if (userSession==null){--%>
<%-- pageContext.forward("login.jsp");--%>
<%-- }--%>
<%--%>--%>
<%--上面这一步应该交给过滤器来做--%>
<h1>主页</h1>
<p><a href="/servlet/logout">注销</a> </p>
</body>
</html>
登录失败
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%--<%--%>
<%-- Object userSession = request.getSession().getAttribute("USER_SESSION");--%>
<%-- if (userSession==null){--%>
<%-- pageContext.forward("login.jsp");--%>
<%-- }--%>
<%--%>--%>
<%--上面这一步应该交给过滤器来做--%>
<h1>主页</h1>
<p><a href="/servlet/logout">注销</a> </p>
</body>
</html>
登出
package com.zretc.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 LogoutServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
Object usr_session = req.getSession().getAttribute("USR_SESSION");
if (usr_session!=null){
req.getSession().removeAttribute("USR_SESSION");
resp.sendRedirect("/login.jsp");
}else{
resp.sendRedirect("/login.jsp");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
权限拦截
（用常量去判断等于何值，跳转哪个页面(Constant.USER_SESSION)==null）
package com.zretc.filter;
import com.sun.deploy.net.HttpRequest;
import com.sun.deploy.net.HttpResponse;
import com.zretc.util.Constant;
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class SysFilter implements Filter {
public void init(FilterConfig filterConfig) throws ServletException {
}
public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws IOException, ServletException {
//ServletRequest -- HttpServletRequest 父 -- 子
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) resp;
if (request.getSession().getAttribute(Constant.USER_SESSION)==null){
// if (request.getSession().getAttribute("USR_SESSION")==null){
response.sendRedirect("/error.jsp");
}
chain.doFilter(req,resp);
}
public void destroy() {
}
}
例：vip权限判断
package com.zretc.filter;
import com.sun.deploy.net.HttpRequest;
import com.sun.deploy.net.HttpResponse;
import com.zretc.util.Constant;
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class SysFilter implements Filter {
public void init(FilterConfig filterConfig) throws ServletException {
}
public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws IOException, ServletException {
/*
vip权限判断
if (request.getSession().getAttribute(Constant.USER_SESSION.level)==vip1){
response.sendRedirect("/sys/vip1/index.jsp");
}
if (request.getSession().getAttribute(Constant.USER_SESSION.level)==vip2){
response.sendRedirect("/sys/vip2/index.jsp");
}
if (request.getSession().getAttribute(Constant.USER_SESSION.level)==vip3){
response.sendRedirect("/sys/vip3/index.jsp");
}
*/
chain.doFilter(req,resp);
}
public void destroy() {
}
}
xml映射配置
<servlet>
<servlet-name>LoginServlet</servlet-name>
<servlet-class>com.zretc.servlet.LoginServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>LoginServlet</servlet-name>
<url-pattern>/servlet/login</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>LogoutServlet</servlet-name>
<servlet-class>com.zretc.servlet.LogoutServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>LogoutServlet</servlet-name>
<url-pattern>/servlet/logout</url-pattern>
</servlet-mapping>
<filter>
<filter-name>SysFilter</filter-name>
<filter-class>com.zretc.filter.SysFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>SysFilter</filter-name>
<url-pattern>/sys/*</url-pattern>
</filter-mapping>
十四、JDBC
1. JDBC复习
什么是JDBC：Java数据库连接！
统一驱动JDBC（–> mysql.Driver / Oracle.Driver --> mysql / Oracle）
需要jar包的支持：
java.sql
javax.sql
mysql-connector-java 连接驱动（必须要导入）
实验环境搭建：数据库建表
CREATE TABLE users(
id int primary key,
name varchar(40),
password varchar(40),
email varchar(60),
birthday date
);
insert into users(id,name,password,email,birthday)
values(1,'张三','123456','zs@qq.com','2000-01-01')
insert into users(id,name,password,email,birthday)
values(2,'李四','123456','ls@qq.com','2000-01-01')
insert into users(id,name,password,email,birthday)
values(3,'王五','123456','ww@qq.com','2000-01-01')
导入数据库依赖
<!-- mysql 依赖 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.49</version>
</dependency>
IDEA中连接添加database
JDBC固定步骤：
- 加载驱动
- 连接数据库，代表数据库
- 向数据库发送SQL的对象Statement CRUD
- 编写SQL（根据业务，不同的SQL）
- 执行SQL，查询SQL返回一个ResultSet结果集（更新SQL操作返回int成功记录条数（受影响的行数））
- 关闭连接，释放资源（一定要做） 先开的后关
查询、删除（Statement）
package com.zretc.test;
import java.sql.*;
public class TestJdbc {
public static void main(String[] args) throws Exception{
//配置信息
String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8";
String username = "root";
String password = "123456";
String driver = "com.mysql.jdbc.Driver";
//1. 加载驱动
Class.forName(driver);
//2. 连接数据库，代表数据库
Connection connection = DriverManager.getConnection(url, username, password);
//3. 向数据库发送SQL的对象Statement CRUD
Statement statement = connection.createStatement();
//4. 编写SQL
String sql = "select * from users";
//5. 执行查询SQL，返回一个ResultSet结果集（更新操作返回int）
ResultSet resultSet = statement.executeQuery(sql);
//安全的预编译
// PreparedStatement preparedStatement = connection.prepareStatement(sql);
// ResultSet resultSet = preparedStatement.executeQuery();
//增删改 1
// String sql = "delete from users where id = 4";
// //受影响的行数，增删改都是用executeUpdate即可
// int i = statement.executeUpdate(sql);
//增删改 2
// String sql = "delete from users where id = 4";
// PreparedStatement preparedStatement = connection.prepareStatement(sql);
// int i = preparedStatement.executeUpdate(sql);
// 循环输出结果集
while (resultSet.next()){
System.out.println("id="+resultSet.getObject("id"));
System.out.println("name="+resultSet.getObject("name"));
System.out.println("password="+resultSet.getObject("password"));
System.out.println("email="+resultSet.getObject("email"));
System.out.println("birthday="+resultSet.getObject("birthday"));
System.out.println("================");
}
//6. 关闭连接，释放资源（一定要做） 先开的后关
if (resultSet!=null) {
resultSet.close();
}
if (statement!=null) {
statement.close();
}
if (connection!=null) {
connection.close();
}
}
}
增加（PreparedStatement 预编译SQL）
package com.zretc.test;
import java.sql.*;
import java.sql.Date;
import java.text.SimpleDateFormat;
public class TestJdbc2 {
public static void main(String[] args) throws Exception{
//配置信息
String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8";
String username = "root";
String password = "123456";
String driver = "com.mysql.jdbc.Driver";
//1. 加载驱动
Class.forName(driver);
//2. 连接数据库，代表数据库
Connection connection = DriverManager.getConnection(url, username, password);
//3. 编写SQL
String sql = "insert into users(id, name, password, email, birthday) VALUES (?,?,?,?,?)";
//4. 预编译
PreparedStatement preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1,0);//给第1个占位符？的值赋值为1
// 不能赋值为已有id值，会报错键值冲突。可以改为id自动递增，且值赋值为0。或者赋值为未有的id值
preparedStatement.setString(2,"兔兔");//给第2个占位符？的值赋值为
preparedStatement.setString(3,"123456");//给第3个占位符？的值赋值为
preparedStatement.setString(4,"tt@qq.com");//给第4个占位符？的值赋值为
// preparedStatement.setString(5,"2002-03-20");//给第5个占位符？的值赋值为
// new SimpleDateFormat().format(new Date())
// new Date(new java.util.Date().getTime())
// new Date(System.currentTimeMillis())
preparedStatement.setDate(5,new Date(new java.util.Date().getTime()));//给第5个占位符？的值赋值为
//5. 执行SQL
int i = preparedStatement.executeUpdate();
// 更新操作没有结果集
// ResultSet resultSet = preparedStatement.executeQuery();
if (i>0){
System.out.println("插入成功");
}else{
System.out.println("插入失败");
}
//6. 关闭连接，释放资源（一定要做） 先开的后关
if (preparedStatement!=null){
preparedStatement.close();
}
if (connection!=null) {
connection.close();
}
}
}
2. JDBC事务
要么都成功，要么都失败！
- ACID原则：保证数据的安全
- 原子性（Atomicity）
- 一致性（Consistency）
- 独立性（隔离性）（Isolation）
- 持久性（Durability）
- 事务
- 开启事务
- 事务提交 commit（）
- 事务回滚 rollback（）
- 关闭事务
junit单元测试
<!-- junit单元测试 加个@Test 利用注解、反射 测试方法-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
</dependency>
简单使用
@Test注解只有在方法上有效，只要加了这个注解的方法，就可以直接运行！
package com.zretc.test;
import org.junit.Test;
public class TestJdbc3 {
@Test
public void testMethod(){
System.out.println("testMethod");
}
}
例：银行事务
IDEA的数据库命令行操作
start transaction ;#开启事务
update account set money = money-100 where name = 'A';
update account set money = money+100 where name = 'B';
# rollback ;
commit ;
代码实现
package com.zretc.test;
import org.junit.Test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class TestJdbc3 {
@Test
public void test() {
//配置信息
String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8";
String username = "root";
String password = "123456";
String driver = "com.mysql.jdbc.Driver";
Connection connection = null;
try {
//1. 加载驱动
Class.forName(driver);
//2. 连接数据库，代表数据库
connection = DriverManager.getConnection(url, username, password);
//3. 通知数据库开启事务 false 开启 true 关闭
connection.setAutoCommit(false);
// 编写sql，并且执行
String sql = "update account set money = money-100 where name = 'A'";
connection.prepareStatement(sql).executeUpdate();
//制造错误
// int i = 1/0;
String sql2 = "update account set money = money+100 where name = 'B'";
connection.prepareStatement(sql2).executeUpdate();
connection.commit();//以上两条SQL都执行成功了，就提交事务！
System.out.println("success");
}catch (Exception e){
try {
//如果出现异常，就通知数据库回滚事务
connection.rollback();
}catch (SQLException e1) {
e1.printStackTrace();
}
e.printStackTrace();
}finally {
if (connection!=null){
try {
connection.close();
} catch (SQLException e2) {
e2.printStackTrace();
}
}
}
}
@Test
public void testMethod(){
System.out.println("testMethod");
}
}
十五、 SMBMS 超市订单管理系统
1. smbms项目搭建
2. smbms登陆流程实现
3. smbms注销及权限过滤
4. smbms密码修改实现
5. Ajax验证旧密码实现
6. smbms用户管理底层实现
7. smbms用户管理分页OK
8. smbms架构分析及方法学习
十六、文件
1. 文件传输原理
- 创建项目
- 创建一个新项目，JDK建议1.8或以上
- 添加框架支持，新版IDEA需要手动导入Web框架
- 然后选择Web Application
- 导入jar包
commons-fileupload-1.4.jar
commons-io-2.6.jar
- 文件上传注意事项
- 为保证服务器安全，上传文件应该放在外界无法直接访问的目录下，比如放于WEB-INF目录下
- 为防止文件覆盖的现象发生，要为上传文件产生一个唯一的文件名（文件名 时间戳 uuid md5等）
- 要限制上传文件的最大值
- 可以限制上传文件的类型，在收到上传文件名时，判断后缀是否合法
2. 文件上传
1、index.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>$Title$</title>
</head>
<body>
<form action="${pageContext.request.contextPath}/upload.do" enctype="multipart/form-data" method="post">
上传用户：<input type="text" name="username"><br/>
<p><input type="file" name="file1"></p>
<p><input type="file" name="file2"></p>
<p><input type="submit"> | <input type="reset"></p>
</form>
</body>
</html>
2、FileServlet
方法一：项目结构勾选
pom.xml
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.4</version>
</dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.6</version>
</dependency>
<!-- servlet依赖的jar包start -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
</dependency>
<!-- servlet依赖的jar包start -->
<!-- jsp依赖jar包start -->
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>javax.servlet.jsp-api</artifactId>
<version>2.3.1</version>
</dependency>
<!-- jsp依赖jar包end -->
<!--jstl标签依赖的jar包start -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<!--jstl标签依赖的jar包end -->
或
方法二：lib库 √
package com.qia.servlet;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.ProgressListener;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.UUID;
public class FileServlet extends HttpServlet {
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException, IOException {
//判断上传的文件时普通表单还是带文件的表单
if (!ServletFileUpload.isMultipartContent(request)) {
return;//终止方法运行，说明这是一个普通的表单，直接返回
}
//创建上传文件的保存路径，建议在WEB-INF路径下，安全，用户无法直接访问上传的文件
String uploadPath = this.getServletContext().getRealPath("/WEB-INF/upload");
File uploadFile = new File(uploadPath);
if (!uploadFile.exists()) {
uploadFile.mkdir();//创建这个目录
}
//缓存，临时文件
//临时路径，假如文件超过了预期的大小，我们就把它放到一个临时文件中，过几天自动删除，或者提醒用户自动转存为永久
String tempPath = this.getServletContext().getRealPath("/WEB-INF/tmp");
File tempFile = new File(tempPath);
if (!tempFile.exists()) {
tempFile.mkdir();//创建这个临时目录
}
//处理上传的文件，一般都需要通过流来获取，我们可以使用request.getInputStream()，原生态的文件上传流来获取，十分麻烦
//但是我们都建议使用Apache的文件上传组件来实现，common-fileupload，它需要依赖于common-io组件
/*
ServletFileUpload负责处理上传的文件数据，并将表单中每个输入项封装成一个FileItem对象
，在使用ServletFileUpload对象解析请求时，需要DiskFileItemFactory对象。
所以，我们需要在进行解析工作前构造好DiskFileItemFactory对象，
通过ServletFileUpload对象的构造方法，或setFileItemFactory()方法，设置ServletFileUpload对象的fileItemFactory属性
*/
//1.创建DiskFileItemFactory对象，处理文件上传路径或者大小限制的
DiskFileItemFactory factory = createDiskFileItemFactory(tempFile);
//2.获取ServletFileUpload
ServletFileUpload upload = creatServletFileUpload(factory);
//3.处理上传的文件
String msg = uploadFile(request, uploadPath, upload);
//转发
request.setAttribute("msg", msg);
request.getRequestDispatcher("/info.jsp").forward(request, response);
}
// 3. 处理上传的文件
private String uploadFile(HttpServletRequest request, String uploadPath, ServletFileUpload upload) throws IOException {
String msg = "";
//把前端请求解析，封装成一个FileItem对象，需要从ServletFileUpload对象中获取
try {
List<FileItem> fileItems = upload.parseRequest(request);
for (FileItem fileItem : fileItems) {
//判断表单的前端控件是否是普通控件还是文件控件
if (fileItem.isFormField()) {
String fieldName = fileItem.getFieldName();
//处理乱码
String value = fileItem.getString("UTF-8");
System.out.println(fieldName + ":" + value);
} else {
//文件
//===========处理文件============
String uploadFileName = fileItem.getName();
System.out.println("uploadFileName:" + uploadFileName);
//可能存在文件名不合法的情况
if (uploadFileName == null || "".equals(uploadFileName.trim())) {
continue;
}
//获取上传的文件名
String fileName = uploadFileName.substring(uploadFileName.lastIndexOf("/") + 1);
//获取文件的后缀名
String fileExtName = uploadFileName.substring(uploadFileName.lastIndexOf(".") + 1);
//如果文件后缀名fileExtName不是我们所需要的，就直接return,不处理，告诉用户文件类型不对
//可以使用UUID（统一识别的通用码），保证文件名唯一
//UUID.randomUUID() 随机生一个唯一识别的通用码
//网络从传输中的东西，都需要序列化
//implements java.io.Serializable 标记接口 本地方法栈--》C++
String uuidPath = UUID.randomUUID().toString();
//===========存放地址============
String realPath = uploadPath + "/" + uuidPath;
File realPathFile = new File(realPath);
if (!realPathFile.exists()) {
realPathFile.mkdir();
}
//===========文件传输============
InputStream inputStream = fileItem.getInputStream();
FileOutputStream fos = new FileOutputStream(realPath + "/" + fileName);
byte[] buffer = new byte[1024 * 1024];
int len = 0;
while ((len = inputStream.read(buffer)) > 0) {
fos.write(buffer, 0, len);
}
fos.close();
inputStream.close();
msg = "上传成功~";
}
}
} catch (FileUploadException e) {
e.printStackTrace();
msg = "上传失败~";
}
return msg;
}
// 2. 获取ServletFileUpload
private ServletFileUpload creatServletFileUpload(DiskFileItemFactory factory) {
ServletFileUpload upload = new ServletFileUpload(factory);
//监听文件上传进度：
upload.setProgressListener(new ProgressListener() {
@Override
public void update(long pBytesRead, long pContentLength, int pItems) {
//pBytesRead 已经读取到的文件大小
//pContentLength 文件总大小
System.out.println("总大小：" + pContentLength + " -- 已上传：" + String.format("%.2f",(pBytesRead * 100.0 / pContentLength)) + "%");
//java如何保留小数点后两位
//推荐：用format方法,语法“String.format("%.2f",数值)”;
}
});
//处理乱码问题
upload.setHeaderEncoding("UTF-8");
//设置单个能够上传的文件的最大值
upload.setFileSizeMax(1024 * 1024 * 10);
//设置总共能够上传的文件的最大值
upload.setSizeMax(1024 * 1024 * 10);
return upload;
}
// 1. 创建DiskFileItemFactory对象，处理文件上传路径或者大小限制的
private DiskFileItemFactory createDiskFileItemFactory(File tempFile) {
DiskFileItemFactory factory = new DiskFileItemFactory();
//通过这个工厂设置一个缓冲区，当上传的文件大于这个缓冲区的时候，将它放到临时文件中
factory.setSizeThreshold(1024 * 1024);
//缓存区大小为1M
factory.setRepository(tempFile);
//临时目录的保存目录，需要一个File
return factory;
}
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
}
}
TestThread
package com.qia.servlet;
import java.util.UUID;
public class TestThread {
public static void main(String[] args) {
// String uuidPath = UUID.randomUUID().toString();
// String uuidPath2 = UUID.randomUUID().toString();
// String uuidPath3 = UUID.randomUUID().toString();
// String uuidPath4 = UUID.randomUUID().toString();
// System.out.println(uuidPath);
// System.out.println(uuidPath2);
// System.out.println(uuidPath3);
// System.out.println(uuidPath4);
float f = 0.1f;
double d = 1.0/10;
double d2 = 1.0/10;
System.out.println(f);
System.out.println(d);
System.out.println(d2);
System.out.println(f == d);
}
}
3、web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<servlet>
<servlet-name>FileServlet</servlet-name>
<servlet-class>com.qia.servlet.FileServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>FileServlet</servlet-name>
<url-pattern>/upload.do</url-pattern>
</servlet-mapping>
</web-app>
4、info.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
${msg}
</body>
</html>
5、成功
十七、邮件
1. 邮件发送原理及实现
1、邮件发送原理
2、实现
package com.qia;
public class Test {
//简单邮件： 没有附件和图片，纯文本邮件
//复杂邮件：有附件和图片
//要发送邮件：需要获得协议和支持！开启服务POP3/SMTP服务
//授权码：
}
package com.qia;
import com.sun.mail.util.MailSSLSocketFactory;
import javax.mail.Authenticator;
import javax.mail.Message;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import java.util.Properties;
//发送一个简单邮件
public class MailDemo01 {
public static void main(String[] args) throws Exception {
Properties properties = new Properties();
//设置QQ邮件服务器
properties.setProperty("mail.host", "smtp.qq.com");
//邮件发送协议
properties.setProperty("mail.transport.protocol", "smtp");
//需要验证用户名密码
properties.setProperty("mail.smtp.auth", "true");
//关于QQ邮箱，还需要设置SSL加密，加上以下以下代码即可
MailSSLSocketFactory sf = new MailSSLSocketFactory();
sf.setTrustAllHosts(true);
properties.put("mail.smtp.ssl.enable", "true");
properties.put("mail.smtp.ssl.socketFactory", sf);
//使用javaMail发送邮件的5个步骤
//1.创建定义整个应用程序所需的环境信息的Session对象
Session session = Session.getDefaultInstance(properties, new Authenticator() {
@Override
protected PasswordAuthentication getPasswordAuthentication() {
//发件人邮件用户名、授权码
return new PasswordAuthentication("2497502815@qq.com", "授权码");
}
});
//--开启debug模式，这样就可以查看到程序发送email的运行状态
session.setDebug(true);
//2.通过session得到transport对象
Transport ts = session.getTransport();
//3.使用邮箱的用户名和授权码连上邮件服务器
ts.connect("smtp.qq.com", "2497502815@qq.com", "授权码");
//4.创建邮件
MimeMessage message = new MimeMessage(session);
//--邮件的发件人
message.setFrom(new InternetAddress("2497502815@qq.com"));
//--邮件的收件人
message.setRecipient(Message.RecipientType.TO, new InternetAddress("2497502815@qq.com"));
//--邮件的标题
message.setSubject("hello");
//--邮件的文本内容
message.setContent("<h1 style='color: red'>你好啊</h1>", "text/html;charset=UTF-8");
//5.发送邮件
ts.sendMessage(message, message.getAllRecipients());
//6.关闭连接
ts.close();
}
}
package com.qia;
import com.sun.mail.util.MailSSLSocketFactory;
import javax.activation.DataHandler;
import javax.activation.FileDataSource;
import javax.mail.Authenticator;
import javax.mail.Message;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;
import java.util.Properties;
public class MailDemo02 {
public static void main(String[] args) throws Exception {
Properties properties = new Properties();
//设置QQ邮件服务器
properties.setProperty("mail.host", "smtp.qq.com");
//邮件发送协议
properties.setProperty("mail.transport.protocol", "smtp");
//需要验证用户名密码
properties.setProperty("mail.smtp.auth", "true");
//关于QQ邮箱，还需要设置SSL加密，加上以下以下代码即可
MailSSLSocketFactory sf = new MailSSLSocketFactory();
sf.setTrustAllHosts(true);
properties.put("mail.smtp.ssl.enable", "true");
properties.put("mail.smtp.ssl.socketFactory", sf);
//使用javaMail发送邮件的5个步骤
//1.创建定义整个应用程序所需的环境信息的Session对象
Session session = Session.getDefaultInstance(properties, new Authenticator() {
@Override
protected PasswordAuthentication getPasswordAuthentication() {
//发件人邮件用户名、授权码
return new PasswordAuthentication("2497502815@qq.com", "授权码");
}
});
//--开启debug模式，这样就可以查看到程序发送email的运行状态
session.setDebug(true);
//2.通过session得到transport对象
Transport ts = session.getTransport();
//3.使用邮箱的用户名和授权码连上邮件服务器
ts.connect("smtp.qq.com", "2497502815@qq.com", "授权码");
//4.创建邮件
MimeMessage message = new MimeMessage(session);
//--邮件的发件人
message.setFrom(new InternetAddress("2497502815@qq.com"));
//--邮件的收件人
message.setRecipient(Message.RecipientType.TO, new InternetAddress("2497502815@qq.com"));
//--邮件的标题
message.setSubject("hello");
//》》》》》》》》》》《《《《《《《《《
//图片
MimeBodyPart image = new MimeBodyPart();
//图片需要数据处理 DataHandler
DataHandler dh = new DataHandler(new FileDataSource("src/resources/bg.jpg"));
image.setDataHandler(dh);
//给图片设置一个id
image.setContentID("bg.jpg");
//文本
MimeBodyPart text = new MimeBodyPart();
text.setContent("这是一封邮件带图片<img src='cid:bg.jpg'/>的邮件","text/html;charset=UTF-8");
//整合
MimeMultipart mm = new MimeMultipart();
mm.addBodyPart(text);
mm.addBodyPart(image);
mm.setSubType("related");
//放到消息中，保存修改
message.setContent(mm);
message.saveChanges();
//5.发送邮件
ts.sendMessage(message, message.getAllRecipients());
//6.关闭连接
ts.close();
}
}
2. 网站注册发送邮件实现
1、index.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>注册</title>
</head>
<body>
<form action="${pageContext.request.contextPath}/registerServlet.do" method="post">
用户名：<input type="text" name="userName"/><br/>
密码：<input type="password" name="password"/><br/>
邮箱：<input type="text" name="email"/><br/>
<input type="submit" value="注册"/>
</form>
</body>
</html>
2、pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<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>
<groupId>com.qia</groupId>
<artifactId>WebMail</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
<name>WebMail 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>
<dependency>
<groupId>javax.mail</groupId>
<artifactId>mail</artifactId>
<version>1.4.7</version>
</dependency>
<dependency>
<groupId>javax.activation</groupId>
<artifactId>activation</artifactId>
<version>1.1.1</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.1</version>
</dependency>
</dependencies>
</project>
3、POJO：User
package com.qia.pojo;
import java.io.Serializable;
public class User implements Serializable {
private String userName;
private String password;
private String email;
public User() {
}
public User(String userName, String password, String email) {
this.userName = userName;
this.password = password;
this.email = email;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
@Override
public String toString() {
return "User{" +
"userName='" + userName + '\'' +
", password='" + password + '\'' +
", email='" + email + '\'' +
'}';
}
}
4、Util：SendMail
网站3秒原则：用户体验
多线程实现用户体验！（异步处理）
package com.qia.util;
import com.sun.mail.util.MailSSLSocketFactory;
import com.qia.pojo.User;
import javax.mail.Authenticator;
import javax.mail.Message;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import java.util.Properties;
//网站3秒原则：用户体验
//多线程实现用户体验！（异步处理）
public class SendMail extends Thread {
private String from = "2497502815@qq.com";
private String userName = "2497502815@qq.com";
private String password = "授权码";
private String host = "smtp.qq.com";
private User user;
public SendMail(User user) {
this.user = user;
}
@Override
public void run() {
try {
Properties properties = new Properties();
//设置QQ邮件服务器
properties.setProperty("mail.host", host);
//邮件发送协议
properties.setProperty("mail.transport.protocol", "smtp");
//需要验证用户名密码
properties.setProperty("mail.smtp.auth", "true");
//关于QQ邮箱，还需要设置SSL加密，加上以下以下代码即可
MailSSLSocketFactory sf = new MailSSLSocketFactory();
sf.setTrustAllHosts(true);
properties.put("mail.smtp.ssl.enable", "true");
properties.put("mail.smtp.ssl.socketFactory", sf);
//使用javaMail发送邮件的5个步骤
//1.创建定义整个应用程序所需的环境信息的Session对象
Session session = Session.getDefaultInstance(properties, new Authenticator() {
@Override
protected PasswordAuthentication getPasswordAuthentication() {
//发件人邮件用户名、授权码
return new PasswordAuthentication(from, password);
}
});
//--开启debug模式，这样就可以查看到程序发送email的运行状态
session.setDebug(true);
//2.通过session得到transport对象
Transport ts = session.getTransport();
//3.使用邮箱的用户名和授权码连上邮件服务器
ts.connect(host, from, password);
//4.创建邮件
MimeMessage message = new MimeMessage(session);
//--邮件的发件人
message.setFrom(new InternetAddress(userName));
//--邮件的收件人
message.setRecipient(Message.RecipientType.TO, new InternetAddress(userName));
//--邮件的标题
message.setSubject("hello");
//--邮件的文本内容
message.setContent("<h1 style='color: red'>你好啊</h1>", "text/html;charset=UTF-8");
//5.发送邮件
ts.sendMessage(message, message.getAllRecipients());
//6.关闭连接
ts.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
5、RegisterServlet
package com.qia.servlet;
import com.qia.pojo.User;
import com.qia.util.SendMail;
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 RegisterServlet extends HttpServlet {
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//接受用户请求，封装成对象
String userName = request.getParameter("userName");
String password = request.getParameter("password");
String email = request.getParameter("email");
User user = new User(userName, password, email);
SendMail sendMail = new SendMail(user);
sendMail.run();
request.setAttribute("message", "发送成功");
request.getRequestDispatcher("info.jsp").forward(request, response);
}
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
}
}
6、web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<servlet-mapping>
<servlet-name>registerServlet</servlet-name>
<url-pattern>/registerServlet.do</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>registerServlet</servlet-name>
<servlet-class>com.qia.servlet.RegisterServlet</servlet-class>
</servlet>
</web-app>
7、info.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
${message}
</body>
</html>
3. 网站注册发送邮件Spring版
Spring
自动化装配
…
之后 该怎么持续学习
SSM框架
Linux
SpringBoot
SpringCloud
Hadoop
扫一扫
515
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
