JavaWeb基础入门到上手项目
文章目录
-
- 1、基本概念
-
- 1.1、前言
- 1.2、web应用程序
- 1.3、静态web
- 1.4、动态web
- 2、web服务器
-
- 2.1、技术讲解
- 2.2、web服务器
- 3、Tomcat
-
- 3.1、安装Tomcat
- 3.2、Tomcat启动和配置
- 3.3、配置
- 3.4、发布一个web网站
- 4、HTTP
-
- 4.1、什么是HTTP
- 4.2、两个时代
- 4.3、HTTP请求
- 4.4、HTTP响应
- 5、Maven
-
- 5.1、Maven项目架构管理工具
- 5.2、下载安装Maven
- 5.3、配置环境变量
- 5.4、阿里云镜像
- 5.5、本地仓库
- 5.6、在IDEA中使用Maven
- 5.7、创建一个普通maven项目
- 5.8、标记文件夹功能
- 5.9、在idea中配置Tomcat
- 5.10、pom文件
- 5.11、Maven仓库的使用
- 常见的问题
- 6、Servlet
-
- 6.1、Servlet简介
- 6.2、HelloServlet
- 6.3、Servlet原理
- 6.4、Mapping
- 6.5、ServletContext
-
- 1、共享数据
- 2、获取初始化参数
- 3、请求转发
- 4、读取资源文件
- 6.6、HttpServletResponse
-
- 1、简单分类
- 2、常见应用
-
- 1.向浏览器输出消息
- 2.下载文件
- 3.验证码功能
- 6.7、HttpServletRequest
- 7、Cookie、Session
-
- 7.1、会话
- 7.2、保存会话的两种技术
-
- 7.2.1、cookie
- 7.2.2、session
- 7.3、Cookie
-
- 7.3.1、用代码实现保存用户上一次访问的时间
- 7.3.2、删除cookie:
- 7.3.3、中文传输数据乱码问题
- 7.4、Session（重点）
-
- 7.4.1、Session的概念
- 7.4.2、具体使用session
- 8、JSP
-
- 8.1、什么是JSP
- 8.2、JSP原理
- 8.3、JSP基础语法
-
- **JSP表达式**
- **JSP脚本片段**
- **脚本片段的再实现**
- **JSP声明**
- 8.4、JSP指令
- 8.5、九大内置对象
- 8.6、JSP标签、JSTL标签、EL表达式
- 9、JavaBean
- 10、三层架构
-
- 10.1、早期开发
- 10.2、MVC三层架构
- 11、Filter（重点）
- 12、监听器
- 13、过滤器、监听器常见应用
- 14、JDBC
- 15、事务
- 16、SMBMS项目
- 17、文件上传
-
- 使用类介绍
##前言
- Java Web 其实就是一个技术的总和,把Web看成一个容器而已主要使用JavaEE技术来实现.在加上各种中间件。
- 整个javaWeb阶段的内容通过实际的案例贯穿学习， 所涉及到的技术知识点会在案例中根据不同的需求引入。
- 首先了解javaWEB的整个技术体系，掌握常用的技术知识点。
注：本篇博客是基于B站遇见狂神说的JavaWeb讲解视频进行编写，如有遗漏和错误欢迎指出，原视频地址为【狂神说Java】JavaWeb入门到实战，大家记得三连啊✧(≖ ◡ ≖✿)
下面我们进入正题！
1、基本概念
1.1、前言
web开发：
- web,网页的意思
- 静态web
- html,css
- 提供给所有人看的数据始终不会变化
- 动态web
- 淘宝，几乎所有的网站
- 提供给所有人看的数据始终会变化，每个人在不同时间不同地点看到的信息各不相同
- 技术栈：Servlet/JSP,ASP,PHP
在Java中，动态web资源开发的技术统称为JavaWeb
1.2、web应用程序
web应用程序：可以提供浏览器访问的程序
-
a.html b.html…多个web资源，这些web资源可以被外界访问，对外界提供服务
-
我们能访问到的任何一个页面或者资源，都存在于这个世界上的某一个角落的计算机上
-
URL
-
这些统一的web资源会被放在同一个文件夹下，web应用程序---->Tomcat：服务器
-
一个web应用由多部分组成（静态web 动态web）
- html，css，js
- jsp,servlet
- java程序
- jar包
- 配置文件
web应用程序编写完毕后，若想提供给外界访问，需要一个服务器来统一管理
1.3、静态web
- *.html, *.html,这些都是网页的后缀，如果服务器上一直存在这些东西，我们就可以直接进行读取
- 静态web存在的缺点
- web页面无法动态更新，所有用户看到的都是同一个页面
- 轮播图，点击特效：伪动态
- JavaScript（实际开发中使用最多）
- VBScript
- 它无法和数据库交互（数据无法持久化，用户无法交互）
- web页面无法动态更新，所有用户看到的都是同一个页面
1.4、动态web
页面会动态展示：web的页面展示的效果因人而异（不同的人打开的页面是不一样的）
缺点
- 加入服务器的动态web资源出现了错误，我们需要重新编写我们的后台程序，重新发布(停机维护)
优点
- web页面可以动态更新，所有用户看到的都不是同一个页面
- 它可以和数据库交互（数据持久化：注册，用户信息）
2、web服务器
2.1、技术讲解
ASP：
- 微软：国内最早流行的就是ASP
- 在html中嵌入了VB的脚本，ASP+DOM
- 在ASP开发中，基本一个页面都有几千行的业务代码，页面极其混乱
- 维护成本高
- C#
PHP：
- 开发速度很快，功能很强大，跨平台，代码简单
- 无法承载大访问量的情况（局限性）
JSP/Servlet：
- sun公司主推的B/S架构
- 基于Java语言
- 可以承载高并发，高可用，高性能带来的影响
- 语法像ASP
2.2、web服务器
服务器是一种被动的操作，用来处理用户的一些请求和给用户一些响应信息
IIS：
- 微软
- ASP
- Windows中自带的
Tomcat
Tomcat是Apache 软件基金会（Apache Software Foundation）的Jakarta 项目中的一个核心项目，最新的Servlet 和JSP 规范总是能在Tomcat 中得到体现，Tomcat 5支持最新的Servlet 2.4 和JSP 2.0 规范。因为Tomcat 技术先进、性能稳定，而且免费，因而深受Java 爱好者的喜爱并得到了部分软件开发商的认可，成为比较流行的Web 应用服务器。
Tomcat 服务器是一个免费的开放源代码的Web 应用服务器，属于轻量级应用服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP 程序的首选。对于一个初学者来说，他是最佳选择
Tomcat 实际上运行JSP 页面和Servlet。另外，Tomcat和IIS等Web服务器一样，具有处理HTML页面的功能。
下载Tomcat：
- 安装/解压
- 了解配置文件及目录结构
- 作用
3、Tomcat
3.1、安装Tomcat
在安装之前给大家提一个建议，我在学习新知识的过程中经常会到软件版本不匹配报错的问题，而且经常卸载安装好几次也不成功，
所以建议大家在安装之前先去查看以下版本匹配的问题（不是最新的版本就是最好的），我在这里使用是Tomcat9
具体的下载流程大家可以参考以下博客，tomcat安装及配置教程（保姆级）_爱你的阿白~的博客-CSDN博客_tomcat安装及配置教程
3.2、Tomcat启动和配置
文件夹作用：
启动，关闭Tomcat：
可能遇到的问题：
- Java环境变量没有配置
- 闪退问题：需要配置兼容性
- 乱码问题：配置文件中设置
3.3、配置
可以配置启动的端口号
- Tomcat默认端口号为8080
- Mysql：3306
- http：80
- https:443
可以配置主机的名称
- 默认的主机名为：localhost->127.0.0.1
- 默认网站应用存放的位置为：webapps
思考问题
网站是如何进行访问的：
- 输入一个域名：回车
- 检查本机的hosts配置文件下有没有这个域名映射
- 有—>直接返对应的IP地址，这个地址中有我们需要访问的web程序，可以直接访问
- 没有—>去DNS服务器寻找（找到就返回，找不到就返回找不到）
3.4、发布一个web网站
- 将自己写的网站放到服务器（Tomcat）指定的webapp的文件夹下，就可以访问了
网站应该有的结构：
--webapps : Tomcat服务器的web目录
--ROOT
--Qstudy : 网站的目录名
--index.html : 默认的首页
--static
--css
--js
--img
--...
--WEB-INF
--classes : java程序
--lib : web应用所依赖的jar包
--web.xml : 网站的配置文件
4、HTTP
4.1、什么是HTTP
超文本传输协议（Hyper Text Transfer Protocol，HTTP）是一个简单的请求-响应协议，它通常运行在TCP之上。
http端口:80 https端口:443 (s代表安全)
- 文本：html，字符串，…
- 超文本：图片，音乐，视频，定位，地图…
4.2、两个时代
- http1.0
- HTTP/1.0:客户端可以与Web服务器连街沟，只获得一个web资源，断开连接
- http2.0
- HTTP/1.1:客户端可以与Web服务器连街沟，可以获得多个web资源
4.3、HTTP请求
-
客户端------发请求（request）-----服务器
Request URL: https://www.baidu.com/ //请求地址（以百度为例） Request Method: GET //GET/POST方法 Status Code: 200 OK //状态码：200代表OK 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.9 Accept-Encoding: gzip, deflate, br Accept-Language: zh-CN,zh;q=0.9//语言 Cache-Control: max-age=0 Connection: keep-alive -
请求行
-
消息头
Accept: //告诉浏览器它所支持的数据类型 Accept-Encoding: //支持哪种编码格式 GBK UTF-8 GB2312 ISO8859-1 Accept-Language: //告诉浏览器他的语言环境 Cache-Control: //缓存控制 Connection: //告诉浏览器，请求完是断开还是保持连接 HOET: //主机
4.4、HTTP响应
- 服务器-----响应（response）-----客户端
Cache-Control: private // 缓存控制
Connection: keep-alive // 连接
Content-Encoding: gzip // 编码
Content-Type: text/html;charset=utf-8 // 类型
- 响应体
Accept: //告诉浏览器它所支持的数据类型
Accept-Encoding: //支持哪种编码格式 GBK UTF-8 GB2312 ISO8859-1
Accept-Language: //告诉浏览器他的语言环境
Cache-Control: //缓存控制
Connection: //告诉浏览器，请求完是断开还是保持连接
HOET: //主机
REFRESH: //告诉客户端多久刷新一次
Location: //让网页重新定位
-
响应头
200：请求响应成功
202：接受
3**：
- 重定向：你重新到我给你的新位置去
400：错误的请求
404：找不到资源
5**：服务器代码错误（502网关错误）
5、Maven
- 在JAvaweb开发中，需要使用大量的jar包，我们需要手动导入
- 如何能够让一个东西自动帮我们导入和配置这个jar包
5.1、Maven项目架构管理工具
我们目前用来就是方便导入jar包的
Maven的核心思想：约定大于配置
- 有约束不要去违反
Maven会规定好你该如何去编写我们的Java代码，必须要按照规范
5.2、下载安装Maven
具体下载步骤大家可以参考这篇博客maven安装及配置（详细版）
这里尤其要注意Maven版本与IDEA版本对应的问题
官网;https://maven.apache.org/
这里我保存的位置是：E:\JavaBackend\Maven\apache-maven-3.5.2
5.3、配置环境变量
在我们的系统环境变量中
配置如下配置：
- M2_HOME maven目录下的bin目录
- MAVEN_HOME maven的目录
- 在系统的path中配置%MAVEN_HOME%\bin
测试是否安装成功
5.4、阿里云镜像
- 镜像：mirrors，可以加速我们的下载
setting.xml配置文件位置
<mirror>
<id>nexus-aliyunid>
<mirrorOf>centralmirrorOf>
<name>Nexus aliyunname>
<url>http://maven.aliyun.com/nexus/content/groups/publicurl>
mirror>
5.5、本地仓库
本地仓库 localRepository，远程仓库
建立一个仓库：
- 原来的地址：
C:\Users\86134\.m2\repository
- 修改后的地址：
<localRepository>E:/JavaBackend/Maven/apache-maven-3.5.2/maven_repositorylocalRepository>
5.6、在IDEA中使用Maven
-
启动IDEA
-
创建一个Mavenweb项目
3.等待项目初始化完毕
4.观察maven仓库中多了哪些东西
5.idea中的maven设置（idea中经常使用自带的maven，需要手动修改，退出项目在最开始的页面可以修改默认设置）
5.7、创建一个普通maven项目
5.8、标记文件夹功能
（1）
（2）
5.9、在idea中配置Tomcat
（1）
（2）
（3）警告问题：我们访问一个网站的时候，需要指定一个文件夹名字
（4）启动测试
5.10、pom文件
pom.xml是maven的核心配置文件
pom.xml
<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.0modelVersion>
<groupId>org.examplegroupId>
<artifactId>Javaweb-01-mavenartifactId>
<version>1.0-SNAPSHOTversion>
<packaging>warpackaging>
<name>Javaweb-01-maven Maven Webappname>
<url>http://www.example.comurl>
<properties>
<project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
<maven.compiler.source>1.7maven.compiler.source>
<maven.compiler.target>1.7maven.compiler.target>
properties>
<dependencies>
<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
<version>4.11version>
<scope>testscope>
dependency>
dependencies>
<build>
<finalName>Javaweb-01-mavenfinalName>
<pluginManagement>
<plugins>
<plugin>
<artifactId>maven-clean-pluginartifactId>
<version>3.1.0version>
plugin>
<plugin>
<artifactId>maven-resources-pluginartifactId>
<version>3.0.2version>
plugin>
<plugin>
<artifactId>maven-compiler-pluginartifactId>
<version>3.8.0version>
plugin>
<plugin>
<artifactId>maven-surefire-pluginartifactId>
<version>2.22.1version>
plugin>
<plugin>
<artifactId>maven-war-pluginartifactId>
<version>3.2.2version>
plugin>
<plugin>
<artifactId>maven-install-pluginartifactId>
<version>2.5.2version>
plugin>
<plugin>
<artifactId>maven-deploy-pluginartifactId>
<version>2.8.2version>
plugin>
plugins>
pluginManagement>
build>
project>
在build中配置resources，来防止我们资源导出失败的问题
<build>
<resources>
<resource>
<directory>src/main/resourcesdirectory>
<includes>
<include>**/*.propertiesinclude>
<include>**/*.xmlinclude>
includes>
resource>
<resource>
<directory>src/main/javadirectory>
<includes>
<include>**/*.propertiesinclude>
<include>**/*.xmlinclude>
includes>
resource>
resources>
build>
5.11、Maven仓库的使用
Maven仓库
常见的问题
-
maven版本与jdk版本不相容（jdk1.8 maven3.5）
-
Tomcat闪退
-
IDEA中每次都要重复配置Maven(修改全局)
-
Maven项目中Tomcat无法配置
-
Maven默认web项目中的web.xml版本问题
-
- 替换为webapp4.0版本和Tomcat一致
<web-app metadata-complete="true" version="4.0" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee"> web-app>
-
6、Servlet
6.1、Servlet简介
- Servlet就是sun公司开发动态web的一门技术
- sun公司在这些api中提供了一个接口叫Servlet，如果想发开一个Servlet程序，则需要两步
- 编写一个类实现Servlet接口
- 把开发号的java类部署到web服务器中
通常我们把实现了Servlet接口的java程序叫做Servlet
6.2、HelloServlet
Servlet接口Sun公司有两个默认的实现类：HttpServlet,GenericServlet
1.构建一个普通的Maven项目，删掉里面的src目录，以后我们的学习就在这个项目里面建立Moudel；这个空的工程就题Maven主工程；
关于Maven父子工程的理解
父项目中会有
servlet-01
子项目通常会有(这里如果没有可以手动添加)
javaweb-02-servlet
com.qjd
1.0-SNAPSHOT
注：父项目中的java子项目可以直接使用
3.Maven环境优化
3.1.修改web.xml为最新的
在这里可以把最新的web.xml保存下来，下次直接拿来稍微修改就可以使用
web.xml
hello
hello
/hello
3.2.将Maven的结构搭建（java，resources）
4.编写一个Servlet程序
-
编写一个普通类
- 实现Servlet接口，这里我们直接继承HttpServlet
public class HelloServlet extends HttpServlet {
//由于get或post只是请求实现的方式不同，可以相互调用，业务逻辑都一样
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("进入了doGet方法");
//ServletOutputStream outputStream = resp.getOutputStream();
PrintWriter writer = resp.getWriter();//响应流
writer.println("Hello,Servlet");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
5.编写Servlet的映射
为什么需要映射？
我们写的是Java程序，但是要通过浏览器访问，而浏览器需要连接web服务器，所以我们需要在web服务中注册我们写的Servlet，还需要给它一个浏览器能够访问的路径
<web-app metadata-complete="true" version="4.0"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://xmlns.jcp.org/xml/ns/javaee">
<servlet>
<servlet-name>helloservlet-name>
<servlet-class>com.qjd.servlet.HelloServletservlet-class>
servlet>
<servlet-mapping>
<servlet-name>helloservlet-name>
<url-pattern>/hellourl-pattern>
servlet-mapping>
web-app>
6.配置Tomcat
注意：配置项目发布的路径就可以了
7.启动测试
(1)为部署标记工件
(2)启动Tomcat发现在服务这个模块中显示了我们在HelloServlet中编写的“进入了doGet方法“”
(3)测试结果（注意这里的访问路径不要写错）
6.3、Servlet原理
Servlet是由web服务器调用，web服务器在收到浏览器的请求之后，会执行以下流程：
6.4、Mapping
1.一个Servlet可以指定一个映射路径
<servlet-mapping>
<servlet-name>helloservlet-name>
<url-pattern>/hellourl-pattern>
servlet-mapping>
2.一个Servlet可以指定多个映射路径
<servlet-mapping>
<servlet-name>helloservlet-name>
<url-pattern>/hellourl-pattern>
servlet-mapping>
<servlet-mapping>
<servlet-name>helloservlet-name>
<url-pattern>/hello2url-pattern>
servlet-mapping>
<servlet-mapping>
<servlet-name>helloservlet-name>
<url-pattern>/hello3url-pattern>
servlet-mapping>
3.一个Servlet可以指定通用映射路径
<servlet-mapping>
<servlet-name>helloservlet-name>
<url-pattern>/hello/*url-pattern>
servlet-mapping>
<servlet-mapping>
<servlet-name>helloservlet-name>
<url-pattern>/*url-pattern>
servlet-mapping>
4.指定一些后缀或者前缀等
<servlet-mapping>
<servlet-name>helloservlet-name>
<url-pattern>*.qjdurl-pattern>
servlet-mapping>
5.优先级问题
指定了固有的映射路径优先级最高，如果找不到就会走默认的处理请求
如下启动Tomcat默认进入ErrorServlet的404，但输入http://localhost:8080/s001/hello可以进入Hello.Servlet而不是404
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.println("404
");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doPost(req, resp);
}
}
<servlet>
<servlet-name>helloservlet-name>
<servlet-class>com.qjd.servlet.HelloServletservlet-class>
servlet>
<servlet-mapping>
<servlet-name>helloservlet-name>
<url-pattern>/hellourl-pattern>
servlet-mapping>
<servlet>
<servlet-name>errorservlet-name>
<servlet-class>com.qjd.servlet.ErrorServletservlet-class>
servlet>
<servlet-mapping>
<servlet-name>errorservlet-name>
<url-pattern>/*url-pattern>
servlet-mapping>
6.5、ServletContext
web容器在启动的时候，它会为每个web程序都创建一个对应的ServletContext对象，它代表了当前的web应用
1、共享数据
我们在这个Servlet中保存的数据可以在另一个Servlet中拿到
例子：
-
放置username的类
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 = "ikun";//数据 context.setAttribute("username",username);//将一个数据保存在了ServletContext中，名字为：username，值为username （= "ikun";） } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { doGet(req, resp); } } -
读取username 的类
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().println("名字是"+username); } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { super.doGet(req, resp); } } -
配置web.xml
<servlet> <servlet-name>helloservlet-name> <servlet-class>com.qjd.servlet.HelloServletservlet-class> servlet> <servlet-mapping> <servlet-name>helloservlet-name> <url-pattern>/hellourl-pattern> servlet-mapping> <servlet> <servlet-name>getcservlet-name> <servlet-class>com.qjd.servlet.GetServletservlet-class> servlet> <servlet-mapping> <servlet-name>getcservlet-name> <url-pattern>/getcurl-pattern> servlet-mapping> -
测试访问（理解6.5开始的图）：
-
直接访问http://localhost:8080/s002/getc不能显示出名字（名字存在http://localhost:8080/s002/hello中）
-
先访问http://localhost:8080/s002/hello再访问http://localhost:8080/s002/getc可以得到名字
-
2、获取初始化参数
-
在web.xml中配置参数
<context-param> <param-name>urlparam-name> <param-value>jdbc:mysql://localhost:3306/mybatis?useSSL=false&useUnicode=true&characterEncoding=UTF-8param-value> context-param> -
得到参数
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { ServletContext context = this.getServletContext(); String url = context.getInitParameter("url"); resp.getWriter().println(url); } -
在web.xml中注册
<servlet> <servlet-name>gpservlet-name> <servlet-class>com.qjd.servlet.ServletDemo03servlet-class> servlet> <servlet-mapping> <servlet-name>gpservlet-name> <url-pattern>/gpurl-pattern> servlet-mapping>
3、请求转发
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("进入了ServletDemo04");
ServletContext context = this.getServletContext();
context.getRequestDispatcher("/gp").forward(req,resp);//转发的请求路径并调用forward实现请求转发
}
4、读取资源文件
Properties
- 在java目录下新建properties
- 在resources目录下新建properties
发现都被打包到同一个路径下：classes，我们俗称这个路径为classpath（类路径）
注意：如果这里没有将properties放在resources目录下，可能会导致读取不成功，我们需要在build中配置resources ， 来防止我们资源导出失败的问题
<build>
<resources>
<resource>
<directory>src/main/resourcesdirectory>
<includes>
<include>**/*.propertiesinclude>
<include>**/*.xmlinclude>
includes>
resource>
<resource>
<directory>src/main/javadirectory>
<includes>
<include>**/*.propertiesinclude>
<include>**/*.xmlinclude>
includes>
resource>
resources>
build>
思路：需要一个文件流
-
db.properties
username=root password=123456 -
ServletDemo05
public class ServletDemo05 extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { System.out.println("进入了ServletDemo05"); InputStream is = this.getServletContext().getResourceAsStream("/WEB-INF/classes/db.properties"); Properties prop = new Properties(); prop.load(is); String username = prop.getProperty("username"); String password = prop.getProperty("password"); resp.getWriter().println(username+":"+password); } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { super.doGet(req, resp); } } -
web.xml
<servlet> <servlet-name>sd5servlet-name> <servlet-class>com.qjd.servlet.ServletDemo05servlet-class> servlet> <servlet-mapping> <servlet-name>sd5servlet-name> <url-pattern>/sd5url-pattern> servlet-mapping> -
访问测试
6.6、HttpServletResponse
web服务器接收到客户端的http请求，针对这个请求，分别创建一个代表请求的HttpServletRequest对象和一个代表响应的HttpServletResponse对象
- 如果要获取客户端请求过来的参数：找HttpServletRequest
- 如果要给客户端响应一些信息：找HttpServletResponse
1、简单分类
负责向浏览器发送数据的方法
ServletOutputStream getOutputStream() throws IOException;
PrintWriter getWriter() throws IOException;
负责向浏览器发送响应头的方法
void setCharacterEncoding(String var1);
void setContentLength(int var1);
void setContentLengthLong(long var1);
void setContentType(String var1);
响应的状态码常量
200：请求响应成功
202：接受
3**：
重定向：重新到我给你的新位置去
400：错误的请求
404：找不到资源
5**：服务器代码错误（502网关错误）
以下具体的状态码了解即可，重点记住以上关于Http重点的状态码
int SC_CONTINUE = 100;
int SC_SWITCHING_PROTOCOLS = 101;
int SC_OK = 200;
int SC_CREATED = 201;
int SC_ACCEPTED = 202;
int SC_NON_AUTHORITATIVE_INFORMATION = 203;
int SC_NO_CONTENT = 204;
int SC_RESET_CONTENT = 205;
int SC_PARTIAL_CONTENT = 206;
int SC_MULTIPLE_CHOICES = 300;
int SC_MOVED_PERMANENTLY = 301;
int SC_MOVED_TEMPORARILY = 302;
int SC_FOUND = 302;
int SC_SEE_OTHER = 303;
int SC_NOT_MODIFIED = 304;
int SC_USE_PROXY = 305;
int SC_TEMPORARY_REDIRECT = 307;
int SC_BAD_REQUEST = 400;
int SC_UNAUTHORIZED = 401;
int SC_PAYMENT_REQUIRED = 402;
int SC_FORBIDDEN = 403;
int SC_NOT_FOUND = 404;
int SC_METHOD_NOT_ALLOWED = 405;
int SC_NOT_ACCEPTABLE = 406;
int SC_PROXY_AUTHENTICATION_REQUIRED = 407;
int SC_REQUEST_TIMEOUT = 408;
int SC_CONFLICT = 409;
int SC_GONE = 410;
int SC_LENGTH_REQUIRED = 411;
int SC_PRECONDITION_FAILED = 412;
int SC_REQUEST_ENTITY_TOO_LARGE = 413;
int SC_REQUEST_URI_TOO_LONG = 414;
int SC_UNSUPPORTED_MEDIA_TYPE = 415;
int SC_REQUESTED_RANGE_NOT_SATISFIABLE = 416;
int SC_EXPECTATION_FAILED = 417;
int SC_INTERNAL_SERVER_ERROR = 500;
int SC_NOT_IMPLEMENTED = 501;
int SC_BAD_GATEWAY = 502;
int SC_SERVICE_UNAVAILABLE = 503;
int SC_GATEWAY_TIMEOUT = 504;
int SC_HTTP_VERSION_NOT_SUPPORTED = 505;
2、常见应用
1.向浏览器输出消息
（前面的练习就是）
2.下载文件
-
要获取下载文件的路径
-
下载的文件名是什么
-
设置想办法让浏览器能够支持下载我们需要的东西
-
获取下载文件的输入流
-
创建缓冲区
-
获取OutputStream对象
-
将FileOutputStream写入到buffer缓冲区
-
使用OutputStream将缓冲区中的数据输出到客户端
代码实现
public class FileServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//要获取下载文件的路径
String realPath = "E:\\JavaWeb\\Javaweb\\javaweb-02-servlet\\response\\src\\main\\resources\\3.jpg";
System.out.println("下载文件的路径"+realPath);
//下载的文件名是什么
String fileName = realPath.substring(realPath.lastIndexOf("\\") + 1);
//设置想办法让浏览器能够支持Content-Disposition下载我们需要的东西,中文命名的文件用
//URLEncoder.encode(fileName,"utf-8")解决乱码问题
resp.setHeader("Content-Disposition","attachment; filename="+ URLEncoder.encode(fileName,"utf-8"));
//获取下载文件的输入流
FileInputStream in = new FileInputStream(realPath);
//创建缓冲区
int len = 0;
byte[] buffer = new byte[1024];
//获取OutputStream对象
ServletOutputStream out = resp.getOutputStream();
//将FileOutputStream写入到buffer缓冲区
//使用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 {
doGet(req, resp);
}
}
测试访问
3.验证码功能
验证怎么来的？
-
前端实现
-
后端实现，需要用到Java的图片类，生成一个图片
public class ImageServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { //如何让浏览器3秒自动刷新一次 resp.setHeader("refresh","3"); //在内存中创建一个图片 BufferedImage bufferedImage = new BufferedImage(80,60,BufferedImage.TYPE_INT_RGB); //得到图片 Graphics2D graphics =(Graphics2D) bufferedImage.getGraphics();//画笔 //设置图片的背景颜色 graphics.setColor(Color.BLUE); graphics.fillRect(0,0,80,60); //给图片写数据 graphics.setColor(Color.CYAN); graphics.setFont(new Font(null,Font.BOLD,20)); graphics.drawString(makeNum(),0,20); //告诉浏览器这个请求用图片的方式打开 resp.setContentType("image/jpg"); //网站存在缓存 resp.setDateHeader("expires",-1); resp.setHeader("cache-control","no-cache"); //把图片写给浏览器 ImageIO.write(bufferedImage,"jpg", resp.getOutputStream()); } //生成随机数 private String makeNum(){ Random random = new Random(); String s = random.nextInt(9999999) + ""; StringBuffer sb = new StringBuffer(); for (int i = 0; i < 7-s.length() ; i++) { sb.append("0"); } String s1 = sb.toString() + s; return s; } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { doGet(req, resp); } }
测试访问：每5秒钟刷新生成随机数(这个页面有点丑，大家请见谅)
4.实现重定向
一个web资源收到客户端请求后，它会通知客户端去访问另一个web资源，这个过程叫做重定向
常见场景：
用户登录
void sendRedirect(String var1) throws IOException;
测试：
public class RedirectServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//重定向
resp.sendRedirect("/r/img");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
测试访问
注：网页404时代表代码没有问题，只是路径出错了
jsp测试
-
index.jsp
Hello World!
<%--这里提交的路径需要寻找到项目的路径--%> <%--pageContext.request.contextPath代表当前的项目--%> <%@page contentType="text/html; ISO-8859-1" pageEncoding="UTF-8" %> -
success.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>Title Success
-
RequestTest
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 { doGet(req, resp); } }
测试访问：
6.7、HttpServletRequest
HttpServletRequest代表客户端的请求，用户通过Http协议访问服务器，Http请求中的所有信息会被封装到HttpServletRequest，
通过这个HttpServletRequest的方法，获得客户端的所有信息
获取参数，请求转发
代码实现
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
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("=====================================");
//通过请求转发
//注意：这里的 / 代表当前的web应用（转发不用写/ 重定向写/）
req.getRequestDispatcher("/success.jsp").forward(req,resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
测试访问
思考题:请你聊聊重定向和转发的区别
相同点：页面都会实现跳转
不同点：
- 请求转发的时候，URL不会发生变化 307
- 重定向的时候，URL地址栏会发生变化 302
7、Cookie、Session
7.1、会话
会话：用户打开了一个浏览器，点击了很多超链接，访问多个web资源，关闭浏览器，这个过程可以称之为会话
有状态会话：记录了一些信息
大家在浏览网站的过程中有没有思考过这样一个问题，一个网站怎么证明客户访问过呢？
客户端 服务端
1.服务端给客户端一个信件，客户端下次访问服务端带上信件就可以了 ： cookie
2.服务器登记客户已经来过了，下次访问的时候直接匹配登记过的客户 ； session
3.大家可以先看一下这张图，下面对Cookie与Session的讲解就是围绕这张图展开的，最后会对这张图进行详细的讲解
7.2、保存会话的两种技术
7.2.1、cookie
- 客户端技术（响应，请求）
- cookie一般是以键值对的形式进行表示的（key-value）
- 我们登录过一个网站，当我们再次打开就不需要再次登录了
7.2.2、session
- 服务器技术（保存用户的会话信息，可以把信息或者数据放在session中）
- 每个客户端都有自己的一个Session会话
- Session会话中，我们经常用来保存用户登录之后的信息
大部分的网站：网站登录之后，下次就不用再登录了，第二次访问直接就可以登录进去
7.3、Cookie
1.cookie中常用属性的解释
- Name：这个是cookie的名字
- Value：这个是cooke的值
- path：这个定义了Web站点上可以访问该Cookie的目录
- Expircs：这个值表示cookie的过期时间，也就是有效值，cookic在这个值之前都有效。
- size：这个表示cookic的大小
2.Cookie的Http传输
Cookie的Http传输 我们会在接下来的例子中进行抓包展示
3.Cookie的生命周期
cookie有2种存储方式，一种是会话性，一种是持久性
- 会话性：如果cookie为会话性，那么cookie仅会保存在客户端的内存中，当我们关闭客服端时cookie也就失效了
- 持久性：如果cookie为持久性，那么cookie会保存在用户的硬盘中，直至生存期结束或者用户主动将其销毁。
cookie我们是可以进行设置的，我们可以人为设置cookie的有效时间，什么时候创建，什么时候销毀。
4.cookie 使用的常见方法
java中Cookie对象的方法进行讲解
- new Cookie(String name, String value)：创建一个Cookie对象，必须传入cookie的名字和cookic的值
- setValue()：得到cookie保存的值
- getName()：获取cookie的名字
- setMaxAge(int expiry)：设置cookie的有效期，默认为-1。这个如果设置负数，表示客服端关闭，cookie就会删除。0表示马上删除。正数表示有效时间，单位是秒
- setPath(String uri)：设置cookie的作用域
HttpServletRequest和Http ServletResponse对Cookie进行操作的常见方法
- response.addCookie(Cookie cookie)：将cookie给客户端进行保存
- resquest.getCookies0：得到客服端传过来的所有cookie对象
这张图是客户端携带Cookie访问服务器的流程图
7.3.1、用代码实现保存用户上一次访问的时间
-
从请求中拿到cookie信息
-
服务端响应给客户端cookie
//保存用户上一次访问的时间
public class CookieDemon01 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//服务器告诉你你来的时间,把这个时间封装为一个信件,你下次来,我就知道你来了
//解决中文乱码，这里解决乱码需要根据实际情况自己进行调试
req.setCharacterEncoding("gbk");
resp.setCharacterEncoding("gbk");
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("LastLogTime")){
//获取cookie的值
long lastLogTime = Long.parseLong(cookie.getValue());
Date date = new Date(lastLogTime);
out.write(date.toLocaleString());
}
}
}else {
out.write("这是您第一次访问本站");
}
//服务器给客户端响应一个cookie
Cookie cookie = new Cookie("LastLogTime", System.currentTimeMillis()+"");
//设置cookie有效期为一天(浏览器关闭cookie还存在一天)
cookie.setMaxAge(24*60*60);
resp.addCookie(cookie);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
3.注册Servlet
<servlet>
<servlet-name>CookieDemo01servlet-name>
<servlet-class>com.qid.servlet.CookieDemon01servlet-class>
servlet>
<servlet-mapping>
<servlet-name>CookieDemo01servlet-name>
<url-pattern>/c1url-pattern>
4.测试访问
第一次访问
第二次访问
接下来我们抓包查看Cookie的Http传输
注：cookie一般会保存在本地的用户目录下AppData ，浏览器只会携带在当前请求的URL中包含了改cookie中path值的cookie
了解一下：
一个网站cookie是否存在上限?
- 一个cookie只能保存一个信息
- 一个web站点可以给浏览器发送多个cookie,最多存放20个cookie
- cookie大小上限为4kb
- 300个cookie大约为浏览器上限
7.3.2、删除cookie:
-
不设置有效期,关闭浏览器,自动失效
-
设置有效期为0
public class CookieDemon02 extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { //创建一个cookie.名字必须和要删除的名字一致 Cookie cookie = new Cookie("LastLogTime", System.currentTimeMillis()+""); //有限期为0 cookie.setMaxAge(0); resp.addCookie(cookie); } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { doGet(req, resp); } }
7.3.3、中文传输数据乱码问题
这里再用上面记录访问时间的例子说一下传输中文数据的问题：
如果一直中文传输数据乱码，可以尝试以下代码：
编码解码
//编码
Cookie cookie = new Cookie("name", URLEncoder.encode("张三","utf-8"));
//解码
out.write( URLDecoder.decode(cookie.getValue(),"utf-8"));
整体代码：
//中文数据传递
public class CookieDemon03 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//解决中文乱码
req.setCharacterEncoding("utf-16");
resp.setCharacterEncoding("utf-16");
//cookie,服务器端从客户端获取
Cookie[] cookies = req.getCookies();//返回数组说明cookie可能存在多个
PrintWriter out = resp.getWriter();
//判断cookie是否存在
if (cookies != null) {
//如果存在怎么办
out.write("您的名字是:");
for (int i = 0; i < cookies.length; i++) {
Cookie cookie = cookies[i];
//获取cookie的名字
if( cookie.getName().equals("name")){
//获取cookie的值
System.out.println(cookie.getValue());
//解码
out.write( URLDecoder.decode(cookie.getValue(),"utf-8"));
}
}
}else {
out.write("这是您第一次访问本站");
}
//编码
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后测试结果
7.4、Session（重点）
7.4.1、Session的概念
1.什么是session
- 服务器会给每一个用户（浏览器）创建一个Session
- 一个Session独占一个浏览器，只要浏览器没有关闭，这个Session就存在
- 用户登录之后，整个网站它都可以访问—>保存用户的信息
2.Session的常用方法
- request.getSession():创建（第一次调用）或获取Session会话对象
- isNew():判断当前Session会话是否是新创建出来的
- getId():得到Session的会话ID
- setAttribute()：往Session中保存数据
- getAttribute()：获取Session域中的数据
3.Session的生命周期
-
手动注销：session.invalidate();
-
自动注销：在web.xml 中配置
<session-config>
<session-timeout>15session-timeout>
session-config>
4.session应用：
- 保存一个登录用户的信息
- 购物车信息
- 在整个网站中经常会使用的数据，我们将它保存在Session中
下面这张图是服务器登记session，客户端用sessionID访问的流程图
7.4.2、具体使用session
1.保存数据：
- Person.java
- SessionDemon01(设置信息)
- SessionDemon02（得到信息）
public class Person {
private String name;
private int age;
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + 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;
}
}
public class SessionDemon01 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//解决乱码问题
req.setCharacterEncoding("gbk");
resp.setCharacterEncoding("gbk");
resp.setContentType("text/html;charset = gbk");
//得到Session
HttpSession session = req.getSession();
//给Session中存东西
session.setAttribute("name",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);
// resp.addCookie(cookie);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
public class SessionDemon02 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//解决乱码问题
req.setCharacterEncoding("gbk");
resp.setCharacterEncoding("gbk");
resp.setContentType("text/html;charset = gbk");
//得到Session
HttpSession session = req.getSession();
Person person = (Person) session.getAttribute("name");
resp.getWriter().write(person.toString());
System.out.println(person.toString());
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
注册Servlet测试访问
（1）访问设置信息s1
(2)访问得到信息s2
2.会话过期
-
手动
public class SessionDemon03 extends HttpServlet { //注销，移除 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { HttpSession session = req.getSession(); session.removeAttribute("name"); //手动注销session session.invalidate();//一旦注销会重新产生一个sessionId } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { doGet(req, resp); } } -
自动
<session-config> <session-timeout>15session-timeout> session-config>
最后我们再回到刚开始的问题，一个网站怎么证明你来过呢？
思考 ： Session和Cookie的区别
①cookie可以存储在浏览器或者本地，Session只能存在服务器
②session能够存储任意的java对象，cookie 只能存储String 类型的对象
③Session比tCookie更具有安全性(Cookie有安全隐患，通过拦截或本地文件找得到你的cookie后可以进行攻击）
④Session占用服务器性能，Session过多，增加服务器压力
⑤单个Cookie保存的数据不能超过4K，很多浏览器都限制一个站点最多保存20个Cookie,Session是没有大小限制和服务器的
8、JSP
8.1、什么是JSP
JavaServletPages: Java服务器端页面，也和Serlvet一样，用于动态web技术
最大的特点：
- 写JSP就像写HTML
- 区别：
- HTML只给用户提供静态的数据
- JSP页面中可以嵌入Java代码，为用户提供动态数据
8.2、JSP原理
思路：JSP到底是怎么执行的
-
代码层面没有任何问题
-
服务器内部工作
Tomcat中有一个work目录：
idea中使用Tomcat会在idea的Tomcat中产生一个work目录
-
发现页面变成了Java程序
JSP最终也会被转成一个java类
JSP本质上就是一个Servlet
浏览器向服务器发送请求，不管访问什么资源，其实都是在访问servlet
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/htm1");
//设望响应的页面类型
pagecontext = _jspxFactory.getPagecontext(this,request,response,
null,true,8192,true);
_jspx_page_context = pagecontext;
application = pagecontext.getservletcontext();
config = pagecontext.getservletconfig();
session = pagecontext,getsession();
out = pagecontext.getout();
_jspx_out=out;
以上的这些对象我们可以在JSP页面上直接使用
在JSP页面中，只要是Java代码就会原封不动的输出
如果是HTML代码就会被转换为：
out.write("\n");
这样的格式输出到前端
8.3、JSP基础语法
任何语言都有自己的语法，Java中有；JSP作为Java技术的一种应用，他拥有一些自己的扩充语法，Java所有的语法都支持
JSP表达式
<%--JSP表达式
作用:用来将程序的输出，输出到客户端
<%= new 变量或者表达式%>
--%>
<%= new java.util.Date()%>
JSP脚本片段
<%--jsp 脚本片段 --%>
<%
int sum = 0;
for (int i = 1; i <= 100; i++) {
sum+=i;
}
out.println("Sum="+sum+"
");
%>
脚本片段的再实现
<%
int x = 10;
out.println(x);
%>
这是一个jsp文档
<%
int y = 20;
out.println(2);
%>
<%--在代码中嵌入HTML元素 --%>
<%
for (int i = 0; i < 5; i++) {
%>
hello world <%=i%>
<%
}
%>
JSP声明
<%!
static {
System.out.println("Loading Servlet!");
}
private int global = 0;
public void qjd(){
System.out.println("进入了方法qjd");
}
%>
JSP声明：(<%!%>)会被编译到JSP生成的Java类中！其他的（<%%>）就会被生成到jspService 方法中
在JSP中嵌入Java代码
<%----%> 注释
<%%> 片段
<%=%> 表达式输出一个值
<%!%> 全局
${} el表达式
JSP的注释（<%----%>）不会在客户端显示，HTML（ ）就会
8.4、JSP指令
<%@page args...%>
<%@ include file="" %>
1.定制错误页面<%@page args…%>
jsp2.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--定制错误页面(可以在这个jsp中引入也可以在web.xml 中配置)--%>
<%@ page errorPage="error/500.jsp" %>
Title
<%
int x = 1/0;
%>
如果在web.xml中配置
<error-page>
<error-code>500error-code>
<location>/error/500.jsplocation>
error-page>
500.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
Title
测试
500错误：
404错误：
2.共用部分<%@ include file=“” %>
Title
<%--方法一@ include会将三个页面合三为一--%>
<%@ include file="common/header.jsp" %>
网页主体
<%@ include file="common/footer.jsp" %>
<%--方法二jsp标签
jsp:include：拼接页面，本质还是3个
--%>
网页主体
测试
8.5、九大内置对象
- PageContext (存东西)
- Request (存东西)
- Response
- Session (存东西)
- Application 【ServletContext】(存东西)
- config 【ServletConfig】
- out
- page
- exception
重点对象理解：
request:客户端向服务器发送请求，产生的数据，用户看完就没用了，比如：新闻，用户看完没用的！
session:客户端向服务器发送请求，产生的数据，用户用完一会还有用，比如：购物车；
application:客户端向服务器发送请求，产生的数据，一个用户用完了，其他用户还可能使用，比如：聊天数
据；
具体实现：
- 通过pageContext寻找的方式取出我们保存的值
pageContextDemon01.jsp（在一个页面取值）
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
Title
<%--内置对象--%>
<%
pageContext.setAttribute("name1","张三1");//保存的数据只在一个页面中有效
request.setAttribute("name2","张三2");//保存的数据只在一次请求中有效，请求转发会携带这个数据
session.setAttribute("name3","张三3");//保存的数据只在一次会话中有效，打开到关闭浏览器
application.setAttribute("name4","张三4");//保存的数据在服务器中有效，打开到关闭服务器
%>
<%
//通过pageContext寻找的方式取出我们保存的值
//从底层到高层（作用域）: page->request->session->application->找不到
//JVM:双亲委派机制 应用->扩展类->rt.jar
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");//不存在
%>
<%--使用el表达式输出 ${}--%>
取出的值为:
${name1}
${name2}
${name3}
${name4}
${name5}
pageDemon02.jsp（在另一个页面取值）
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
Title
<%--在另一个页面取pageContextDemon01.jsp中的值只能取到3和4
如果 request请求转发就可以取出来
--%>
<%
//通过pageContext寻找的方式取出我们保存的值
//从底层到高层（作用域）
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");//不存在
%>
<%--使用el表达式输出 ${}--%>
取出的值为:
${name1}
${name2}
${name3}
${name4}
${name5}
手动修改作用域与请求转发
//手动修改作用域，第三个参数为作用域
pageContext.setAttribute("hello","hello1",PageContext.SESSION_SCOPE);//等价于 session.setAttribute("hello","hello1");
<%
//请求转发
pageContext.forward("/index.jsp");
//等价于 request.getRequestDispatcher("/index.jsp").forward(request,response);
%>
8.6、JSP标签、JSTL标签、EL表达式
<dependency>
<groupId>javax.servlet.jsp.jstlgroupId>
<artifactId>jstl-apiartifactId>
<version>1.2version>
dependency>
<dependency>
<groupId>taglibsgroupId>
<artifactId>standardartifactId>
<version>1.1.2version>
dependency>
EL表达式：${}
- 获取数据
- 执行运算
- 获取web开发的常用对象
JSP标签：
<%--jsp:include --%>
1
<%--转发时添加数据--%>
<%--取出参数--%>
名字:<%=request.getParameter("name")%>
年龄:<%=request.getParameter("age")%>
JSTL表达式：
JSTL标签库的使用就是为了弥补html标签的不足;它自定义许多标签，可以供我们使用，标签的功能和Java代码一样
- 核心标签（掌握部分）
-
格式化标签
-
SQL标签
-
XML标签
JSTL标签库使用步骤：
- 引入对应的taglib
- 使用其中的方法
- 在Tomcat也需要导入jstl的包。否则会报错：jstl解析错误
c:if:
<%@ taglib prefix="x" uri="http://java.sun.com/jsp/jstl/xml" %>
Title
if测试
<%--判断如果提交的用户名是管理员则登录成功--%>
c:choose:
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--引入jstl核心标签库--%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="x" uri="http://java.sun.com/jsp/jstl/xml" %>
Title
<%--定义一个标量scroe,值为99--%>
你的成绩为优秀
你的成绩为良好
你的成绩为一般
你的成绩为不及格
c:forEach:
<%@ page import="java.util.ArrayList" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--引入jstl核心标签库--%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="x" uri="http://java.sun.com/jsp/jstl/xml" %>
Title
<%
ArrayList people = new ArrayList<>();
people.add(0,"张三");
people.add(1,"李四");
people.add(2,"王五");
people.add(3,"赵六");
people.add(4,"田七");
request.setAttribute("list",people);
%>
<%--var:每一次遍历出来的变量
items:要遍历的对象
begin:开始
end:结束
step:步长
--%>
9、JavaBean
实体类
JavaBean有特定的写法：
- 必须要有一个无参构造
- 属性必须私有化
- 必须有对应的set/get方法
一般用来和数据库字段做映射，ORM；
ORM：对象关系映射
- 表—>类
- 字段—>属性
- 行记录—>对象
<%@ page import="com.qjd.pojo.People" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
Title
<%
// People people = new People();
// people.setId(001);
// people.setAddress("");
%>
10、三层架构
什么是MVC：Model View Controller (模型，视图，控制器)
10.1、早期开发
用户直接访问控制层，控制层就可以直接操作数据库
servlet--CRUD--数据库
弊端：程序十分臃肿，不利于维护
servlet的代码中！处理请求、响应、视图跳转、处理JDBC、处理业务代码、处理逻辑代码
架构：设有什么是加一层解决不了的！
程序调用
JDBC
Mysql oracle sqlserver ...
10.2、MVC三层架构
Model:
- 业务处理：业务逻辑（Service）
- 数据持久层：CRUD(Dao)
View:
- 展示数据
- 提供连接发起Servlet请求（a,form,img…）
Controller:
- 接受用户的请求：（req:请求参数、session信息…）
- 交给业务层处理对应的代码
- 控制视图的跳转
登录--->接收用户的登录请求--->处理用户的请求（获取用户登录的参数，username,password）--->交给业务层处理登录业务（判断用户名密码是否正确）--->Dao层查询用户名和密码是否正确--->数据库
11、Filter（重点）
Filter:过滤器，用来过滤网站的数据；
- 处理中文乱码
- 登录验证…
Filter开发步骤：
- 导包
- 编写过滤器
- 导包不要错 import javax.servlet.*;
- 实现Filter接口，重写对应的方法
- 在web.xml中配置Filter
CharacterEncodingFilter:
public class CharacterEncodingFilter implements Filter {
//初始化 web服务器启动就初始化了
@Override
public void init(FilterConfig filterConfig) throws ServletException {
System.out.println("CharacterEncodingFilter初始化");
}
//Chain:链
/*
* 1.过滤中的所有代码，在过滤特定请求的时候都会执行
* 2.必须要让过滤器继续通行filterChain.doFilter(servletRequest,servletResponse);
* */
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
servletRequest.setCharacterEncoding("utf-8");
servletResponse.setCharacterEncoding("utf-8");
servletResponse.setContentType("text/html;charset=utf-8");
System.out.println("CharacterEncodingFilter执行前...");
filterChain.doFilter(servletRequest,servletResponse);//让我们的请求继续走，如果不添加，程序到这里就被拦截停止
System.out.println("CharacterEncodingFilter执行后...");
}
//销毁 web服务器关闭的时候销毁
@Override
public void destroy() {
System.out.println("CharacterEncodingFilter销毁");
}
}
web.xml:
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<servlet>
<servlet-name>ShowServletservlet-name>
<servlet-class>com.qjd.servlet.ShowServletservlet-class>
servlet>
<servlet-mapping>
<servlet-name>ShowServletservlet-name>
<url-pattern>/servlet/showurl-pattern>
servlet-mapping>
<servlet-mapping>
<servlet-name>ShowServletservlet-name>
<url-pattern>/showurl-pattern>
servlet-mapping>
<filter>
<filter-name>CharacterEncodingFilterfilter-name>
<filter-class>com.qjd.filter.CharacterEncodingFilterfilter-class>
filter>
<filter-mapping>
<filter-name>CharacterEncodingFilterfilter-name>
<url-pattern>/servlet/*url-pattern>
filter-mapping>
web-app>
ShowServlet:
public class ShowServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// resp.setCharacterEncoding("utf-8");
// req.setCharacterEncoding("utf-8");
resp.getWriter().write("你好啊");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
12、监听器
实现一个监听器的接口：（有N种）
-
编写一个监听器（实现监听器的接口）
//统计网站在线人数:统计session public class OnlineCountListener implements HttpSessionListener{ // 创建session监听 // 一旦创建Session就会触发一次这个事件 @Override public void sessionCreated(HttpSessionEvent se) { System.out.println(se.getSession().getId()); 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就会触发一次这个事件 @Override public void sessionDestroyed(HttpSessionEvent se) { ServletContext ctx = se.getSession().getServletContext(); 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中配置) *1 -
配置监听器（web.xml中注册）
<listener> <listener-class>com.qjd.listener.OnlineCountListenerlistener-class> listener> -
根据情况是否使用
-
测试结果
13、过滤器、监听器常见应用
-
监听关闭事件（GUI）
public class TestPanel { public static void main(String[] args) { Frame frame = new Frame("好好学习");//新建一个窗口 Panel panel = new Panel(null);//面板 frame.setLayout(null);//设置窗体的布局 frame.setBounds(300,300,500,500); frame.setBackground(new Color(0, 255, 34)); panel.setBounds(50,50,300,300); panel.setBackground(new Color(128, 0, 255)); frame.add(panel); frame.setVisible(true); //监听关闭事件 frame.addWindowListener(new WindowListener() { @Override public void windowOpened(WindowEvent e) { System.out.println("打开"); } @Override public void windowClosing(WindowEvent e) { System.out.println("正在关闭"); System.exit(0);//0是正常终止。1是非正常终止 } @Override public void windowClosed(WindowEvent e) { System.out.println("已关闭"); } @Override public void windowIconified(WindowEvent e) { } @Override public void windowDeiconified(WindowEvent e) { } @Override public void windowActivated(WindowEvent e) { System.out.println("激活"); } @Override public void windowDeactivated(WindowEvent e) { System.out.println("未激活"); } }); } } -
用户登录才能进入主页，用户注销后就不能进入主页（必须通过登录才能访问登录成功主页，通过直接访问登录成功主页不能进入）
-
用户登录之后，向Session中放入用户的数据
-
进入主页的时候要判断用户是否已经登录（在过滤器中实现）
public class SysFilter implements Filter { @Override public void init(FilterConfig filterConfig) throws ServletException { } @Override public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { //ServletRequest HttpServlet HttpServletRequest request1 = (HttpServletRequest) servletRequest; HttpServletResponse response1 = (HttpServletResponse) servletResponse; String user_session = (String) request1.getSession().getAttribute(Constant.USER_SESSION); if(user_session == null){ response1.sendRedirect("/error.jsp"); } filterChain.doFilter(servletRequest,servletResponse); } @Override public void destroy() { } }
整体步骤：
- 制定登录页面Login.jsp
- LoginServlet
- 登录成功进入success.jsp
- 登录失败进入error.jsp
- 权限验证SysFilter
- 解决session名字重用问题（定义常量Constant）
- 配置web.xml
14、JDBC
什么是JDBC：Java DataBase Connection (Java连接数据库)
连接数据库需要jar包的支持：
- java.sql
- javax.sql
- mysql-connector-java(连接驱动)
JDBC 固定步骤：
1.加载驱动
2.连接数据库,代表数据库
3.向数据库发送SQL的对象Statement : CRUD
4.编写SQL （根据业务，不同的SQL）
5.执行SQL
6.关闭连接（先开的后关）
实验环境搭建：
-
数据库信息
-
导入数据库依赖
<dependency> <groupId>mysqlgroupId> <artifactId>mysql-connector-javaartifactId> <version>8.0.29version> dependency> -
IDEA中连接数据库
-
JDBC六步
public class TestJDBC { public static void main(String[] args) throws ClassNotFoundException, SQLException { //配置信息 //解决中文乱码问题useUnicode=true&characterEncoding=utf-8 String url = "jdbc:mysql://localhost:3306/jdbc? useUnicode=true&characterEncoding=utf-8&useSSL=true"; String username = "root"; String password = "123456789"; //1.加载驱动 Class.forName("com.mysql.jdbc.Driver"); //2.连接数据库,代表数据库 Connection connection = DriverManager.getConnection(url, username, password); //3.向数据库发送SQL的对象 Statement:CRUD Statement statement = connection.createStatement(); // PreparedStatement安全，可以防止sql注入（预编译） //4.编写sql String sql = "select *from jdbc.users"; //5.执行查询sql，返回一个ResultSet结果集 ResultSet rs = statement.executeQuery(sql); while (rs.next()){ System.out.println("id="+rs.getObject("id")); System.out.println("name="+rs.getObject("name")); System.out.println("password="+rs.getObject("password")); System.out.println("email="+rs.getObject("email")); System.out.println("birthday="+rs.getObject("birthday")); } //6.关闭连接，释放资源(先创建的后关闭) rs.close(); statement.close(); connection.close(); } }
- 结果：
-
使用预编译防止sql注入
public class TestJDBC2 { public static void main(String[] args) throws ClassNotFoundException, SQLException { //配置信息 //解决中文乱码问题useUnicode=true&characterEncoding=utf-8 String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8&useSSL=true"; String username = "root"; String password = "123456789"; //1.加载驱动 Class.forName("com.mysql.cj.jdbc.Driver"); //2.连接数据库,代表数据库 Connection connection = DriverManager.getConnection(url, username, password); //3.编写sql String sql = "insert into jdbc.users(id, name, password, email, birthday) VALUES (?,?,?,?,?);"; //4.预编译 PreparedStatement安全，可以防止sql注入（预编译） PreparedStatement preparedStatement = connection.prepareStatement(sql); preparedStatement.setInt(1,4);//第一个占位符？的值为1 preparedStatement.setString(2,"赵六");//第二个占位符？的值为赵六 preparedStatement.setString(3,"523456");//第三个占位符？的值为123456 preparedStatement.setString(4,"[email protected]");//第四个占位符？的值为[email protected] preparedStatement.setDate(5,new Date(System.currentTimeMillis()));//第五个占位符？的值为当前年月日 //5.执行查询sql int i = preparedStatement.executeUpdate(); System.out.println(i); //6.关闭连接，释放资源(先创建的后关闭) preparedStatement.close(); connection.close(); } }
- 结果：
15、事务
要么都成功，要么都失败！
ACID原则：保证数据的安全
- 原子性
- 隔离性
- 持久性
- 一致性
开启事务
事务提交commit
事务回滚rollback
关闭事务
junit单元测试
-
依赖
<dependency> <groupId>junitgroupId> <artifactId>junitartifactId> <version>4.13.2version> <scope>testscope> dependency> -
简单使用：
@Test注解只有在方法上有效，只要加了这个注解的方法就可以直接运行
搭建测试事务环境：
count表：
public class TestJDBC3 {
@Test
public void test() {
//配置信息
//解决中文乱码问题useUnicode=true&characterEncoding=utf-8
String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8&useSSL=true";
String username = "root";
String password = "123456789";
Connection connection = null;
//1.加载驱动
try {
Class.forName("com.mysql.cj.jdbc.Driver");
//2.连接数据库,代表数据库
connection = DriverManager.getConnection(url, username, password);
//3.通知数据库开启事务(false是开启)
connection.setAutoCommit(false);
String sql = "update jdbc.account set money = money-100 where name = 'a';";
connection.prepareStatement(sql).executeUpdate();
//制造错误
int i=1/0;
String sql2 = "update jdbc.account set money = money+100 where name = 'b';";
connection.prepareStatement(sql2).executeUpdate();
connection.commit();//以上两条sql都提交成功了就提交事务
System.out.println("提交成功！");
} catch (Exception e) {
try {
//如果出现异常，就通知数据库回滚事务
connection.rollback();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
e.printStackTrace();
}finally {
try {
connection.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
}
-
出现错误就会回滚账户余额不变
-
没有错误就会正常提交事务
16、SMBMS项目
SMBMS项目是一个用JavaWeb编写的超市管理项目，大家可以在下面这个网站下载到原始项目
SMBMS项目源码
对于这个超市管理项目，大家可以结合前面学习的知识分析代码，遇到不会的可以标记，最后再看狂神的视频讲解SMBMS项目
我相信大家经过这个项目大家会对JavaWeb有更深的理解
17、文件上传
使用类介绍
【文件上传的注意事项】
1.为保证服务器安全，上传文件应该放在深无法直接访问的目录下，比如放于WEB-NF目录下。
2.为防止文件覆盖的现象发生，要为上传文件产生一个唯一的文件名
3.要限制上传文件的最大值。
4.可以限制上传文件的类型，在收到上传文件名时，判断后缀名是否合法。
【需要用到的类详解】
ServletFileUpload负责处理上传的文件数据，并将表单中每个输入项封装成一个Fileltem对象，在使用ServletFileUpload对象解析请求时需要DiskFileltemFactory对象。所以，我们需要在进行解析工作前构造好DiskFileltemFactory>对象，通过ServletFileUpload对象的构造方法或setFileltemFactory()方法设置ServletFileUpload?对象的fileltemFactory属性。
文件上传源码
- FileSerlvet类
/**
* Servlet implementation class FileSerlvet
*/
public class FileSerlvet extends HttpServlet {
private static final long serialVersionUID = 1L;
/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse
* response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// TODO Auto-generated method stub
// response.getWriter().append("Served at: ").append(request.getContextPath());
// 判断上传的文件普通表单还是带文件的表单
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(); //创建这个月录
}
// 创建上传文件的保存路径，建议在WEB-INF路径下，安全，用户无法直接访问上传的文件
String tmpPath = this.getServletContext().getRealPath("/WEB-INF/tmp");
File file = new File(tmpPath);
if (!file.exists()) {
file.mkdir();//创建临时目录
}
// 处理上传的文件,一般都需要通过流来获取,我们可以使用 request, getInputstream(),原生态的文件上传流获取,十分麻烦
// 但是我们都建议使用 Apache的文件上传组件来实现, common-fileupload,它需要旅 commons-io组件;
try {
// 创建DiskFileItemFactory对象，处理文件路径或者大小限制
DiskFileItemFactory factory = getDiskFileItemFactory(file);
/*
* //通过这个工厂设置一个缓冲区,当上传的文件大于这个缓冲区的时候,将他放到临时文件 factory.setSizeThreshold(1024 *
* 1024); //缓存区大小为1M factory.setRepository (file);//临时目录的保存目录,需要一个File
*/
// 2、获取ServletFileUpload
ServletFileUpload upload = getServletFileUpload(factory);
// 3、处理上传文件
// 把前端请求解析，封装成FileItem对象，需要从ServletFileUpload对象中获取
String msg = uploadParseRequest(upload, request, uploadPath);
// Servlet请求转发消息
System.out.println(msg);
if(msg == "文件上传成功!") {
// Servlet请求转发消息
request.setAttribute("msg",msg);
request.getRequestDispatcher("info.jsp").forward(request, response);
}else {
msg ="请上传文件";
request.setAttribute("msg",msg);
request.getRequestDispatcher("info.jsp").forward(request, response);
}
} catch (FileUploadException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
public static DiskFileItemFactory getDiskFileItemFactory(File file) {
DiskFileItemFactory factory = new DiskFileItemFactory();
// 通过这个工厂设置一个缓冲区,当上传的文件大于这个缓冲区的时候,将他放到临时文件中;
factory.setSizeThreshold(1024 * 1024);// 缓冲区大小为1M
factory.setRepository(file);// 临时目录的保存目录,需要一个file
return factory;
}
public static ServletFileUpload getServletFileUpload(DiskFileItemFactory factory) {
ServletFileUpload upload = new ServletFileUpload(factory);
// 监听长传进度
upload.setProgressListener(new ProgressListener() {
// pBYtesRead:已读取到的文件大小
// pContextLength:文件大小
public void update(long pBytesRead, long pContentLength, int pItems) {
System.out.println("总大小：" + pContentLength + "已上传：" + pBytesRead);
}
});
// 处理乱码问题
upload.setHeaderEncoding("UTF-8");
// 设置单个文件的最大值
upload.setFileSizeMax(1024 * 1024 * 10);
// 设置总共能够上传文件的大小
// 1024 = 1kb * 1024 = 1M * 10 = 10м
return upload;
}
public static String uploadParseRequest(ServletFileUpload upload, HttpServletRequest request, String uploadPath)
throws FileUploadException, IOException {
String msg = "";
// 把前端请求解析，封装成FileItem对象
List<FileItem> fileItems = upload.parseRequest(request);
for (FileItem fileItem : fileItems) {
if (fileItem.isFormField()) {// 判断上传的文件是普通的表单还是带文件的表单
// getFieldName指的是前端表单控件的name;
String name = fileItem.getFieldName();
String value = fileItem.getString("UTF-8"); // 处理乱码
System.out.println(name + ": " + value);
} else {// 判断它是上传的文件
// ============处理文件==============
// 拿到文件名
String uploadFileName = fileItem.getName();
System.out.println("上传的文件名: " + uploadFileName);
if (uploadFileName.trim().equals("") || uploadFileName == null) {
continue;
}
// 获得上传的文件名/images/girl/paojie.png
String fileName = uploadFileName.substring(uploadFileName.lastIndexOf("/") + 1);
// 获得文件的后缀名
String fileExtName = uploadFileName.substring(uploadFileName.lastIndexOf(".") + 1);
/*
* 如果文件后缀名fileExtName不是我们所需要的 就直按return.不处理,告诉用户文件类型不对。
*/
System.out.println("文件信息[件名: " + fileName + " ---文件类型" + fileExtName + "]");
// 可以使用UID（唯一识别的通用码),保证文件名唯
// 0UID. randomUUID(),随机生一个唯一识别的通用码;
String uuidPath = UUID.randomUUID().toString();
// ================处理文件完毕==============
// 存到哪? uploadPath
// 文件真实存在的路径realPath
String realPath = uploadPath + "/" + uuidPath;
// 给每个文件创建一个对应的文件夹
File realPathFile = new File(realPath);
if (!realPathFile.exists()) {
realPathFile.mkdir();
}
// ==============存放地址完毕==============
// 获得文件上传的流
InputStream inputStream = fileItem.getInputStream();
// 创建一个文件输出流
// realPath =真实的文件夹;
// 差了一个文件;加上翰出文件的名产"/"+uuidFileName
FileOutputStream fos = new FileOutputStream(realPath + "/" + fileName);
// 创建一个缓冲区
byte[] buffer = new byte[1024 * 1024];
// 判断是否读取完毕
int len = 0;
// 如果大于0说明还存在数据;
while ((len = inputStream.read(buffer)) > 0) {
fos.write(buffer, 0, len);
}
// 关闭流
fos.close();
inputStream.close();
msg = "文件上传成功!";
fileItem.delete(); // 上传成功,清除临时文件
//=============文件传输完成=============
}
}
return msg;
}
}
- 注册xml
<servlet>
<servlet-name>uploadservlet-name>
<servlet-class>com.qjd.FileSerlvetservlet-class>
servlet>
<servlet-mapping>
<servlet-name>uploadservlet-name>
<url-pattern>/upload.dourl-pattern>
- 导入依赖的jar包
<dependency>
<groupId>commons-fileuploadgroupId>
<artifactId>commons-fileuploadartifactId>
<version>1.4version>
dependency>
<dependency>
<groupId>commons-iogroupId>
<artifactId>commons-ioartifactId>
<version>2.6version>
dependency>
- index.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--
GET：上传文件大小有限制
POST：上传文件大小没有限制
${pageContext.request.contextPath}
--%>
- info.jsp
<%@ page language="java" contentType="text/html;charset=UTF-8"%>
Insert title here
<%=request.getAttribute("msg")%>
到这里JavaWeb绝大部分的知识就结束了，但是我们的学习还没有结束哦，大家要掌握JavaWeb就要多练习几个JavaWeb的实战项目，在项目中成长并深入理解JavaWeb，最后希望大家都得到自己满意的结果(◍•ᴗ•◍)
大家觉得JavaWeb这篇文章还可以的话可以点个赞啊๐•ᴗ•๐
