JavaWeb
1、基本概念
1.1、前言
web开发：
- web：网页的意思，
- 静态web：
- html，css
- 提供给所有人看的数据始终不会有变化
- 动态web：
- 提供给人看的数据会发生变化
- 技术栈：Servlet，JSP，ASP，PHP
在java中，动态资源开发的技术统称为javaweb开发
1.2、web应用程序
web应用程序：可以提供浏览器访问的程序：
- a.html，b.html……多个web资源，这些web资源可以被外界访问，给外界提供服务
- 网上访问到的任何一个资源，都是存在于一台计算机上的
- URL
- 同一的web资源会放在一个文件夹下，web应用程序通过Tomcat服务器来启动
- 一个web应用程序由多个部分组成（静态web、动态web）
- html、css、js
- Servlet、jsp
- java程序
- jar包
- 配置文件（Properties）
1.3、静态Web
缺点：
- Web页面无法更新
- 轮播图，点击特效：伪动态
- JavaScript[实际开发中，运用得最多]
- VBScript
- 无法与数据库交互（数据无法持久化，用户无法交互）
1.4、动态Web
缺点：
- 如果服务器出现了故障，需要重新编写后台程序，重新发布
- 停机维护
优点：
- 可以动态更新
- 可以与数据库交互，用户可以与其进行交互
2、Web服务器
2.1、技术讲解
- ASP
- 微软，国内最早流行
- 在HTML中嵌入了VB脚本，ASP + COM
- JSP
- 开发速度很快，功能很强大，跨平台，代码简单
- 无法承载大量访问量的情况（局限性）
- PHP/Servlet
- 可以解决三高（高并发，高可用，高性能）问题
2.2、Web服务器
服务器是一种被动操作，用来处理用户的一些请求和给用户的一些相应信息
IIS
Tomcat
3、Tomcat
配置启动的端口号
- Tomcat默认端口号：8080
- MySQL：3306
- HTTP：80
- HTTPS：443
<Connector port="8080" protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443" />
配置主机名称
默认主机名位localhost --> 127.0.0.1
默认网站应用存放的位置：webapps
<Host name="localhost" appBase="webapps"
unpackWARs="true" autoDeploy="true">
高难度面试题
请你谈谈网站是如何进行访问的？
1、输入一个域名，按下回车
2、先检查本机的C:\Windows\System32\drivers\etc\hosts配置文件中有无这个域名的映射：
有：直接返回对应的ip地址，，这个地址中，有我们需要访问的web程序，可以直接访问；
没有：去DNS服务器寻找，找到就返回，找不到就返回找不到
网站结构
-- webapps：Tomcat服务器的web目录
- ROOT
- fjstudy：网站的目录名
- WEB-INF
- classes：java程序
- lib：web应用所依赖的jar包
- web.xml：网页配置文件
- index.xml：默认的首页
- static
- css
- style.css
- js
- img
4、Http
4.1、什么是Http
http（超文本传输协议）是一个简单的请求-相应协议，通常运行在TCP上
4.2、两个时代
- http1.0
- HTTP/1.0：客户端可以与web服务器连接，只能获得一个web资源，然后断开连接
- http2.0
- HTTP/1.1：客户端可以与web服务器连接，可以获得多个web资源
4.3、Http请求
- 客户端 — 发请求 — 服务器
百度：
Request URL:https://www.baidu.com/ 请求地址
Request Method:GET get方法/post方法
Status Code:200 OK 状态码：200
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.4、Http响应
- 服务器 — 响应 — 客户端
百度：
Cache-Control:private 缓存控制
Connection:Keep-Alive 连接
Content-Encoding:gzip 编码
Content-Type:text/html 类型
1、响应体
Accept：告诉浏览器，它所支持的数据类型
Accept-Encoding：支持哪种编码格式 GBK UTF-8 GB2312 ISO8859-1
Accept-Language：告诉浏览器，它的语言环境
Cache-Control：缓存控制
Connection：告诉浏览器，请求完成是断开还是保持连接
HOST：主机
Refresh：告诉客户端，多久刷新一次
Location：让网页重新定位
2、响应状态码
200：请求响应成功 200
3XX：重定向
- 重定向：向新的地址寻找
4XX：找不到资源 404 - 资源不存在
5XX：服务器代码错误 500 502（网关错误）
常见面试题：
当你的浏览器中地址栏输入地址并回车的一瞬间到页面能够展示回来，经历了什么？
5、Servlet
5.1、Servlet简介
- Servlet就是sun公司用来开发动态Web的一门技术
- sun在其中添加了一个接口Servlet，如果想要开发一个Servlet程序，只需要两个步骤
- 编写一个类，实现Servlet接口
- 把开发好的java程序部署到web服务器中
我们把实现了Servlet接口的java程序叫做Servlet
5.2、HelloServlet
1、构建一个普通maven项目，删掉其中的src目录，以后就在项目中建立Module
2、Maven环境优化
- 修改web.xml为最新
- 将Maven结构搭建完整
3、编写一个Servlet程序
- 编写一个普通类
- 实现Servlet接口，这里继承HttpServlet
public class HelloServlet extends HttpServlet {
//由于get和post只是请求实现的不同的方式，可以相互调用，业务逻辑都一样
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
PrintWriter writer = resp.getWriter(); //响应流
writer.println("Hello,Servlet");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
4、编写一个Servlet的映射
为什么需要映射？我们写的是java程序，而需要通过浏览器进行访问，而浏览器需要连接web服务器，所以我们需要在web服务器中注册我们的Servlet，还需要给他一个浏览器可以访问的路径
<!-- 注册Servlet -->
<servlet>
<servlet-name>hello</servlet-name>
<servlet-class>com.fj.servlet.HelloServlet</servlet-class>
</servlet>
<!-- Servlet的请求路径 -->
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
5、配置Tomcat
注意：配置项目发布的路径就可以了
6、启动测试
5.3、Servlet原理
Servlet是由web服务器调用，web服务器收到浏览器请求后，会：
5.4、Mapping问题
1、一个Servlet可以指定一个映射路径
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
2、一个Servlet可以指定多个映射路径
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello1</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>
3、一个Servlet可以指定通用映射路径
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello/*</url-pattern>
</servlet-mapping>
4、默认请求路径
<!-- 默认请求路径 -->
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
5、指定一些前缀或者后缀等等
<!-- 可以自定义后缀实现请求映射
注意点：*前面不可以加映射的路径，如/、/hello
-->
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>*.fj</url-pattern>
</servlet-mapping>
6、优先级问题
值定了固有的映射路径优先级最高，如果找不到就走默认的处理请求
<!-- 404 -->
<servlet>
<servlet-name>error</servlet-name>
<servlet-class>com.fj.servlet.ErrorServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>error</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
5.5、ServletContext
web容器在启动的时候，会为每个web程序创建一个对应的ServletContext对象，它代表了当前web应用
1、共享数据
在ServletContext中放置数据内容
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中，名字为username，值为果冻奶酪
System.out.println("Hello");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
创建一个类来获取数据
public class GetServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
ServletContext context = this.getServletContext();
String username = (String)context.getAttribute("username");
resp.setContentType("text/html");
resp.setCharacterEncoding("utf-8");
PrintWriter writer = resp.getWriter();
writer.println("用户名" + username);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
项目中的web.xml文件配置
<servlet>
<servlet-name>hello</servlet-name>
<servlet-class>com.fj.servlet.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>getcontext</servlet-name>
<servlet-class>com.fj.servlet.GetServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>getcontext</servlet-name>
<url-pattern>/getcontext</url-pattern>
</servlet-mapping>
2、获取初始化参数
在web.xml中配置初始化参数
<!-- 配置一些web应用初始化参数 -->
<context-param>
<param-name>url</param-name>
<param-value>jdbc:mysql://localhost:3306</param-value>
</context-param>
在servlet中获取初始化参数
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"); //获取web应用初始化参数
resp.getWriter().print(url);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
在web.xml中配置servlet映射
<servlet>
<servlet-name>getparameter</servlet-name>
<servlet-class>com.fj.servlet.ServletDemo03</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>getparameter</servlet-name>
<url-pattern>/getparameter</url-pattern>
</servlet-mapping>
3、请求转发
public class ServletDemo04 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
ServletContext context = this.getServletContext();
//RequestDispatcher requestDispatcher = context.getRequestDispatcher("/getparameter");//获取请求转发,其中的String字符串是请求转发的路径
//requestDispatcher.forward(req, resp); //调用forward实现请求转发
context.getRequestDispatcher("/getparameter").forward(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
web.xml文件中
<servlet>
<servlet-name>servletdemo4</servlet-name>
<servlet-class>com.fj.servlet.ServletDemo04</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>servletdemo4</servlet-name>
<url-pattern>/servletdemo4</url-pattern>
</servlet-mapping>
4、读取资源文件
Properties
- 在java目录下新建properties
- 在resources目录下新建properties
发现：都被打包到了同一个路径下：classes。我们俗称这个路径为classpath
思路：需要一个文件流
properties文件
username=ro
password=123456
servlet类
public class ServletDemo05 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//第一个/不可以省略，代表的是当前web项目
InputStream is = this.getServletContext().getResourceAsStream("/WEB-INF/classes/com/fj/servlet/aa.properties");
Properties prop = new Properties();
prop.load(is);
String username = prop.getProperty("username");
String password = prop.getProperty("password");
resp.getWriter().print(username + ":" + password);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
5.6、HttpServletResponse
web服务器接收到客户端发送的一个请求，针对这个请求，创建一个代表请求的HttpServletRequest对象，和代表响应的HttpServletResponse对象
- 获取客户端请求的一些参数：HttpServletRequest
- 获取服务器响应的一些参数：HttpServletResponse
1、简单分类
负责向浏览器发送数据的方法
ServletOutputStream getOutputStream() throws IOException;
PrintWriter getWriter() throws IOException;
负责向浏览器发送响应头的方法
void setCharacterEncoding(String var1);
void setContentLength(int var1);
void setContentType(String var1);
void setDateHeader(String var1, long var2);
void addDateHeader(String var1, long var2);
void setHeader(String var1, String var2);
void addHeader(String var1, String var2);
void setIntHeader(String var1, int var2);
void addIntHeader(String var1, int var2);
响应的状态码
int SC_CONTINUE = 100;
int SC_SWITCHING_PROTOCOLS = 101;
int SC_OK = 200;
int SC_CREATED = 201;
int SC_ACCEPTED = 202;
int SC_NON_AUTHORITATIVE_INFORMATION = 203;
int SC_NO_CONTENT = 204;
int SC_RESET_CONTENT = 205;
int SC_PARTIAL_CONTENT = 206;
int SC_MULTIPLE_CHOICES = 300;
int SC_MOVED_PERMANENTLY = 301;
int SC_MOVED_TEMPORARILY = 302;
int SC_FOUND = 302;
int SC_SEE_OTHER = 303;
int SC_NOT_MODIFIED = 304;
int SC_USE_PROXY = 305;
int SC_TEMPORARY_REDIRECT = 307;
int SC_BAD_REQUEST = 400;
int SC_UNAUTHORIZED = 401;
int SC_PAYMENT_REQUIRED = 402;
int SC_FORBIDDEN = 403;
int SC_NOT_FOUND = 404;
int SC_METHOD_NOT_ALLOWED = 405;
int SC_NOT_ACCEPTABLE = 406;
int SC_PROXY_AUTHENTICATION_REQUIRED = 407;
int SC_REQUEST_TIMEOUT = 408;
int SC_CONFLICT = 409;
int SC_GONE = 410;
int SC_LENGTH_REQUIRED = 411;
int SC_PRECONDITION_FAILED = 412;
int SC_REQUEST_ENTITY_TOO_LARGE = 413;
int SC_REQUEST_URI_TOO_LONG = 414;
int SC_UNSUPPORTED_MEDIA_TYPE = 415;
int SC_REQUESTED_RANGE_NOT_SATISFIABLE = 416;
int SC_EXPECTATION_FAILED = 417;
int SC_INTERNAL_SERVER_ERROR = 500;
int SC_NOT_IMPLEMENTED = 501;
int SC_BAD_GATEWAY = 502;
int SC_SERVICE_UNAVAILABLE = 503;
int SC_GATEWAY_TIMEOUT = 504;
int SC_HTTP_VERSION_NOT_SUPPORTED = 505;
2、下载文件
1、向浏览器输出消息
2、下载文件
- 获取下载文件的路径
- 下载的文件名
- 设置浏览器支持要下载的文件
- 获取下载文件的输入流
- 创建缓冲区
- 获取OutPutStream对象
- 将FileOutPutStream写入到buffer缓冲区
- 使用OutPutStream将缓冲区的数据输出到客户端
public class FileServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//1.获取下载文件的路径
String path = this.getServletContext().getRealPath("WEB-INF//classes//1.png");
System.out.println("下载文件的路径" + path);
//2.下载的文件名
String fileName = path.substring(path.lastIndexOf("//") + 1);
//3.设置浏览器支持(Content-Disposition)要下载的文件
//中文名字的情况下，使用URLEncoding.encode设置编码格式为UTF-8，不然可能会乱码
resp.setHeader("Content-Disposition", "attachment;filename+"+ URLEncoder.encode(fileName, "UTF-8"));
//4.获取下载文件的输入流
FileInputStream inputStream = new FileInputStream(fileName);
//5.创建缓冲区
int len = 0;
byte[] buffer = new byte[1024];
//6.获取OutPutStream对象
ServletOutputStream servletOutputStream = resp.getOutputStream();
//7.将FileOutPutStream写入到buffer缓冲区
//8.使用OutPutStream将缓冲区的数据输出到客户端
while((len=inputStream.read(buffer)) != -1){
servletOutputStream.write(buffer, 0, len);
}
servletOutputStream.close();
inputStream.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 {
//如何让浏览器每5秒刷新一次
resp.setHeader("refresh", "5");
//在内存中创建一个图片
BufferedImage image = new BufferedImage(80, 20, BufferedImage.TYPE_INT_RGB);
//得到图片
Graphics2D graphics = (Graphics2D) image.getGraphics();
//设置图片的背景颜色
graphics.setColor(Color.white);
graphics.fillRect(0, 0, 80, 20);
//在图片中加入数据
graphics.setColor(Color.blue);
graphics.setFont(new Font(null, Font.BOLD, 20));
graphics.drawString(random(), 0, 20);
//告诉浏览器用请求图片的方式打开
resp.setContentType("image/jpg");
//网站存在缓存，不让浏览器缓存
resp.setDateHeader("expires", -1);
resp.setHeader("Cache-Control", "no-cache"); //缓存策略为不缓存
resp.setHeader("Pragma", "no-cache");
//将图片响应给浏览器
boolean write = ImageIO.write(image, "jpg", resp.getOutputStream());
}
private String random(){
Random random = new Random();
int i = random.nextInt(99999999);
String num = String.valueOf(i);
//保证生成的随机数必定是7位
StringBuffer buffer = new StringBuffer();
for(int j = 0; j < 7-num.length(); j++){
buffer.append("0");
}
num = buffer.toString() + num;
return num;
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
web.xml文件map映射
<servlet>
<servlet-name>imageservlet</servlet-name>
<servlet-class>com.fj.servlet.ImageServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>imageservlet</servlet-name>
<url-pattern>/imageservlet</url-pattern>
</servlet-mapping>
4、实现重定向
web资源B收到客户端A的资源请求后，通知A去请求另一个web资源C，这就是重定向
常见场景：
- 用户登录
void sendRedirect(String var1) throws IOException;
测试：
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
/*
resp.setHeader("Location", "/response_war/imageservlet");
resp.setStatus(302);
*/
resp.sendRedirect("/response_war/imageservlet"); //重定向
}
面试题：聊聊转发和重定向的区别？
相同点：都实现了页面跳转
不同点：转发页面的URL不会发生变化；重定向页面URL会发生变化
小Demo
注册成功后会跳转到sucess.jsp页面
RequestServlet类
public class RequestTest extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//处理请求
String username = req.getParameter("username");
String password = req.getParameter("password");
System.out.println(username + "：" + password);
//重定向一定要注意路径问题，否则会404
resp.sendRedirect("/response_war/sucess.jsp");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
index.jsp文件
<html>
<body>
<h2>Hello World!</h2>
<%--这里提交的路径，需要寻找到项目的路径（即在web.xml中配置的mapping路径）--%>
<%--${pageContext.request.contextPath}：代表当前项目--%>
<form action="${pageContext.request.contextPath}/login" method="get">
用户名：<input type="text" name="username"/>
<br/>
密码：<input type="password" name="password"/>
<br/>
<input type="submit"/>
</form>
</body>
</html>
sucess.jsp页面
<html>
<head>
<title>Title</title>
</head>
<body>
<h1>Success</h1>
</body>
</html>
5.7、HttpServletRequest
HttpServletRequest代表客户端的请求，用户通过Http协议访问服务器，Http请求中的所有数据封装到HttpServletRequest中；通过HttpServletRequest，可以获得客户端的所有信息
获取前端传递的参数，以及请求转发
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//前端显示和后台接收中文乱码问题
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
String username = req.getParameter("username");
String password = req.getParameter("password");
String[] hobbies = req.getParameterValues("hobbies");
System.out.println("======================================");
System.out.println(username + "：" + password);
System.out.println("爱好：");
for(String hobby : hobbies){
System.out.print(hobby + " ");
}
System.out.println();
System.out.println("======================================");
//通过请求转发
req.getRequestDispatcher("/success.jsp").forward(req,resp);
//resp.sendRedirect("/response_war/success.jsp");
}
index.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>登录</title>
</head>
<body>
<h1>登录</h1>
<div align="center">
<%--以post方式提交表单，将表单提交至login请求--%>
<form action="${pageContext.request.contextPath}/login" method="post">
用户名：<input type="text" name="username"/>
<br/>
密码：<input type="password" name="password"/>
<br/>
爱好：
<input type="checkbox" name="hobbies" value="唱歌">1
<input type="checkbox" name="hobbies" value="电影">2
<input type="checkbox" name="hobbies" value="漫画">3
<br/>
<input type="submit"/>
</form>
</div>
</body>
</html>
6、Cookie和Session
6.1、会话（Session）
会话：用户打开一个浏览器，点击多个超链接，访问多个Web资源，关闭浏览器；这一个过程就是一次会话
有状态会话：一个用户访问过浏览器，下次这个用户再次访问浏览器时，浏览器就会知道这个用户之前访问过；这个就称之为有状态会话
6.2、保存会话的两种技术
cookie
- 客户端技术（响应，请求）
session
- 服务器技术，利用这个技术，可以保存用户的会话信息，可以将信息或者数据放在Session中
常见场景：网站登录后，不用再第二次登录了
6.3、Cookie
1、从请求中拿到Cookie
2、服务器响应给客户端Cookie
Cookie[] cookies = req.getCookies()//从请求中获得Cookie
cookie.getName()//获得Cookie中的key
cookie.getValue()//获得Cookie中的值
new Cookie("LastTime", String.valueOf(System.currentTimeMillis()))//新建一个Cookie
cookie.setMaxAge(24*60*60)//设置Cookie的有效期
resp.addCookie(cookie)//响应给客户端Cookie
Cookie一般会保存在本地的用户 -> AppData文件夹下
一个网站Cookie是否存在上限，一些细节问题
- 一个Cookie只能保存一个信息
- 一个web站点可以给浏览器发送多个Cookie，一般一个浏览器最多20个
- 一个web站点最多存放300个
- Cookie大小上限是4Kb
删除Cookie
- 不设置有效期，关闭浏览器，自动失效
- 设置有效期为0
编码解码：
URLEncoder.encode("果冻奶酪", "utf-8") //编码
URLDecoder.decode(cookie.getValue(), "utf-8") //解码
6.4、Session(重点)
- 服务器会给每一个浏览器创建一个Session对象
- 一个Session独占一个浏览器，只要浏览器不关，Session就不会销毁
- 用户登录后，整个网站Session都可以访问：–>保存用户信息；保存购物车信息……
Session和Cookie的区别：
- Cookie是把用户的数据写给用户的浏览器，浏览器保存(可以保存多个)
- Session把用户的数据写到用户独占的Session中，服务器端保存(保存重要的信息，减少服务器资源的浪费)
- Session对象由服务器创建
使用场景
- 保存一个用户登录的信息
- 购物车信息
- 在整个网站中经常会使用到的数据，我们将他保存在Session中
使用Session
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//解决中文乱码问题
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
//得到Session
HttpSession session = req.getSession();
//往Session中存入数据
session.setAttribute("name", new Person("果冻奶酪", 1));
//获取Session的ID
String id = session.getId();
//判断Session是不是新创建的
if (session.isNew()){
resp.getWriter().write("Session创建成功，ID为" + id);
}else {
resp.getWriter().write("Session已经创建，ID为" + id);
}
//Session在创建时干了什么
// Cookie cookie = new Cookie("JSESSIONID", id);
// resp.addCookie(cookie);
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//解决中文乱码问题
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
//得到Session
HttpSession session = req.getSession();
Person name = (Person) session.getAttribute("name");
System.out.println(name.toString());
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
HttpSession session = req.getSession();
session.removeAttribute("name");
session.invalidate(); //手动注销Session，然后立马生成一个新的Session
}
会话自动过期：web.xml中配置
<!-- 设置Session默认失效时间 -->
<session-config>
<!-- 15分钟后Session自动失效，以分钟为单位 -->
<session-timeout>15</session-timeout>
</session-config>
7、JSP
7.1、什么是JSP
java server pages：java服务器端页面，也和Servlet一样，用于动态Web的开发
最大的特点：
- 写JSP就像是写HTML
- 区别
- HTML只给用户提供静态数据
- JSP页面中可以嵌入Java代码，给用户提供动态信息
7.2、JSP原理
思路：JSP到底如何执行的？
- 代码层面没有任何问题
- 服务器内部工作
- tomcat中有一个work目录
- IDEA中使用tomcat会在IDEA的tomcat中产生一个work目录
jsp文件转为了java文件
浏览器向服务器发送请求，不管访问什么资源，其实都在访问Servlet
JSP最终会转为一个java类
JSP本质上就是一个Servlet，HttpJspBase类就是实现了HttpServlet接口
//初始化
public void _jspInit() {
}
//销毁
public void _jspDestroy() {
}
//JSPService
public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
throws java.io.IOException, javax.servlet.ServletException {
}
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：wirter进行输出
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页面中直接使用
在JSP页面中：
只要是JAVA的代码，就会原封不动的输出；
如果是HTML代码，就会被转换为：
out.write("<html>\r\n");
这样的格式，输出到前端
7.3、JSP基础语法
任何语言都有自己的语法，JAVA中由，JSP中作为JAVA技术的一种应用，他有自己一些扩充的技术（了解，知道即可），Java所有语法都支持
JSP表达式
<%-- JSP表达式
作用：将程序的输出，输出到客户端
<%= 变量或者表达式%>
--%>
<%= new java.util.Date()%>
JSP脚本片段
<%-- JSP脚本片段 --%>
<%
int sum = 0;
for (int i = 0; i <= 100; i++){
sum += i;
}
out.println("<h1>sum=" + sum + "</h1>");
%>
脚本片段的再实现
<%
int x = 10;
out.println(x);
%>
<p>这是一个JSP文档</p>
<%
int y = 2;
out.println(y);
%>
<hr/>
<%-- 在代码中嵌入HTML元素 --%>
<%
for (int i = 0; i < 3; i++){
%>
<h1>hello <%= i%></h1>
<%
}
%>
JSP声明
<%!
static {
System.out.println("Loading Servlet!");
}
private int globalVar = 0;
public void fj(){
System.out.println("fj");
}
%>
JSP声明：会被编译到JSP生成的java类中，其他的都会在_jspService()方法中
在JSP，嵌入java代码即可
<%%>脚本片段
<%=%>表达式
<%!%>声明
<%----%>注释
7.4、JSP指令
<%@ page args.... %>
<%@ include file="" %>
用法和区别
<%-- %@ include会将两个页面合二为一 --%>
<%@ include file="common/header.jsp"%>
<h1>Body</h1>
<%@ include file="common/footer.jsp"%>
在_jsp.java中效果如下
<%-- JSP标签
jsp:include拼接页面，本质还是三个页面
--%>
<jsp:include page="/common/header.jsp"/>
<h1>Body</h1>
<jsp:include page="/common/footer.jsp"/>
在_jsp.java中效果如下
区别：<%@ include file="" %>是将页面和为一个整的页面，如果在其他拼接的页面中存在了定义相同的变量，是不会报错；而在<jsp:include page=""/>中如果有相同定义的变量，则会报错
7.5、9大内置对象
- PageContext
- Request
- Response
- Application【ServletContext】
- config【ServletConfig】
- session
- out
- page
- exception
pageContext.setAttribute("name1", "a1");//保存的数据只在一个页面中有效
request.setAttribute("name2", "a2");//保存的数据只在一次请求中有效，请求转发会携带这个数据
session.setAttribute("name3", "a3");//保存的数据只在一次会话中有效，从打开浏览器到关闭浏览器
application.setAttribute("name4", "a4");//保存的数据在服务器有效，从打开服务器到关闭服务器
request：客户端向服务器发送请求，产生的数据，用户看完就没用了，比如：新闻等
session：客户端向服务器发送请求，产生的数据，用户用完一会儿还有用，比如：购物车等
application：客户端向服务器发送请求，产生的数据，一个用户用完了，其他用户还可以用，比如聊天数据等
//通过寻找的方式从pageContext中取出
//从底层到高层(作用域)： page->request->session->application
//JVM：双亲委派机制：
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"); //不存在
使用${}如果是空值就不会显示，而<%= %>如果是空值就会显示为null
<%--使用EL表达式输出--%>
<h1>取出的值为：</h1>
<h3>${name1}</h3>
<h3>${name2}</h3>
<h3>${name3}</h3>
<h3>${name4}</h3>
<h3>${name5}</h3>
<h3> <%= name5%> </h3>
7.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标签
<%--
http://localhost:8080/jsptag.jsp?name=1&age=2
--%>
<jsp:forward page="jsptag2.jsp">
<jsp:param name="name" value="1"/>
<jsp:param name="age" value="2"/>
</jsp:forward>
JSTL表达式
JSTL标签库的使用就是为了弥补HTML的不足：它自定义很多标签，，可以来供我们使用，标签的功能和java一样
核心标签（掌握部分）
JSTL标签使用步骤：
- 导入对应的taglib
- 使用其中的方法
- 在Tomcat中也需要引入JSTL和standard的包，否则会报JSTL解析错误
c:if的使用
<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>
<%--判断如果登录的用户是管理员，则登录成功--%>
<c:if test="${param.username=='admin'}" var="isAdmin">
<c:out value="欢迎登录"/>
</c:if>
<c:out value="${isAdmin}"/>
</body>
c:when的使用
<body>
<%--定义一个变量score，值为85--%>
<c:set var="score" value="85"/>
<c:choose>
<c:when test="${score >= 90}">
成绩为优秀
</c:when>
<c:when test="${score >= 80 && score < 90}">
成绩为良好
</c:when>
<c:when test="${score >= 60 && score < 80}">
成绩为及格
</c:when>
</c:choose>
</body>
c:forEach的使用
<%
ArrayList<String> list = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五");
list.add("赵六");
list.add("田七");
request.setAttribute("list", list);
%>
<%--
var：每一次遍历出来的变量
items：要遍历的对象
begin：起始
end：终止
step：步长
--%>
<c:forEach var="people" items="${list}">
<c:out value="${people}"/>
<br/>
</c:forEach>
<hr>
<c:forEach var="people" items="${list}" begin="1" end="3" step="2">
<c:out value="${people}"/>
<br/>
</c:forEach>
8、JavaBean
实体类
JavaBean特有的写法：
- 必须有一个无参构造
- 属性必须私有化
- 必须有对应的get/set方法
一般用来和数据库的字段作映射 ORM
ORM：对象关系映射
- 表–>类
- 字段–>属性
- 行记录–>对象
9、MVC三层架构
什么是MVC：Model（模型）、View（视图）、Controller（控制器）
9.1、早期的架构
用户直接访问控制层，控制层可以直接访问和操作数据库：
9.2、MVC三层架构
servlet-->CRUD-->数据库
弊端：程序非常臃肿，并且不利于维护
servlet的代码中：处理请求、视图跳转、JDBC的处理，逻辑代码的处理，业务代码的处理
Model：
- 业务处理：业务逻辑(Service)
- 数据持久层：CRUD(DAO)
View：
- 展示数据
- 提供链接，发起Servlet请求(a，form，image)
Controller(Servlet)：
- 接收用户请求：(request：请求参数、session信息)
- 交给业务层处理对应的代码
- 控制视图跳转
登录--->接收用户的请求--->处理用户的请求(获取用户登录的参数)--->交给业务层处理登录业务
(判断用户名密码是否正确)--->DAO层查询用户名和密码是否正确--->查询数据库
10、过滤器（Filter）【重点】
Filter：用来过滤网站的数据；
- 处理中文乱码
- 登录验证
- ……
Filter开发步骤：
- 导包
- 编写过滤器
- 导包导入java.servlet下的filter
实现Filter接口，重写对应的方法即可
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);
3.
*/
@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中配置Filter
<filter>
<filter-name>CharacterEncodingFilter</filter-name>
<filter-class>com.fj.filter.CharacterEncodingFilter</filter-class>
</filter>
<!-- 只要是/servlet下的请求，都会经过该过滤器 -->
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<url-pattern>/servlet/*</url-pattern>
</filter-mapping>
11、监听器（Listener）
1、编写一个监听器
实现一个监听器的接口
//统计网站在线人数：统计session
public class OnlineCountListener implements HttpSessionListener {
//创建session监听
//一旦创建Session，就会触发这个事件
@Override
public void sessionCreated(HttpSessionEvent httpSessionEvent) {
ServletContext servletContext = httpSessionEvent.getSession().getServletContext();
System.out.println(httpSessionEvent.getSession().getId());
Integer onlineCount = (Integer) servletContext.getAttribute("OnlineCount");
if (onlineCount == null){
onlineCount = new Integer(1);
}else{
int count = onlineCount.intValue();
onlineCount = new Integer(count + 1);
}
servletContext.setAttribute("OnlineCount", onlineCount);
}
//销毁session监听
//一旦销毁Session，就会触发这个事件
@Override
public void sessionDestroyed(HttpSessionEvent httpSessionEvent) {
ServletContext servletContext = httpSessionEvent.getSession().getServletContext();
Integer onlineCount = (Integer) servletContext.getAttribute("OnlineCount");
if (onlineCount == null){
onlineCount = new Integer(0);
}else{
int count = onlineCount.intValue();
onlineCount = new Integer(count - 1);
}
servletContext.setAttribute("OnlineCount", onlineCount);
}
}
2、web.xml中注册监听器
<!-- 注册监听器 -->
<listener>
<listener-class>com.fj.listener.OnlineCountListener</listener-class>
</listener>
12、过滤器、监听器的常见应用
监听器：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(Color.WHITE); //设置背景颜色
panel.setBounds(50, 50, 300, 300);
panel.setBackground(Color.GREEN);
frame.add(panel);
frame.setVisible(true);
//监听事件，监听关闭事件
frame.addWindowListener(new WindowAdapter() {
@Override
public void windowClosing(WindowEvent e) {
super.windowClosing(e);
}
});
}
}
用户登陆后才能进入个人主页，注销后就不能进入个人主页
1、用户登录后，向Session中放入用户的数据
2、进入主页的时候判断用户是否登录（在过滤器中实现）
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 {
HttpServletRequest request = (HttpServletRequest) servletRequest;
HttpServletResponse response = (HttpServletResponse) servletResponse;
if (request.getSession().getAttribute(Constant.USER_SESSION) == null){
response.sendRedirect("/fail.jsp");
}
filterChain.doFilter(servletRequest, servletResponse);
}
@Override
public void destroy() {
}
}
13、JDBC
JDBC：Java连接数据库
导入jar包支持：
- java.sql
- javax.sql
- mysql-connector-java 连接驱动【必须要导入】
实验环境搭建
导入数据库依赖
<!-- MySQL的驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.11</version>
</dependency>
可能出现的问题
解决方案：
在pom.xml中加入以下代码
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.encoding>UTF-8</maven.compiler.encoding>
<java.version>9</java.version>
<maven.compiler.source>9</maven.compiler.source>
<maven.compiler.target>9</maven.compiler.target>
</properties>
JDBC固定六个步骤：
1、连接驱动
2、连接数据库
3、获取SQL对象Statement
4、编写SQL，
5、遍历输出
6、关闭连接，释放资源
//获取配置信息
String url = "jdbc:mysql://localhost:3306/jdbc?useSSL=false&useUnicode=false&serverTimezone=GMT";
String username = "root";
String password = "fj123456";
//加载驱动
Class.forName("com.mysql.cj.jdbc.Driver");
//连接数据路，代表数据库
Connection connection = DriverManager.getConnection(url, username, password);
//向数据库发送SQL的对象Statement : CRUD
Statement statement = connection.createStatement();
//编写SQL
String sql = "select * from users";
//执行SQL，返回一个ResultSet：结果集
ResultSet resultSet = statement.executeQuery(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"));
}
//关闭连接，释放资源
resultSet.close();
statement.close();
connection.close();
预编译SQL
//获取配置信息
String url = "jdbc:mysql://localhost:3306/jdbc?useSSL=false&useUnicode=false&serverTimezone=GMT";
String username = "root";
String password = "fj123456";
//加载驱动
Class.forName("com.mysql.cj.jdbc.Driver");
//连接数据路，代表数据库
Connection connection = DriverManager.getConnection(url, username, password);
//编写SQL
String sql = "insert into users(id, name, password, email, birthday) values (?,?,?,?,?)";
//使用预编译SQL，PreparedStatement：CRUD
PreparedStatement preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, 4);//给第一个占位符？赋值为4
preparedStatement.setString(2, "赵六");//给第二个占位符？赋值为赵六
preparedStatement.setString(3, "123456");//给第三个占位符？赋值为123456
preparedStatement.setString(4, "zl@qq.com");//给第四个占位符？赋值为zl@qq.com
preparedStatement.setDate(5, new Date(new java.util.Date().getTime()));//给第五个占位符？赋值为new Date(new java.util.Date().getTime())
//执行SQL
int i = preparedStatement.executeUpdate();
if (i > 0){
System.out.println("插入成功");
}
//关闭连接，释放资源
preparedStatement.close();
connection.close();
事务
ACID原则：保证数据的安全
开启事务
事务提交 commit()
事务回滚 rollback()
关闭事务
转账：
A：1000
B：1000
A（900） --100--> B（1100）
Junit单元测试
依赖
<!-- 单元测试 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
@Test只有在方法上才有效
扫一扫
3245
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
