基本概念
web开发:
- web 网页的意思
- 静态web
- html,css
- 提供给所有人看的数据,始终不会发生变化!
- 动态web
- 几乎所有的网站,都是动态的。
- 提供给所有人看的数据始终会发生变化,每个人在不同的时间,不同的地点看到的信息各不相同!
- 技术栈:Servlet/JSP,ASP ,PHP
在java中,动态web资源开发的技术统称为javaweb。
web应用程序
web应用程序:可以提供浏览器访问的程序;
- a.html、b.html…多个web资源,这些web资源可以被外界访问,对外界提供服务;
- 能访问到的任何一个页面或者资源,都存在与这个世界的某一个角落的计算机上。
- URL
- 这个统一的web资源被放在同一个文件夹下,web应用程序–》Tomcat 服务器
- 一个web应用由多部分组成(静态web,动态web)
- html,css,js
- jsp,servlet
- Java程序
- jar包
- 配置文件(properties)
web应用程序编写完毕后,若想提供给外界访问:需要一个服务器来统一管理;
静态web
- *.htm *.html,这些都是网页的后缀,如果服务器上一直存在这些东西,我们就可以直接进行读取。通过网络访问。
- 静态web存在的缺点
- web页面无法动态更新,所有用户看到的都是同一个页面
- 轮播图,点击特效:伪动态
- JavaScript【实际开发中,它用的最多】
- VBScript
- 它无法和数据库交互(数据无法持久化,用户无法交互)
- web页面无法动态更新,所有用户看到的都是同一个页面
动态web
页面会动态展示:“Web的页面展示的效果因人而异”;
缺点:
- 假如服务器的动态web资源出现了错误,我们需要重新编写我们的后天程序,重新发布
- 停机维护
优点:
- 停机维护
- web页面可以动态更新,所有用户看到的都不是同一个页面
- 它可以和数据库交互(数据持久化:注册,商品信息,用户信息)
web服务器
技术讲解
ASP:
- 微软:国内最早流行的就是ASP
- 在HTML中嵌入了VB的脚本,ASP+COM
- 在ASP开发综合,基本一个页面都有几千行的业务代码,页面极其混乱【在HTML文件代码中嵌套JAVA代码】
- 维护成本高
- C#
- IIS
PHP: - PHP开发速度很快,功能很强大,跨平台,代码很简单(70%,WP)
- 无法承载大访问量的情况(局限性)
JSP/Servlet: - sun公司主推的B/S架构
- 基于java语言(所有的大公司,或者一些开源的组件,都是用JAVA写的)
- 可以承载三高问题带来的影响(高可用,高并发,高性能)
- 语法像ASP,加强市场强度
web服务器
服务器是一种被动的操作,用来处理用户的一些请求和给用户一些响应信息
IIS
微软的;ASP。。,windows中自带的
Tomcat
对于一个Java初学web的人来说,它是最佳的选择。
工作3-5年之后,可以尝试手写Tomcat服务器
下载Tomcat:
- 安装或解压
- 了解配置文件及目录结构
- 这个东西的作用
Tomcat
文件夹作用
bin 启动关闭的脚本文件
conf 配置
lib 依赖的jar包
webapps 存放网站的
logs 日志
server.xml
可以配置启动的端口号
端口号:
Tomcat 8080
mysql 3306
http 80
https 443
可以配置主机的名称【C盘 HOST】
默认的主机名为:localhost-》127.0.0.1
默认网站应用存放的位置为:webapps
请你谈谈网站是如何进行访问的?
- 输入一个域名,回车
- 检查本机的 C:\Windows\System32\drivers\etc\hosts配置文件下是否有这个域名映射;【有:直接返回对应的ip地址,这个地址中,有我们需要访问的web程序,可以直接访问;没有:去DNS服务器找,找到的话就返回,找不到就返回找不到】
【DNS服务器,全世界的域名都在这里管理】
发布一个web网站
- 将自己写的网站,放在服务器(Tomcat)中指定的web应用的文件夹(webapps)下,就可以访问了。
网站应该有的结构
--webapps: Tomcat 服务器的web目录
--ROOT
--laomao :网站的目录名
- WEB-INF
- classes:java程序
- lib:web应用所依赖的jar包
- web.xml:网站配置文件
- index.html 默认的首页
- static
- css
- style.css
- js
- img
- .....
Http
什么是http
HTTP(超文本传输协议)是一个简单的请求响应协议,它通常运行在TCP之上。
- 文本:html,字符串, 。。。
- 超文本:图片,音乐,视频,定位,地图。。。
HTTPS(安全的)
两个时代
- http 1.0
- HTTP/1.0:客户端与web服务器连接后,只能获得一个web资源,断开连接
- http 2.0
- HTTP/1.1:客户端与web服务器连接后,可以获得多个web资源。
http请求
- 客户端–发请求(request)–服务器
Request URL:https://www.baidu.com/ // 请求地址
Request Method:GET // get方法、post方法
Status Code:200 OK // 状态码:200
Remote(远程) Address:14.215.177.39:443
- 请求行
- 请求行中的请求方式:GET
- 请求方式:Get,Post,HEAD ,DELETE,PUT,TRACT…
- get:请求能够携带的参数比较少,大小有限制,会在浏览器的URL地址栏显示数据内容,不安全,但高效
- post:请求能够携带的参数没有限制,大小没有限制,不会再浏览器的URL地址栏显示数据内容,安全,但不高效
- 消息头
- Accept 告诉浏览器,它所支持的数据类型
- Accept-Encoding:支持哪种编码格式 GBK UTF-8 GB2312 ISO8859-1
- Accept-Language: 告诉浏览器,它的语言环境
- Cache-Control:缓存控制
- Connection:告诉浏览器,请求完成是断开还是保持连接
- HOST:主机。。。
http响应
- 服务器–响应–客户端
Cache-Control:private 缓存控制
Connection:Keep-Alive 连接
Content-Encoding:gzip 编码
Content-Type:text/html 类型
- 响应体
- Accept 告诉浏览器,它所支持的数据类型
- Accept-Encoding:支持哪种编码格式 GBK UTF-8 GB2312 ISO8859-1
- Accept-Language: 告诉浏览器,它的语言环境
- Cache-Control:缓存控制
- Connection:告诉浏览器,请求完成是断开还是保持连接
- HOST:主机。。。
- Refrush:刷新,告诉客户端,多久刷新一次
- Location:让网页重新定位
- 响应状态码
200 请求响应成功 200
3** 请求重定向
- 重定向:你重新到我给你的新地址
4XX:找不到资源 404 - 资源不存在
5XX:服务器代码错误 500 502:网关错误
当你的浏览器中地址栏并回车的一瞬间到页面能够展示回来,经历了什么?
Maven
- 在javaweb开发中,需要使用大量的jar包,我们手动去导入
- 如何能够让一个东西自动帮我导入和配置这个jar包
由此,Maven诞生了
Maven架构管理工具
我们目前就是方便导入jar包的!
Maven的核心思想:约定大于配置!
- 有约束,不要去违反。
Maven会规定该如何去编写我们的Java代码,必须要按照这个规范来!
官网下载完成解压即可!
配置环境变量
M2_HOME【Maven下bin目录】
MAVEN_HOME【Maven目录】
阿里云镜像
镜像:mirrors
作用:加速我们的下载
国内建议使用阿里云镜像
本地仓库
在本地的仓库,远程仓库;
建立一个本地仓库:localRepository
在IDEA中使用Maven
- 启动IDEA
- 创建一个MavenWeb项目
- 等待项目初始化完毕
- 观察maven仓库中多了什么东西
- IDEA中的Maven设置
IDEA中配置Maven
注意:经常在IDEA中会出现一个问题,就是项目自动创建完成后,它这个MavenHome会使用IDEA默认的,我们如果发现这个问题,手动改为本地的。 - 到这里,Maven在IDEA中的配置和使用就OK了。
创建一个普通的Maven项目
不选模板
- main\java 【放置Java源代码的】
- main\resources 【放置一些配置文件的】
- test\java 【测试使用】
- 初始的maven配置文件
在IDEA中标记文件夹功能
remark
在IDEA中配置Tomcat
解决警告问题
为什么会有这个问题:我们访问一个网站,需要指定一个文件夹名字;【必须要做的】
Application content: 可以写可以不写,默认访问路径为localhost:8080
假如写了一个 /laomao 路径为localhost:8080/laomao
这个过程叫做,虚拟路径映射。
IDEA右边栏Maven projects
Lifecycle 【maven的命令行操作】
Plugins 【插件,甚至可以删掉】
Dependencies 【项目依赖:一个个的jar包】
pom文件
<!--Maven版本和头文件>
<!--配置的groupId、artifactId、version-->
<!--Package:项目打包方式
jar:java应用
war:javaweb应用-->
<!--配置-->properties
<!--项目的默认构建编码-->
<!--编码版本-->
<!--项目依赖-->
<!--具体的jar包配置文件-->
Maven的高级之处在于,它会帮你导入这个jar包所依赖的其他jar包。
Maven由于它的约定大于配置,我们之后可能遇到我们写的配置文件,无法被导出或者生效的问题,解决方案:
在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>
IDEA操作
目录树:Maven中的jar包的联系关联图。
Servlet
servlet简介
- servlet就是sun公司开发动态web的一门技术
- Sun公司在这些API中提供了一个接口叫做:Servlet,如果你想开发一个Servlet程序,只需要完成两个小步骤:
- 编写一个类,实现Servlet接口
- 把开发好的java类部署到微博服务器中
把实现了Servlet接口的Java程序叫做,Servlet
HelloServlet
Servlet接口在Sun公司有两个默认的实现类:HttpServlet,
- 构建一个普通的Maven项目,删掉里面的src目录,以后我们的学习就在这个项目里面建立Module;这个空的工程就是Maven的主工程;
- 关于maven父子工程的理解:
父项目中会有
子项目中有<modules> <module>servlet-01</module> </modules>
父项目中的jar包子项目可以直接使用。<parent> <artifactId>javaweb-01-maven02</artifactId> <groupId>com.laomao</groupId> <version>1.0-SNAPSHOT</version> </parent>
3. Maven环境优化
1. 修改web.xml为最新的
2. 将Maven的结构搭建完整【java和resources】
4. 编写一个Servlet
1. 编写一个普通类
2. 实现Servlet接口,这里我们直接继承HttpServlet
package com.laomao.servlet;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
public class HelloServlet extends HttpServlet {
// 由于get和post知识请求实现的不同的方式,可以互相调用,业务逻辑都一样
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// ServletOutputStream outputStream = resp.getOutputStream();
PrintWriter writer = resp.getWriter(); //响应流
writer.print("Hello,Servlet");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doPost(req, resp);
}
}
- 编写Servlet的映射
为什么需要映射:我们写的是java程序,但是要通过浏览器访问,而浏览器需要连接web服务器,所以我们需要在web服务器中注册我们要写的Servlet,还需要给它一个浏览器能够访问的路径;<!-- 注册servlet--> <servlet> <servlet-name>hello</servlet-name> <servlet-class>com.laomao.servlet.HelloServlet</servlet-class> </servlet> <!-- servlet的请求路径--> <servlet-mapping> <servlet-name>hello</servlet-name> <url-pattern>/hello</url-pattern> </servlet-mapping>
- 配置Tomcat
配置项目发布的路径 - 启动测试
Servlet原理
Servlet是由Web服务器调用,web服务器在收到浏览器请求之后,会:
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>/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>
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello4</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello5</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>*.laomao</url-pattern>
</servlet-mapping>
- 优先级问题
指定了固有的映射路径优先级最高,如果找不到就会走默认的处理请求。
<!-- Error-->
<servlet>
<servlet-name>error</servlet-name>
<servlet-class>com.laomao.servlet.ErrorServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>error</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
ServletContext
web容器在启动的时候,它会为每个web程序都创建一个对应的ServletContext对象,它代表了当前的web应用;
1. 共享数据
我在这个Servlet中保存的数据,可以在另外一个Servlet中拿到
存放数据的类
public class HelloWorld 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,值为username
}
}
得到数据的类
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");
resp.getWriter().print(username);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
配置xml
<servlet>
<servlet-name>hello</servlet-name>
<servlet-class>com.laomao.servlet.HelloWorld</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>get</servlet-name>
<servlet-class>com.laomao.servlet.GetServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>get</servlet-name>
<url-pattern>/get</url-pattern>
</servlet-mapping>
2. 获取初始化参数
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 {
super.doPost(req, resp);
}
}
<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.laomao.servlet.ServletDemo03</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>gp</servlet-name>
<url-pattern>/gp</url-pattern>
</servlet-mapping>
3. 请求转发
dispatcher
public class ServletDemo04 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
ServletContext context = this.getServletContext();
context.getRequestDispatcher("/gp").forward(req,resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
4. 读取资源文件
Properties
- 在java目录下新建properties
- 在resources目录下新建properties
都被打包到了同一路径下:classes,我们俗称这个路径为classpath
==思路:==需要一个文件流;
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");
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);
}
}
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);
2. 常见应用
- 向浏览器输出消息
- 下载文件
- 要获取下载文件的路径
- 下载的文件名是啥
- 设置想办法让浏览器能够支持下载我们需要的东西
- 获取下载文件的输入流
- 创建缓冲区
- 获取OutputStream对象
- 将FileOutputStream流写入到buffer缓冲区
- 使用OutputStream将缓冲区中的数据输出到客户端
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 要获取下载文件的路径
String realPath = "F:\\kuangshenJAVA\\project\\javaweb-01-maven02\\response\\target\\classes\\1.jpg";
System.out.println("下载文件的路径:"+realPath);
// 下载的文件名是啥
String fileName = realPath.substring(realPath.lastIndexOf("\\") + 1);
// 设置想办法让浏览器能够支持(Content-Disposition)下载我们需要的东西,中文文件名URLEncoder.encoder编码,否则有可能乱码
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();
}
3. 验证码功能
验证怎么来的?
- 前端实现
- 后端实现,需要用到Java的图片类,生成一个图片
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 如何让浏览器5秒刷新一次;
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/png");
// 网站存在缓存,不让浏览器缓存
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(99999999) + "";
StringBuffer sb = new StringBuffer();
for (int i = 0; i < 7-num.length(); i++) {
sb.append("0");
}
num = sb.toString() + num;
return num;
}
4. 重定向
一个web资源收到客户端请求后,它会通知客户端去访问另外一个web资源C,这个过程叫重定向
常见场景:
- 用户登录
void sendRedirect(String var1) throws IOException;
测试:
resp.sendRedirect("/r/img"); // 重定向
/*
resp.setHeader("Location", "/r/img");
resp.setStatus(302);
*/
面试题: 请你聊聊重定向和转发的区别?
相同点:
- 页面都会实现跳转
不同点 - 请求转发的时候,url不会发生变化;
- 重定向时,url地址栏会发生变化。
@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");
}
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);
System.out.println(password);
System.out.println(Arrays.toString(hobbies));
System.out.println("===============================");
System.out,println(req.getContextPath());
// 通过请求转发
// 这里的 / 代表当前的web应用
req.getRequestDispatcher("/success.jsp").forward(req, resp);
}
面试题: 请你聊聊重定向和转发的区别?
相同点:
- 页面都会实现跳转
不同点 - 请求转发的时候,url不会发生变化; 307
- 重定向时,url地址栏会发生变化。 302
Cookie/Session
会话
会话:用户打开一个浏览器,点击了很多超链接,访问多个web资源,关闭浏览器,这个过程可以称之为会话;
有状态会话:一个同学来过教室,下次再来教室,我们会知道这个同学,曾经来过,称之为有状态会话;
一个网站,怎么证明你来过?
客户端 服务端
- 服务端给客户端一个信件,客户端下次访问服务端带上信件就可以了;cookie
- 服务器登记你来过了,下次你来的时候我来匹配你; session
保存会话的两种技术
cookie
- 客户端技术(响应,请求)
session - 服务器技术,利用这个技术,可以保存用户的会话信息,我们可以把信息或者数据放在session中。
常见场景:网站登录之后,你下次不用再登录了,第二次访问不需要登录。
Cookie
- 从请求中拿到cookie信息
- 服务器响应给客户端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
cookie:一般会保存在本地的 用户目录下 appdata;
一个网站cookie是否存在上限!
- 一个cookie只能保存一个信息;
- 一个web站点可以给浏览器发送多个cookie,最多存放20个cookie;
- Cookie大小有限制4kb;
- 300个cookie浏览器上限
删除Cookie;
- 不设置有效期,关闭浏览器,自动失效;
- 设置有效期为0。
Cookie cookie = new Cookie("lastLoginTime", System.currentTimeMillis() + "");
cookie.setMaxAge(0);
resp.addCookie(cookie);
中文数据传递(编码解码,CookieValue值为中文时)
// 中文数据传递
public class CookieDemo03 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
// 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中的值
out.write(URLDecoder.decode(cookie.getValue(),"utf-8"));
}
}
}else{
out.write("这是您第一次访问本站");
}
Cookie cookie = new Cookie("name", URLEncoder.encode("老猫","utf-8"));
resp.addCookie(cookie);
}
Session (重点)
什么是Session:
- 服务器会给每一个用户(浏览器)创建一个Session对象;
- 一个Session独占一个浏览器,只要浏览器没有关闭,这个Session就存在;
- 用户登录之后,整个网站它都可以访问。–>保存用户的信息;保存购物车的信息。。。
Session和Cookie的区别:
- Cookie是把用户的数据写给用户的浏览器,浏览器保存
- 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("laomao",1));
// 获取Session的ID
String sessionId = session.getId();
// 判断Session是不是新创建的
if (session.isNew()){
resp.getWriter().write("session创建成功,ID:"+sessionId);
}else{
resp.getWriter().write("session已经在服务器中存在了,ID:"+sessionId);
}
// //Session 创建的时候做了什么事情;
// Cookie cookie = new Cookie("JSESSIONID", sessionId);
// resp.addCookie(cookie);
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 解决乱码问题
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
// 得到Session
HttpSession session = req.getSession();
Person person = (Person) session.getAttribute("name");
System.out.println(person.toString());
}
两种Session失效的方式
// Servlet
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
HttpSession session = req.getSession();
session.removeAttribute("name");
// 手动注销Session
session.invalidate();
}
// web.xml中设置
<!--设置Session默认的失效时间-->
<session-config>
<!--15分钟后Session自动失效,以分钟为单位-->
<session-timeout>15</session-timeout>
</session-config>
使用场景:
- 保存一个登录用户的信息;
- 购物车信息;
- 在整个网站中经常会使用的数据,我们将它保存在Session中。
JSP
什么是JSP
Java Server Pages:Java服务器端页面,也和Servlet一样,用于动态Web技术。
最大的特点:
- 写JSP就像在写HTML
- 区别:
- HTML只给用户提供静态的数据
- JSP页面中可以嵌入JAVA代码,为用户提供动态数据;
JSP原理
思路:JSP怎么执行的。
- 代码层面没有任何问题
- 服务器内部工作
Tomcat中有一个work目录;
IDEA中使用Tomcat会在IDEA中产生一个work目录
C:\Users\asus\.IntelliJIdea2019.3\system\tomcat\Tomcat_8_5_50_javaweb-session-cookie\work\Catalina\localhost\ROOT\org\apache\jsp
页面转成了Java程序。
浏览器向服务器发送请求,不管访问什么资源,其实都是在访问Servlet。
JSP最终也会被转化成为一个Java类。
JSP本质上就是一个Servlet。
// 初始化
public void _jspInit(){}
// 销毁
public void _jspDestory(){}
// JSPService
public void _jspService(.HttpServletRequest request, HttpServletPesponse response)
- 判断请求
- 内置了一些对象
final javax.servlet.jsp.PageContext pageContext; //页面上下文
javax.servlet.http.HttpSession = 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 // 请求
HttpServletPesponse response // 响应
- 输出页面前增加的代码
response.setContextType("text/html"); // 设置响应的页面类型
pageContext = _jspxFactory.getPageContext(this,request, response, null, true, 8192, true);
_jspx_page_context = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
_jspx_out = out;
- 以上的这些对象,我们可以在JSP页面中直接使用。
在JSP页面中,只要是Java代码,就会原封不动的输出;
如果是HTML代码,就会被转化为
out.write("<html>\r\n");
out.write("name");
这样的格式,输出到前端。
JSP基础语法
任何语言都有自己的语法,Java中有,JSP作为Java技术的一种应用,它拥有一些自己扩充的语法(了解,知道即可)。Java所有语法都支持!
JSP表达式
<%--JSP表达式
作用:用来将程序的输出,输出到客户端
<%= 变量或者表达式%>
--%>
<%= new java.util.Date()%>
JSP脚本片段
<%-- JSP 脚本片段--%>
<%
int sum = 0;
for (int i = 1; i <= 100; i++) {
sum+=i;
}
out.println("<h1>Sum="+sum+"</h1>");
%>
JSP 脚本片段的再实现
<%
int x = 10;
out.println(x);
%>
<p>这是一个JSP文档</p>
<%
int y = 20;
out.println(y);
%>
<%-- 在代码中嵌入HTML元素--%>
<%
for (int i = 0; i < 5; i++) {
%>
<h1>hello,world!</h1>
<%
}
%>
<hr>
JSP 声明
<%!
static {
System.out.println("Loading Servlet!");
}
private int globalVar = 0;
public void mao(){
System.out.println("进入了方法mao");
}
%>
JSP声明:会被编译到JSP生成Java的类中。其他的,就会被生成到_jspService方法中!
在JSP,嵌入java代码即可。
<%%>
<%=%>
<%!%>
<%--注释--%>
JSP的注释,不会再客户端显示,HTML就会显示!
JSP指令
<%@ page args ... %>
<%@ include file=""%> // 提取公共页面
公共页面,常用下面的方式,更加灵活
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<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>
九大内置对象
- PageContext 存东西
- Request 存东西
- Response
- Session 存东西
- Application 【ServletContext】 存东西
- config 【ServletConfig】
- out
- page 不用
- exception
寻找值最好使用EL表达式!
<%--内置对象--%>
<%
pageContext.setAttribute("name1","老猫1号"); // 保存的数据只在一个页面中有效
request.setAttribute("name2","老猫2号"); // 保存的数据只在一次请求中有效,请求转发会携带这个数据
session.setAttribute("name3","老猫3号"); // 保存的数据只在一次会话中有效,从打开浏览器到关闭浏览器
application.setAttribute("name4","老猫4号"); // 保存的数据只在服务器中有效,从打开服务器到关闭服务器
%>
<%--脚本片段中的代码,会原封不动的生成到.jsp.java
要求:这里面的代码:必须保证Java语法的正确性
--%>
<%
// 从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表达式输出 ${} --%>
<h1>取出的值为:</h1>
<h3>${name1}</h3>
<h3>${name2}</h3>
<h3>${name3}</h3>
<h3>${name4}</h3>
<h3>${name5}</h3>
request:客户端向服务器发送请求,产生的数据,用户看完就没用了,比如:新闻,用户看完没用的;
Session:客户端向服务器发送请求,产生的数据,用户用完一会还会用,比如:购物车;
application:客户端向服务器发送请求,产生的数据,一个用户用完了,其他用户还可能使用,比如:聊天数据。
JSP标签,JSTL标签,EL表达式
<!--JSTL表达式的依赖-->
<dependency>
<groupId>javax.servlet.jsp.jstl</groupId>
<artifactId>jstl</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--%>
<%--
http://localhost8080/jsptag.jsp?name=laomao&age=12
--%>
<jsp:forward page="/jsptag2.jsp">
<jsp:param name="name" value="laomao"></jsp:param>
<jsp:param name="age" value="12"></jsp:param>
</jsp:forward>
JSTL表达式
JSTL标签库的使用就是为了弥补HTML标签的不足;它自定义了许多标签,可以供我们使用,标签的功能和Java代码一样。
格式化标签
SQL标签
XML标签
核心标签(掌握部分)
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
JSTL标签库使用步骤:
- 引入对应的taglib
- 使用其中的方法
- 在Tomcat也需要引入jstl的包,否则会报错:JSTL解析错误。
JavaBean
实体类
JavaBean有特定的写法:
- 必须要有一个无参构造
- 属性必须私有化
- 必须有对应的get/set方法
一般用来和数据库的字段做映射,ORM 对象关系映射。
ORM:对象关系映射: - 表–》类
- 字段–》属性
- 行记录–》对象
<%
// People people = new People();
// people.setAddress();
// people.setAge();
// people.setId();
// people.setName();
%>
<jsp:useBean id="people" class="com.laomao.pojo.People" scope="page"/>
<jsp:setProperty name="people" property="address" value="西安"/>
<jsp:setProperty name="people" property="name" value="小傻猫"/>
<jsp:setProperty name="people" property="age" value="2"/>
<jsp:setProperty name="people" property="id" value="1"/>
姓名:<jsp:getProperty name="people" property="name"/>
年龄:<jsp:getProperty name="people" property="age"/>
id:<jsp:getProperty name="people" property="id"/>
地址:<jsp:getProperty name="people" property="address"/>
MVC三层架构
什么是MVC:Model View Controller 模型 视图 控制器
用户直接访问控制层,控制层就可以直接操作数据库;
servlet--CRUD-->数据库
弊端:程序十分臃肿,不利于维护 servlet的代码中:处理请求,响应,视图跳转,处理JDBC,处理逻辑代码,处理业务代码
架构:没有什么是加一层解决不了的!
程序员调用JDBC
JDBC
Model
- 业务处理:业务逻辑(Service)
- 数据持久层:CRUD(Dao)
View - 展示数据
- 提供链接发起Servlet请求 (a, form , img …)
Controller - 接收用户的请求:(req:请求参数、Session信息。。。)
- 交给业务层处理对应的代码
- 控制视图的跳转
登录--》接收用户的登录请求--》处理用户的请求(获取用户登录的参数,username,password)--》交给业务层处理登录业务(判断用户密码是否正确:事务)--》 Dao层查询用户名和密码是否正确--》数据库
Filter(重点)
Filter:过滤器, 用来过滤网站的数据;
- 处理中文乱码
- 登录验证
Filter开发步骤:
- 导包
- 编写过滤器
- 导包不要导错(javax.servlet)
- 实现filter接口,重写三个方法
public class CharacterEncodingFilter implements Filter {
// 初始化:web服务器启动,就已经初始化了,随时等待过滤对象出现!
@Override
public void init(FilterConfig filterConfig) throws ServletException {
System.out.println("CharacterEncodingFilter初始化");
}
//Chain 链
/*
* 1. 过滤中的所有代码,在过滤特定请求的时候都会执行
* 2. 必须要让过滤器基序通行(把这个请求往下转交)
* */
@Override
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服务器关闭的时候,过滤器会销毁
@Override
public void destroy() {
System.out.println("CharacterEncodingFilter销毁");
}
}
- 在web.xml中配置Filter
<filter>
<filter-name>CharacterEncodingFilter</filter-name>
<filter-class>com.laomao.filter.CharacterEncodingFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<url-pattern>/servlet/*</url-pattern>
</filter-mapping>
监听器
实现一个监听器的接口;
- 实现监听器的接口
public class CharacterEncodingFilter implements Filter {
// 初始化:web服务器启动,就已经初始化了,随时等待过滤对象出现!
@Override
public void init(FilterConfig filterConfig) throws ServletException {
System.out.println("CharacterEncodingFilter初始化");
}
//Chain 链
/*
* 1. 过滤中的所有代码,在过滤特定请求的时候都会执行
* 2. 必须要让过滤器基序通行(把这个请求往下转交)
* */
@Override
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服务器关闭的时候,过滤器会销毁
@Override
public void destroy() {
System.out.println("CharacterEncodingFilter销毁");
}
/*
* Session销毁:
* 1. 手动销毁 getSession().invalidate();
* 2. 自动销毁 web.xml 中配置session-config
* */
}
- 在web.xml中注册监听器
<listener>
<listener-class>com.laomao.listener.OnlineCountLister</listener-class>
</listener>
- 看情况是否使用
过滤器、监听器的常见应用
监听器: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,0,255));
panel.setBounds(50, 50, 300, 300);
panel.setBackground(new Color(0,255,0));
frame.add(panel);
frame.setVisible(true);
// 监听关闭事件
frame.addWindowListener(new WindowListener() {
@Override
public void windowOpened(WindowEvent e) {
System.out.println("打开");
}
@Override
public void windowClosing(WindowEvent e) {
System.out.println("关闭ing");
System.exit(0);
}
@Override
public void windowClosed(WindowEvent e) {
System.out.println("关闭ed");
}
@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中放入用户的数据;
- 进入主页的时候要判断用户是否已经登录;
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) resp;
if (request.getSession().getAttribute(Constant.USER_SESSION)==null){
response.sendRedirect("error.jsp");
}
chain.doFilter(request, response);
JDBC
Java连接数据库!
Navicat中创建表,添加数据
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-02-02');
INSERT INTO users(id,`name`,`password`,email, birthday)
VALUES(3, '王五','123456','ww@qq.com','2000-03-03');
SELECT * from users
导入数据库依赖
<!--mysql 的驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
IDEA中连接数据库【侧边栏操作】
JDBC固定步骤:
- 加载驱动
- 连接数据库,代表数据库
- 向数据库中发送SQL的对象:Statement:CRUD
- 编写SQL(根据业务,不同的SQL)
- 执行SQL
- 关闭连接
public class TestJdbc {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
// 配置信息
// 解决中文乱码
String url="jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8";
String username = "root";
String password = "123456";
// 1. 加载驱动
Class.forName("com.mysql.jdbc.Driver");
// 2. 连接数据库,代表数据库
Connection connection = DriverManager.getConnection(url, username, password);
// 3. 向数据库发送SQL的对象:CRUD
Statement statement = connection.createStatement();
// 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();
}
}
事务
要么都成功,要么都失败!
ACID原则:保证数据安全。
开启事务
事务提交 commit()
事务回滚 rollback()
关闭事务
Junit单元测试
<!--单元测试-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
简单使用:
@Test 注解只有在方法上有效,只要加了这个注解的方法,就可以直接运行!