Javaweb从入门到实战
HTTP
Http请求
1. 请求行
- 请求行中的请求方式: Get, Post, HEAD, DELETE, PUT…
- get: 请求能够携带的参数比较少，大小有限制，会在浏览器URL地址栏显示数据内容，不安全，但高效
- post: 请求能够携带的参数没有限制，大小没限制，不会在浏览器URL地址栏显示数据内容，安全，但效率不如get
2. 消息头
Accept: 告诉浏览器，它所支持的数据类型
Accept-Encoding: 支持哪种编码格式 GBK UTF-8 GB2312 ISO8859-1
Accept-Language: 告诉浏览器，它的语言环境
Cache-Control: 缓存控制
Connection: 告诉浏览器，请求完成是断开还是保持连接
Http响应
- 服务器–响应–客户端
百度:
Content-Type: text/html;charset=utf-8
Content-Encoding: gzip
Cache-Control: private
Connection: keep-alive
1.响应体
Accept: 告诉浏览器，它所支持的数据类型
Accept-Encoding: 支持哪种编码格式 GBK UTF-8 GB2312 ISO8859-1
Accept-Language: 告诉浏览器，它的语言环境
Cache-Control: 缓存控制
Connection: 告诉浏览器，请求完成是断开还是保持连接
Refresh: 告诉客户端，多久刷新一次
Location: 让网页重新定位
2. 响应状态码
200: 请求响应成功
3xx: 请求重定向
- 重定向：重定向到另外一个资源
4xx: 找不到资源
- 资源不存在
5xx: 服务器代码错误 502: 网关错误
常用面试题
当在浏览器中地址栏输入地址并键入回车的一瞬间到页面能展示回来，经历了什么？
Maven
- 在Javaweb开发中，需要大量的jar包，我们需要手动导入
- 有什么工具能自动导入和配置jar包。
Maven就是用来解决这种问题的
Maven项目架构管理工具
Maven的核心思想：约定大于配置
- 有约束，不要去违反
Maven会规定好该如何去编写Java代码，必须按照这个规范来。
配置环境变量
- M2_HOME maven目录下的bin 目录
- MAVEN_HOME maven的目录
- 在系统的 PATH 中配置加入
$MAVEN_HOME/bin
配置阿里云镜像
<mirror>
<id>nexus-aliyunid>
<mirrorOf>centralmirrorOf>
<name>Nexus aliyunname>
<url>http://maven.aliyun.com/nexus/content/groups/publicurl>
mirror>
在IDEA中使用Maven
- 启动IDEA
- 创建一个Maven项目
- 等待项目
POM文件
pom文件是maven的核心配置文件
Servlet
简介
- 是sun公司开发动态web的一门技术
- Sun在这些API中提供一个接口叫做: Servlet。如果想开发一个Servlet程序，只需要完成两步
- 编写一个类，实现Servlet接口
- 把开发好的Java类部署到web服务器中
把实现了Servlet接口的Java程序叫做Servlet
HelloServlet
Servlet接口在Sun公司有两个默认的实现类：HttpServlet, GenericServle
-
构建一个Maven项目，删掉里面的src目录，以后的学习就在这个项目里面新建Moudle；这个工程就是Maven的主工程。
-
关于Maven父子工程的理解：
父项目中有:
<modules> <module>servlet-01module> modules>子项目中有:
<parent> <artifactId>javaweb-02-servletartifactId> <groupId>org.examplegroupId> <version>1.0-SNAPSHOTversion> parent>父项目中的java子项目可以直接使用
-
Maven环境优化
- 修改web.xml为最新的
- 将maven的结构搭建完整
-
编写一个Servlet程序
- 编写一个普通类
- 实现Servlet接口，这里我们直接继承HttpServlet
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 { } } -
编写Servlet的映射
为什么需要映射：我们写的是Java程序，但是要通过浏览器访问，而浏览器需要连接web服务器，所以我们需要在web服务中注册我们写的Servlet，还需要给他一个浏览器能够访问的路径；
<servlet> <servlet-name>helloservlet-name> <servlet-class>com.jack.HelloServletservlet-class> servlet> <servlet-mapping> <servlet-name>helloservlet-name> <url-pattern>/hellourl-pattern> servlet-mapping> -
配置Tomcat
-
启动测试
Servlet原理
Servlet是由Web服务器调用，Web服务器在收到浏览器调用后
这里缺一张图
Mapping问题
-
一个Servlet可以指定一个映射路径
<servlet-mapping> <servlet-name>helloservlet-name> <url-pattern>/hellourl-pattern> servlet-mapping> -
一个Servlet可以指定多个映射路径
<servlet-mapping> <servlet-name>helloservlet-name> <url-pattern>/hello1url-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> <servlet-mapping> <servlet-name>helloservlet-name> <url-pattern>/hello4url-pattern> servlet-mapping> -
一个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> -
可以自定义后缀实现请求映射
<servlet-mapping> <servlet-name>helloservlet-name> <url-pattern>*.jackurl-pattern> servlet-mapping> -
优先级问题
制定了固有的映射路径，优先级最高，如果找不到就会走默认的请求路径；
<servlet> <servlet-name>errorservlet-name> <servlet-class>com.jack.servlet.ErrorServletservlet-class> servlet> <servlet-mapping> <servlet-name>errorservlet-name> <url-pattern>/*url-pattern> servlet-mapping>
ServletContext
Web容器在启动的时候，它会为每个Web程序创建一个ServletContext对象，它代表了当前应用；
共享数据
在某个Servlet 中保存的数据可以在另一个Servlet中访问
public class HelloServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// this.getInitParameter();
// this.getServletConfig();
ServletContext context = this.getServletContext();
String username = "jack";
context.setAttribute("username", username); // 将一个数据保存在ServletContext中, 相当于插入了一个键值对, 这个值是Object类型的
System.out.println("Hello");
}
}
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 {
super.doPost(req, resp);
}
}
<servlet>
<servlet-name>helloservlet-name>
<servlet-class>com.jack.servlet.HelloServletservlet-class>
servlet>
<servlet-mapping>
<servlet-name>helloservlet-name>
<url-pattern>/hellourl-pattern>
servlet-mapping>
<servlet>
<servlet-name>getcservlet-name>
<servlet-class>com.jack.servlet.GetServletservlet-class>
servlet>
<servlet-mapping>
<servlet-name>getcservlet-name>
<url-pattern>/getcurl-pattern>
servlet-mapping>
测试访问结果
先访问/hello将对应的键值对存入ServletContext里，然后再访问/getc即可得到结果:
获取初始化参数
<context-param>
<param-name>urlparam-name>
<param-value>jdbc:mysql:://localhost:3306param-value>
context-param>
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 {
}
}
请求转发
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
ServletContext context = this.getServletContext();
System.out.println("进入ServletDemo04");
// RequestDispatcher dispatcher = context.getRequestDispatcher("/gp"); // 转发的请求路径
// dispatcher.forward(req, resp); // 调用forward实现请求转发
context.getRequestDispatcher("/gp").forward(req, resp);
}
读取资源文件
Properties类
- 在java目录下新建properties文件
- 在resources目录下新建properties文件
发现：都被打包到了同一路径下：classes, 我们俗称这个路径为classpath
思路：需要一个文件流
username=jack
password=123456
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 user = prop.getProperty("username");
String pwd = prop.getProperty("password");
resp.getWriter().println(user+":"+pwd);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
}
}
HttpServletResponse
响应：web服务器接收到客户端的http请求，针对这个请求分别创建一个代表请求的HttpServletRequest对象，代表响应的一个HttpServletResponse;
- 如果要获取客户端请求过来的参数: 找HttpServletRequest
- 如果要给客户端响应一些信息: 找HttpServletResopnse
简单分类
负责向浏览器发送数据的方法
ServletOutputStream getOutputStream() throws IOException;
PrintWriter getWriter() throws IOException;
负责向浏览器发送响应头的方法
void setCharacterEncoding(String var1);
void setContentLength(int var1);
void setContentLengthLong(long var1);
void setContentType(String var1);
void setDateHeader(String var1, long var2);
void addDateHeader(String var1, long var2);
void setHeader(String var1, String var2);
void addHeader(String var1, String var2);
void setIntHeader(String var1, int var2);
响应状态码（记上面提到常用的即可）
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;
常见应用
-
向浏览器输出消息
-
下载文件
- 要获取下载文件的路径
- 下载的文件名
- 设置想办法让浏览器能支持下载
- 获取下载文件的输入流
- 创建缓冲区
- 获取OutputStream对象
- 将FileOutputStream流写入到缓冲区
- 使用OutputStream将缓冲区的数据输入到客户端
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 1. 要获取下载文件的路径 String realPath = "/Users/macbook/WorkSpace/Learning/JavaWeb/javaweb-02-servlet/response/target/classes/1.jpeg"; System.out.println("下载文件的路径: " + realPath); // 2. 下载的文件名 String fileName = realPath.substring(realPath.lastIndexOf('/')+1); // 3. 设置想办法让浏览器能支持下载 // 设置响应头, 如果fileName为中文，则需要改变编码URLEncoder.encode(fileName, "UTF-8") resp.setHeader("Content-Disposition","attachment;filename="+fileName); // 4. 获取下载文件的输入流 FileInputStream in = new FileInputStream(realPath); // 5. 创建缓冲区 byte[] buffer = new byte[1024]; // 6. 获取OutputStream对象 ServletOutputStream outputStream = resp.getOutputStream(); // 7. 将FileOutputStream流写入到缓冲区 int len; while((len = in.read(buffer))>0) { outputStream.write(buffer, 0, len); } in.close(); outputStream.close(); // 8. 使用OutputStream将缓冲区的数据输入到客户端 } -
验证码功能
验证码怎么来的？
- 前段实现
- 后端实现，需要用到java的图片类，生成一个图片
public class ImageServlet extends HttpServlet { @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/jpeg"); // 网站存在缓存，不让浏览器缓存 resp.setDateHeader("expires", -1); resp.setHeader("Cache-Control", "no-cache"); resp.setHeader("Pragma", "no-cache"); // 把图片写给浏览器 ImageIO.write(image, "jpg", resp.getOutputStream()); } // 生成随机数 private String makeNum() { Random random = new Random(); String num = random.nextInt(99999999) + ""; StringBuffer sb = new StringBuffer(); for (int i = 0; i < 7-num.length(); ++i) { // 用0补齐数字位数 sb.append("0"); } num = sb.toString() + num; return num; } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { } } -
实现重定向
一个web资源收到客户端请求后，它会通知客户端去访问另外一个web资源，这个过程叫重定向
void sendRedirect(String var1) throws IOException;protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { /* resp.setHeader("Location", "r/img"); resp.setStatus(HttpServletResponse.SC_MOVED_TEMPORARILY); */ resp.sendRedirect("/response_war/img"); // 这里要注意加上Tomcat配置里面的上下文, 也可以向下面一样直接调用注册的Servlet // 这句话实际上完成的工作就是上面两句话的 // resp.sendRedirect("img"); }常见场景：
- 用户登录
面试题：重定向和转发的区别？
相同点：
- 页面都会实现跳转
不同点：
- 请求转发的时候，URL不会发生变化 307
- 重定向的时候，URL会发生变化 302
HttpServletRequest
HttpServletRequest代表客户端的请求，用户通过Http协议访问服务器；HTTP请求中的所有协议会被封装到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("======================");
// 请求转发的时候不需要带项目路径了，转发的时候会自动带上，转发的时候是按照当前地址为基准的
// 重定向需要写项目路径，转发不需要
req.getRequestDispatcher("/success.jsp").forward(req, resp);
}
Cookie, Session
会话
会话：用户打开一个浏览器，点击了很多超链接，访问多个web资源，关闭浏览器，这个过程可以称之为会话。
有状态会话：
保存会话的两种技术
cookie
- 客户端技术（响应，请求）
session
- 服务器技术，利用这个技术，可以保存用户的会话信息。我们可以把信息或者数据放在Session中。
常见：网站登录之后，下次不需要重新登录。
Cookie
- 从请求中拿到cookie信息
- 服务器响应给客户端cookie
Cookie[] cookies = req.getCookies(); // 获得cookie
cookie.getName(); // 获取key
cookie.getValue(); // 获取value
new Cookie("lastLoginTime", System.currentTimeMillis()+""); // 新建cookie
cookie.setMaxAge(24*60*60); // 设置有效期
resp.addCookie(cookie); // 响应客户端cookie
一个网站cookie是否存在上限？
- 一个Cookie只能保存一个信息
- 一个web站点可以给浏览器发送多个cookie，一个站点最多存放20个cookie；
- cookie大小有限制4kb；
- 浏览器上限大概300个
删除Cookie
- 不设置有效期，关闭浏览器，自动失效；
- 设置有效期时间为0
Session （重点）
什么是Session:
- 服务器会给每一个用户（浏览器）创建一个Session对象
- 一个Session独占一个浏览器，只要浏览器没有关闭，这个Session就存在。
- 用户登录之后，整个网站都可以保持登录状态
Session和cookie的区别：
- Cookie是把用户的数据写给用户的浏览器，浏览器保存（可以保存多个）
- Session把用户的数据写到用户独占的Session中，服务器端保存（保存重要的信息，减少服务器资源的使用）
使用场景：
- 保存一个登录用户的信息；
- 购物车信息；
- 在整个网站中，经常会使用的数据，我们将它保存在Session中；
使用Session：
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();
// servlet在调用getSession的时候会创建一个新的Session
// 给Session存东西
session.setAttribute("name", new Person("我", 20));
// 获取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);
}
// 得到Session
HttpSession session = req.getSession();
// servlet在调用getSession的时候会创建一个新的Session
Person person = (Person) session.getAttribute("name");
if(person != null)
System.out.println(person.toString());
else System.out.println("null");
// 得到Session中的值
session.removeAttribute("name");
// 手动注销Session
session.invalidate();
会话自动过期：web.xml配置
<session-config>
<session-timeout>1session-timeout>
session-config>
JSP
什么是JSP
Java Serve Pages：Java服务器端页面，也和Servlet一样，用于动态Web技术！
最大特点：
- 写JSP就像在写HTML
区别：
- HTML只给用户提供静态数据
- JSP页面中可以嵌入JAVA代码，为用户提供动态数据
JSP原理
思路：JSP到底怎么执行的
-
代码层面没有任何问题
-
服务器内部工作
tomcat中有一个work目录；
IDEA中使用Tomcat在IDEA的Tomcate中生成一个work目录
实际上JSP会被tomcat也转换成一个java程序，所以浏览器向服务器发送请求，不管访问什么资源，其实都是在访问Servlet!
在启动Tomcat时命令行的提示信息里有一个CATALINA_BASE
在它对应的目录下找
就能发现这个页面对应的java程序了
查看这个Java程序，可以看到它集成了一个叫
HttpJspBase的类
查看
HttpJspBase的源代码，就可以发现这个HttpJspBase类实际上也是继承了HttpServlet
再回过头来看
index.jsp// 初始化 public void _jspInit() // 销毁 public void _jspDestroy() // JSPService public void _jspService(final HttpServletRequest request, final HttpServletResponse response)在
_jspService方法中会做下面这些事情-
判断请求
-
内置了一些对象
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 // 响应 -
输出页面前增加的代码
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; -
以上的这些对象，我们可以在JSP页面中直接使用
在JSP页面中：
只要是JAVA代码就会原封不动地输出；
如果是HTML代码，就会被转换为
out.write("\r\n");这样的格式，输出到前端。
-
JSP基础语法
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("Sum="+sum+"
");
%>
<%-- 在代码中嵌入HTML元素 --%>
<%
for (int i = 0; i < 5; i++) {
%>
Hello, World <%=i%>
<%
}
%>
JSP声明
上面的这些东西都是在_jspService这个方法中执行的，有没有这样一种方法可以添加一些代码到这个方法之外呢，比如创造一个新的方法或者生命一个类里的全局变量呢？当然是可以了，把代码添加到用<%! %>包裹的块中即可实现。
<%!
static {
System.out.println("Loading Servlet!");
}
private int globalVar = 0;
public void test() {
System.out.println("进入方法test");
}
%>
JSP声明：会被编译到JSP生成的JAVA类中。其他的会被生成到_jspService方法中！
在JSP中嵌入Java代码即可！
<%代码块%>
<%=输出%>
<%!声明%>
<%-- 注释 --%>
JSP的注释，不会在客户端显示，HTML的会。
JSP指令
<%@page args... %>
<%@include file=""%>
9大内置对象
- PageContext 存东西
- Request 存东西
- Response
- Session 存东西
- Application (ServletContext) 存东西
- config (ServletConfig)
- out
- page
- exception
pageContext.setAttribute("name1", "一号我"); // 只在一个页面中有效
request.setAttribute("name2", "二号我"); // 只在一次请求中有效，请求转发会携带这个数据
session.setAttribute("name3", "三号我"); // 在一次会话中有效，从打卡浏览器到关闭浏览器
application.setAttribute("name4", "四号我"); // 保存的数据只在服务器中有效，从打开服务器到关闭服务器
request: 客户端向服务器发送请求，产生的数据，用户看完就没用了；
session: 客户端向服务器发送请求，产生的数据，用户用完一会儿还有用；
application: 客户端向服务器发送请求，产生的数据一个用户用完，其他用户还可能使用。
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（Expression Language）表达式：${}
- 获取数据
- 执行运算
- 获取web开发的常用对象
调用Java方法，这个不常用
JSP标签
<jsp:include page="common/header.jsp"></jsp:include>
<jsp:forward page="jsptag2.jsp">
<jsp:param name="name" value="jack"/>
<jsp:param name="age" value="18"/>
</jsp:forward>
JSTL表达式
JSTL标签库的使用就是为了弥补HTML标签的不足；它自定义许多标签，可以供我们使用，便签的功能和Java代码一样！
格式化标签
SQL标签
XML标签
核心标签（掌握部分）
JSTL标签库使用步骤
- 引入对应的taglib
- 使用其中的方法
<%--判断如果提交的用户名是管理员，则登陆成功--%>
<%--
<%
if(request.getParameter("username").equals("admin")) {
out.print("登陆成功");
}
%>
--%>
<%--下面的标签和上面的java代码实现逻辑是相通的--%>
你的成绩为优秀
你的成绩为良好
你的成绩为一般
你的成绩为还行
<%
ArrayList peoples = new ArrayList<>();
// 下标只能从0开始使用
peoples.add(0,"张三");
peoples.add(1,"李四");
peoples.add(2,"王五");
peoples.add(3,"赵六");
peoples.add(4,"钱七");
request.setAttribute("list", peoples);
%>
<%--
var, 每一次遍历出来的变量
items, 要遍历的对象
--%>
<%--
begin, 起始下标
end, 终止下标(包含)
step, 步长
--%>
c:forEach varStatus属性
- current: 当前这次迭代的（集合中的）项
- index: 当前这次迭代从 0 开始的迭代索引
- count: 当前这次迭代从 1 开始的迭代计数
- first: 用来表明当前这轮迭代是否为第一次迭代的标志
- last: 用来表明当前这轮迭代是否为最后一次迭代的标志
- begin: 属性值
- end: 属性值
- step: 属性值
例子：
XXX
实例解读： 对 session 对象存储的 userList 集合对象进行遍历，每次访问的项暂时存储在 userItem 变量中，从索引 1 开始至索引 10 进行访问，但不是依次访问，每隔 3 个元素访问一次。每次访问项的状态相关值由 userStatus 对象暂存。
${userStatus.index} 此项的索引，从0开始
${userStatus.count} 此项的计数序号，从1开始
${userStatus.first} 此项是否是第一项，布尔值
${userStatus.last} 此项是否是最后一项，布尔值
${userStatus.begin} 此次迭代的起始索引，对应中begin属性值
${userStatus.end} 此次迭代的终止索引，对应中end属性值
${userStatus.step} 此次迭代的跳跃步伐，对应中step属性值
JavaBean
实体类
JavaBean有特定的写法：
- 必须要有一个无参构造；
- 属性必须私有化；
- 必须有对应的get/set方法；
一般用来喝数据库的字段做映射 ORM;
ORM: 对象关系映射
- 表 -> 类
- 字段 -> 类的属性
- 行记录 -> 对象
People表
| id | name | age | address |
|---|---|---|---|
| 1 | jack1 | 3 | xi’an |
| 2 | jack2 | 18 | xi’an |
| 3 | jack3 | 20 | xi’an |
| 4 | jack4 | 25 | xi’an |
class People {
private int id;
private String name;
private int age;
private String address;
}
class A {
new People(1, "jack1", 3 "xi'an");
}
MVC三层架构
什么是MVC: Model View Controller 模型、视图、控制器
Servlet和JSP都可以写Java代码；为了易于维护和使用，Servlet专注于处理请求以及控制视图跳转；JSP专注于显示数据。
早些年
用户直接访问控制层，控制层就可以直接操作数据库
servlet--CRUD-->数据库
弊端：程序十分臃肿，不利于维护 servlet的代码中：处理请求、响应、视图跳转、处理JDBC、处理业务代码、处理逻辑代码
架构：没有什么是加一层解决不了的！
程序员
｜
JDBC
｜
Oracle Mysql Sqlserver
MVC三层架构
Model
- 业务处理：业务逻辑（Service）
- 数据持久层：CRUD – 增删改查（Dao）
View
- 展示数据
- 提供链接发起Servlet请求（a, form, img…）
Controller（Servlet）
-
接受用户的请求：(req: 请求参数、Session)
-
交给业务层处理对应的代码
-
控制视图的跳转
登陆 ---> 接受用户的登陆请求 ---> 处理用户的请求(获取用户登录的参数：username, password...) ---> 交给业务层处理登陆业务（判断用户名密码是否正确）---> Dao层查询用户名和密码是否正确 ---> 数据库
Filter (重点)
Filter: 过滤器，用来过滤网站的数据；
- 处理中文乱码
- 登陆验证…
Filter开发步骤：
-
导包
-
编写过滤器
-
要实现的是
javax.servlet下的Filter接口public class CharacterEncodingFilter implements Filter { // 初始化: web服务器启动时初始化，随时等待过滤对象出现 public void init(FilterConfig filterConfig) throws ServletException { System.out.println("CharacterEncodingFilter初始化"); } // Chain: 链 /* * 1. 过滤中的所有代码，在过滤特定请求的时候都会执行 * 2. 必须要让过滤器继续通行 * chain.doFilter(request, response); * */ public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { request.setCharacterEncoding("utf-8"); response.setCharacterEncoding("utf-8"); response.setContentType("text/html;charset=UTF-8"); System.out.println("CharacterEncodingFilter执行前..."); chain.doFilter(request, response); // 让我们的请求继续走，如果不写，程序到这里就被拦截停止 System.out.println("CharacterEncodingFilter执行后..."); } // 销毁: 服务器关闭的时候销毁 public void destroy() { System.out.println("CharacterEncodingFilter销毁"); } }
-
-
在
web.xml中配置Filter<filter> <filter-name>CharacterEncodingFilterfilter-name> <filter-class>com.jack.filter.CharacterEncodingFilterfilter-class> filter> <filter-mapping> <filter-name>CharacterEncodingFilterfilter-name> <url-pattern>/servlet/*url-pattern> filter-mapping>
监听器
实现一个监听器的接口；（有很多种）
-
编写一个监听器
实现监听器的接口
public class OnlineCountListener implements HttpSessionListener { // 创建session监听 // 一旦一个session被创建，就会触发一次这个事件 public void sessionCreated(HttpSessionEvent se) { System.out.println("Session被创建"); ServletContext ctx = se.getSession().getServletContext(); Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount"); System.out.println(se.getSession().getId()); if(onlineCount == null) { ctx.setAttribute("OnlineCount", 1); } else { ctx.setAttribute("OnlineCount", onlineCount+1); } } // 销毁session监听 // 一旦一个session被销毁，就会触发一次这个事件 public void sessionDestroyed(HttpSessionEvent se) { System.out.println("Session"+se.getSession().getId()+"被销毁"); ServletContext ctx = se.getSession().getServletContext(); Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount"); if(onlineCount == 0) { ctx.setAttribute("OnlineCount", 0); } else { ctx.setAttribute("OnlineCount", onlineCount-1); } se.getSession().invalidate(); } /* * Session 销毁: * 1. 手动销毁 getSession().invalidate(); * 2. 自动销毁 在web.xml中配置session-config下的session-timeout * */ } -
在
web.xml中配置监听器<listener> <listener-class>com.jack.listener.OnlineCountListenerlistener-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 WindowAdapter() {
@Override
public void windowClosing(WindowEvent e) {
super.windowClosing(e);
}
});
}
}
用户登录之后才能进入主页! 用户注销后就不能进入主页。
-
用户登录之后，向Session中放入用户的信息
-
进入主页时要判断用户是否已经登陆;
public class SysFilter implements Filter { @Override public void init(FilterConfig filterConfig) throws ServletException {} @Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { HttpServletRequest request1 = (HttpServletRequest) request; HttpServletResponse response1 = (HttpServletResponse) response; if(request1.getSession().getAttribute(Contanst.USER_SESSION) == null) { response1.sendRedirect("/error.jsp"); } chain.doFilter(request, response); } @Override public void destroy() { } }
JDBC
什么是JDBC: JavaDataBaseConnector
连接数据库需要jar包的支持:
java.sqljavax.sqlmysql-connector-java链接驱动（必须要导入）
实验环境搭建
CREATE TABLE USERS(
id INT PRIMARY KEY,
`name` varchar(40),
`password` varchar(40),
email varchar(60),
birthday DATE
);
insert into users(id, `name`, `password`, email, birthday)
values(1, '张三', '123456', '[email protected]', '2000-01-01');
insert into users(id, `name`, `password`, email, birthday)
values(2, '李四', '123456', '[email protected]', '2000-01-01');
insert into users(id, `name`, `password`, email, birthday)
values(3, '王五', '123456', '[email protected]', '2000-01-01');
导入数据库依赖
<dependencies>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>8.0.30version>
dependency>
dependencies>
IDEA中连接数据库
JDBC固定步骤
- 加载驱动
- 连接数据库
- Statement
- 编写SQL （根据业务，不同的SQL）
- 执行SQL
- 关闭连接
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";
String username = "root";
String password = "123456";
// 1. 加载驱动
Class.forName("com.mysql.jdbc.Driver");
// 2. 连接数据库, 代表数据库
Connection connection = DriverManager.getConnection(url, username, password);
// 3. 向数据库发送SQL的对象Statement: CRUD
Statement statement = connection.createStatement();
// 4. 编写SQL
String sql = "select * from users";
// 5. 执行SQL
ResultSet 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();
connection.close();
statement.close();
}
}
事务
要么都成功，要么都失败
ACID原则：保证数据的安全。
开启事务
事务提交 commit()
事务回滚 rollback()
关闭事务