JavaWeb基础知识（有错误请大家在评论指出）

文章目录

JavaWeb
- JavaWeb基本概念
- Web概述
- - XML基础
- HTTP
- - HTTP简介
  - HTTP请求
  - HTTP响应
- Tomcat
- Servlet
- - Servlet虚拟路径的映射
  - ServletConfig接口
  - ServletContext接口
  - - 共享数据
    - 获得初始化参数
    - 请求转发
    - 读取资源文件
- HttpServletResponse
- - 分类
  - 下载文件
  - 验证码功能
  - 实现重定向
- HttpServletRequest
- - 获取参数和请求转发
- cookie
- Session ***
- JSP
- - JSP原理
  - JSP基础语法
  - - JSP表达式
    - JSP脚本片段
    - 脚本片段的再实现
  - JSP指令
  - 9大内置对象（JSP隐式对象）
  - JSP标签 JSTL标签 EL表达式
  - - EL表达式
    - JSP标签
    - JSTL表达式
    - - 核心标签***
- JavaBean(了解一下)
- MVC三层架构
- Filter***
- 监听器
- 过滤器监听器的常见应用

JavaWeb JavaWeb基本概念

Java Web，是用Java技术来解决相关web互联网领域的技术栈。web包括：web服务端和web客户端两部分。Java在客户端的应用有Java Applet，不过使用得很少，Java在服务器端的应用非常的丰富，比如Servlet，JSP、第三方框架等等。

**静态web资源（如html 页面）：指web页面中供人们浏览的数据始终是不变。**静态web资源开发技术：HTML、CSS

动态web资源：指web页面中供人们浏览的数据是由程序产生的，不同时间点访问web页面看到的内容各不相同。。动态web资源开发技术：Javascript、JSP/Servlet、ASP、PHP等。在Java中，动态web资源开发技术统称为Java Web

Web概述 XML基础

XML语法：

XML注释：

DTD约束

文档类型定义（DTD）可定义合法的XML文档构建模块。它使用一系列合法的元素来定义文档的结构。

DTD 可被成行地声明于 XML 文档中，也可作为一个外部引用。

内部的 DOCTYPE 声明

假如 DTD 被包含在您的 XML 源文件中，它应当通过下面的语法包装在一个 DOCTYPE 声明中：

Schema约束

schema概述

schema约束同为xml文件的约束模式语言之一, 最大的作用是为了验证xml文件的规范性的.

HTTP HTTP简介

HTTP：超文本传输协议（Hypertext Transfer Protocol）
默认端口号：80
HTTPS 默认端口号 443 （S代表Safe 安全的）
HTTP1.0
- HTTP1.0 协议的客户端与服务器在交互过程中需要经过建立连接，发送请求消息，回送响应消息，关闭连接四个步骤。客户端与服务器建立连接后，每次只能处理一个HTTP请求
HTTP1.1
- 客户端与服务器建立连接后，可以传送多个HTTP请求和响应

HTTP请求

客户端------>发送请求------->服务器

General：

Request URL: http://localhost:2019/servlet_war/Servlet01   //请求地址
Request Method: GET                                        //请求方法，get/post方法
Status Code: 200                                           //状态码
Remote Address: [::1]:2019                                 //远程地址

Request Header：

Accept:text/html        
Accept-Encoding: gzip, deflate, br
Accept-Language: en-GB,en-US;q=0.9,en;q=0.8,zh-CN;q=0.7,zh-TW;q=0.6,zh;q=0.5
Cache-Control: max-age=0
Connection: keep-alive
cookie: JSESSIONID=83A28ABEF514F89A9A746C55FACCC21C; Idea-6b53f3ef=66018b3b-efdd-4d19-8e0b-c206dfe4b3e0
Host: localhost:2019
......

HTTP请求行
1. 请求行中的请求方式：Get
2. 请求方式：**Get、Post、（最为常用）**HEAD、PUT、DELETE、TRACE、CONNECT、OPTIONS

HTTP请求消息头

Accept              //指出客户端程序（浏览器）能够支持的类型
Accept-Encoding     //支持哪种编码格式  GBK、UTF-8、GB2312、ISO8859-1
Accept-Language     //支持的语言环境
Cache-Control:      //缓存控制
Connection          //连接
cookie              //cookie
Host                //主机
......

HTTP响应

服务器----->响应----->客户端

Response Header：

Cache-Control: private                   //缓存控制
Connection: keep-alive                   //连接
Content-Encoding: gzip                   //文本编码
Content-Type: text/html;charset=utf-8    //文本类型
......

HTTP响应状态码
1. 1xx：表示请求已接收，需要继续处理
2. 2xx(200)：表示请求已经成功被服务器接收、理解并接受
3. 3xx(302，304)：为完成请求，客户端需进一步细化请求
4. 4xx(404)：客户端的请求有错误
5. 5xx(500)：服务端出现错误
HTTP响应消息头

Accept              //指出客户端程序（浏览器）能够支持的类型
Accept-Encoding     //支持哪种编码格式  GBK、UTF-8、GB2312、ISO8859-1
Accept-Language     //支持的语言环境
Cache-Control:      //缓存控制
Connection          //连接
cookie              //cookie
Host                //主机
Refresh             //告诉客户端多久刷新一次
location            //让网页重新定向
......

Tomcat

目录图：

Servlet

servlet体系结构图：

Servlet接口中的抽象方法

//  容器在创建好Servlet对象后，就会调用此方法。该方法接收一个ServletConfig类型的参数，Servlet容器通过这个参数向Servlet触底初始值
void init(ServletConfig var1);
//用于获取Servlet对象的配置信息，返回Servlet的ServletConfig对象
ServletConfig getServletConfig();
//负责响应用户的请求，当容器（指web服务器）接收到客户端访问Servlet对象的请求时，就会调用此方法。（提供服务的方法，每一次Servlet被访问时执行，会执行多次。）
void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;
//返回一个字符串，其中包含关于Servlet的信息，如：作者，版权和版本等信息
String getServletInfo();
//负责释放Servlet对象占用的资源。当服务器关闭或者Servlet对象被移除时，Servlet对象会被摧毁，容器调用此方法
void destroy();

HttpServlet类常用的方法：

//用于处理GET类型的HTTP请求方法
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
//用于处理POST类型的HTTP请求方法
protected void doPost(HttpServletRequest req, HttpServletResponse resp)

Servlet虚拟路径的映射

Servlet的多重映射
1. 配置多个元素

    
        Servlet
        com.sgl.servlet.HelloServlet
    
    
        Servlet
        /Servlet01
    
    
        Servlet
        /Servlet001

2. 在一个元素下配置多个子元素

    
        Servlet
        com.sgl.servlet.HelloServlet
    
    
        Servlet
        /Servlet01
        /Servlet001

Servlet映射路径中使用的通配符

“ *.拓展名 ”

“ *.properties ***.properties ** resp.sendRedirect("/HttpServletResponse_war/ImageServlet"); //重定向 } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { doGet(req, resp); } }

请求转发和重定向的区别：

相同点：页面都会跳转
不同点：
1. 请求转发的时候，url地址栏不会发生变化
2. 重定向的时候，url地址栏会发生变化

Response重定向

index.jsp (启动Tomcat时，显示的页面)

通过form表单 action="${pageContext.request.contextPath}/RequestTest" ，然后输入，可以进入到RequetTest，然后右通过重定向进入到success.jsp



Hello World!
<%--这里提交的路径，需要寻找到项目的路径--%>
<%--${pageContext.request.contextPath}代表当前的项目--%>

    用户名: 

    密码:

创建的RequestTest类

package com.sgl.demo01;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class RequestTest extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("进入这个请求");

        //处理请求
        String username = req.getParameter("username");
        String password = req.getParameter("password");

        System.out.println(username+"    "+password);

        //重定向一定要注意路径问题  否则404
        resp.sendRedirect("/HttpServletResponse_war/success.jsp");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

success.jsp

<%--
  Created by IntelliJ IDEA.
  User: shiga
  Date: 2021/9/2
  Time: 21:06
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    Title


Success

HttpServletRequest 获取参数和请求转发

index.jsp



登录


    <%--这里的表单表示的意思：以post方式提交表单，提交到我们的LoginServlet请求--%>
    
        用户名:

        密码:

        爱好:
        女孩
        代码
        唱歌
        电影

创建的LoginServlet类

package com.sgl.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Arrays;

public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        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);
        

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

success.jsp

<%--
  Created by IntelliJ IDEA.
  User: shiga
  Date: 2021/9/2
  Time: 21:40
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    Title


success

cookie:

客户端技术（响应，请求）

常见现象：网站登录之后，下次无需登录，第二次直接登录上去

测试：

package com.sgl.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;

public class cookieDemo01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //解决中文乱码问题
        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");
        resp.setHeader("Context-Type","text/html;charset=utf-8");
        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("LastLoginTime")){
                    //获取cookie的值
                    long lastLoginTime = Long.parseLong(cookie.getValue());
                    Date date = new Date(lastLoginTime);
                    out.write(date.toLocaleString());
                }
            }
        }
        //服务端响应一个cookie
        cookie cookie = new cookie("LastLoginTime",System.currentTimeMillis()+"");
        //cookie有效期为1天
        cookie.setMaxAge(24*60*60);
        resp.addcookie(cookie);

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

用到的方法

cookie[] cookies = req.getcookies();  //获取cookie
cookie.getName()   //获取cookie中的key
cookie.getValue()   //获取cookie中的value
cookie cookie = 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

测试删除cookieDemo01类的cookie访问信息，启动Tomcat后，访问cookieDemo01上次访问时间被保存，然后访问cookieDemo02，再访问cookieDemo01，cookie上次访问时间删除

package com.sgl.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class cookieDemo02 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //创建一个cookie，名字必须和删除的名字一致
        cookie cookie = new cookie("LastLoginTime",System.currentTimeMillis()+"");
        //将cookie有效期设置为0
        cookie.setMaxAge(0);

        resp.addcookie(cookie);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

中文数据传递

package com.sgl.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.URLDecoder;
import java.net.URLEncoder;

public class cookieDemo03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        //解决中文乱码问题
        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");
        resp.setHeader("Context-Type","text/html;charset=utf-8");
        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("name")){
                    //输出cookie的值
                    out.write(URLDecoder.decode(cookie.getValue(),"utf-8"));  //解码
                }
            }
        }

        //编码
        cookie cookie = new cookie("name", URLEncoder.encode("刚龙","utf-8"));
        resp.addcookie(cookie);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

用到编码和解码

 URLEncoder.encode("刚龙","utf-8")  //编码
 URLDecoder.decode(cookie.getValue(),"utf-8")  //解码

Session ***

session:

服务端技术，保存会话信息，把信息或者数据存放在session中
服务器会给每一个用户（浏览器）创建一个session对象
一个Session独占一个浏览器，只要浏览器没有关闭，Session就存在
用户登陆后，整个网站它都可以访问 ---->保存用户的信息；保存购物车的信息等等

HttpSession中的方法：

//得到一个Session
HttpSession session = req.getSession();

long getCreationTime();

String getId();

long getLastAccessedTime();

ServletContext getServletContext();

void setMaxInactiveInterval(int var1);

int getMaxInactiveInterval();


@Deprecated
HttpSessionContext getSessionContext();

Object getAttribute(String var1);


@Deprecated
Object getValue(String var1);

Enumeration getAttributeNames();


 @Deprecated
String[] getValueNames();

void setAttribute(String var1, Object var2);


@Deprecated
void putValue(String var1, Object var2);

void removeAttribute(String var1);


@Deprecated
void removevalue(String var1);

void invalidate();

boolean isNew();

测试：

获取Session并给Session存东西

package com.sgl.servlet;

import com.sgl.pojo.Person;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

public class SessionDemo01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //解决中文乱码问题
        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");
        resp.setHeader("text/html","charset=utf-8");

        //得到一个Session
        HttpSession session = req.getSession();

        //给session存东西
        //session.setAttribute("name","刚龙");
        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);
        }



    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

得到Session的保存的值

package com.sgl.servlet;

import com.sgl.pojo.Person;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

public class SessionDemo02 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //解决中文乱码问题
        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");
        resp.setHeader("text/html","charset=utf-8");


        //得到Session
        HttpSession session = req.getSession();

        //String name = (String) session.getAttribute("name");
        Person person = (Person) session.getAttribute("name");
        //resp.getWriter().write(name);
        resp.getWriter().write(person.toString());



    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

会话过期的两种方式：

手动注销Session

package com.sgl.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

public class SessionDemo03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        HttpSession session = req.getSession();
        session.removeAttribute("name");
        //手动注销session
        session.invalidate();
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

会话自动过期，在web.xml中配置

Session和cookie的区别：

cookie是把用户的数据写给用户的浏览器，浏览器保存（可以保存多个）
Session是把用户的数据写到用户独占的Session中，服务端保存（保存重要的信息，减少服务器资源的浪费）
Session对象由服务器创建

JSP

JSP（全称JavaServer Pages）JSP将Java代码和特定变动内容嵌入到静态的页面中，实现以静态页面为模板，动态生成其中的部分内容。

JSP原理

**浏览器向服务器发送请求，不管访问什么资源，其实都是在访问Servlet ** JSP本质就是一个Servlet

JSP最终会被转换成一个Java类

找不到的话，打开IDEA点击 Help 下的 Show Log in Explorer 会在文件夹中显示

index_jsp.java ：源代码

package org.apache.jsp;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;

public final class index_jsp extends org.apache.jasper.runtime.HttpJspbase
    implements org.apache.jasper.runtime.JspSourceDependent,
                 org.apache.jasper.runtime.JspSourceimports {

  private static final javax.servlet.jsp.JspFactory _jspxFactory =
          javax.servlet.jsp.JspFactory.getDefaultFactory();

  private static java.util.Map _jspx_dependants;

  private static final java.util.Set _jspx_imports_packages;

  private static final java.util.Set _jspx_imports_classes;

  static {
    _jspx_imports_packages = new java.util.HashSet<>();
    _jspx_imports_packages.add("javax.servlet");
    _jspx_imports_packages.add("javax.servlet.http");
    _jspx_imports_packages.add("javax.servlet.jsp");
    _jspx_imports_classes = null;
  }

  private volatile javax.el.expressionFactory _el_expressionfactory;
  private volatile org.apache.tomcat.InstanceManager _jsp_instancemanager;

  public java.util.Map getDependants() {
    return _jspx_dependants;
  }

  public java.util.Set getPackageimports() {
    return _jspx_imports_packages;
  }

  public java.util.Set getClassimports() {
    return _jspx_imports_classes;
  }

  public javax.el.expressionFactory _jsp_getexpressionFactory() {
    if (_el_expressionfactory == null) {
      synchronized (this) {
        if (_el_expressionfactory == null) {
          _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getexpressionFactory();
        }
      }
    }
    return _el_expressionfactory;
  }

  public org.apache.tomcat.InstanceManager _jsp_getInstanceManager() {
    if (_jsp_instancemanager == null) {
      synchronized (this) {
        if (_jsp_instancemanager == null) {
          _jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
        }
      }
    }
    return _jsp_instancemanager;
  }

  public void _jspInit() {
  }

  public void _jspDestroy() {
  }

  public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
      throws java.io.IOException, javax.servlet.ServletException {

    if (!javax.servlet.DispatcherType.ERROR.equals(request.getDispatcherType())) {
      final java.lang.String _jspx_method = request.getMethod();
      if ("OPTIONS".equals(_jspx_method)) {
        response.setHeader("Allow","GET, HEAD, POST, OPTIONS");
        return;
      }
      if (!"GET".equals(_jspx_method) && !"POST".equals(_jspx_method) && !"HEAD".equals(_jspx_method)) {
        response.setHeader("Allow","GET, HEAD, POST, OPTIONS");
        response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, "JSP 只允许 GET、POST 或 HEAD。Jasper 还允许 OPTIONS");
        return;
      }
    }

    final javax.servlet.jsp.PageContext pageContext;
    javax.servlet.http.HttpSession session = null;
    final javax.servlet.ServletContext application;
    final javax.servlet.ServletConfig config;
    javax.servlet.jsp.JspWriter out = null;
    final java.lang.Object page = this;
    javax.servlet.jsp.JspWriter _jspx_out = null;
    javax.servlet.jsp.PageContext _jspx_page_context = null;


    try {
      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;

      out.write("n");
      out.write("n");
      out.write("Hello World!n");
      out.write("n");
      out.write("n");
    } catch (java.lang.Throwable t) {
      if (!(t instanceof javax.servlet.jsp.SkipPageException)){
        out = _jspx_out;
        if (out != null && out.getBufferSize() != 0)
          try {
            if (response.isCommitted()) {
              out.flush();
            } else {
              out.clearBuffer();
            }
          } catch (java.io.IOException e) {}
        if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
        else throw new ServletException(t);
      }
    } finally {
      _jspxFactory.releasePageContext(_jspx_page_context);
    }
  }
}

部分讲解：

方法

//初始化  
public void _jspInit() {}
//销毁
public void _jspDestroy() {}
//
public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)

内置对象

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:代表当前页
final javax.servlet.http.HttpServletRequest request   //请求
final javax.servlet.http.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页面中：

只要是Java代码就会原封不动的输出；

如果是HTML代码，就会被转换为：

out.write("n");

然后输出

JSP原理图：

JSP基础语法 JSP表达式

  <%--JSP表达式
  作用：用来将程序输出到客户端
  <%= 变量或者表达式%>
  --%>
  <%= new java.util.Date()%>

JSP脚本片段

  <%--JSP脚本片段--%>
  <%
    int sum = 0;
    for (int i = 0; i < 100; i++) {
      sum = sum + i;
    }
    out.println("Sum="+sum+"");
  %>

脚本片段的再实现

  <%
    int x = 10;
    out.println(x);
  %>
  <%
    int y = 10;
    out.println(y);
  %>
  
  <%--在代码中嵌入HTML代码--%>
  <%
    for (int i = 0; i < 5; i++) {
  %>
    Hello World  <%=i%>
  <%
    }
  %>

JSP声明

  <%!
    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会！

测试定制页面错误，页面跳转到自定义错误的页面

<%--
  Created by IntelliJ IDEA.
  User: shiga
  Date: 2021/9/3
  Time: 20:58
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>

<%--在web.xml文件配置了，这里就不需要了--%>
<%--定制错误页面--%>
<%@ page errorPage="error/500.jsp" %>



    Title



<%
    int x =1/0;
%>

自定义的404和500页面：

<%--
  Created by IntelliJ IDEA.
  User: shiga
  Date: 2021/9/3
  Time: 21:20
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    Title

<%--
  Created by IntelliJ IDEA.
  User: shiga
  Date: 2021/9/3
  Time: 20:59
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    Title

跳转页面的两种方式：

使用JSP指令<% @ args… %>

<%--定制错误页面--%>
<%@ page errorPage="error/500.jsp" %>

在web.xml文件中配置

    
        404
        /error/404.jsp
    

    
        500
        /error/500.jsp

JSP指令

<% @ page 属性名1="属性值1" 属性名2="属性值2" ... %>

属性名称	取值范围	描述
language	Java	指明解释该JSP时采用的语言，默认为Java
import	任何包名，类名	import属性，写了之后会自动添加到servlet的import语句中，但不进行包存在性的检查
session	true，false	Session对象是否参与会话，session="false"就没有session对象了
isErrorPage	true，false	isErrorPage=“true false” 设置此页是否为出错页，如果被设置为true,你就能使用exception对象
errorPage	某个JSP页面的相对路径	设置处理异常事件的JSP文件。
contentType	有效的文档类型	contentType属性设置发送到客户端文档的响应报头的类型和字符编码。多个使用;号分开。 pageEncodeing属性只用于更改字符编码
PageEnCoding	当前页面	指定页面编码格式

例子：

<%--定制错误页面--%>
<%@ page errorPage="error/500.jsp" %>
<%--显示的声明这是一个错误页面--%>
<%@ page isErrorPage="true" %>

<%@ page pageEncoding="utf-8" %>

include指令

网站前面的导航栏和底部栏，跳转页面一直固定不动，用的是i<%@ include file=""%>或

<%--@ include会将两个页面合二为一--%>
<%@ include file="common/header.jsp"%>
网页主体
<%@ include file="common/footer.jsp"%>


<%--JSP标签
    jsp:include:拼接页面，本质还是三个
        --%>
<%--JSP标签--%>

网页主体

9大内置对象（JSP隐式对象）

JSP隐式对象：

名称	类型	描述
out	javax.servlet.jsp.JspWriter	用于页面输出
request	javax.servlet.jsp.HttpServletRequest	得到用户请求
response	javax.servlet.jsp.HttpServletResponse	服务端向客户端回应信息
config	javax.servlet.jsp.ServletConfig	服务器配置，可以得到初始化参数
session	javax.servlet.http.HttpSession	用来保存用户信息
application	javax.servlet.jsp.ServletContext	所有用户的共享信息
page	java.lang.Object	指当前页面转换后的Servlet实例
pageContext	javax.servlet.jsp.PageContext	JSP的页面容器
exception	java.lang.Throwable	表示JSP页面所发生的异常，在错误页面才起作用

测试：

pageContextDemo01.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    pageContext



<%--内置对象--%>
<%
    pageContext.setAttribute("name1","鲁班一号");//保存的数据只在一个页面中有效
    request.setAttribute("name2","鲁班二号");//保存的数据只在一次请求中有效，请求转发会携带这个数据
    session.setAttribute("name3","鲁班三号");//保存的数据只在一次会话中有效，从打开浏览器到关闭浏览器
    application.setAttribute("name4","鲁班四号");//保存的数据只在服务器中有效，从打开服务器到关闭服务器
%>

<%--脚本片段中的代码，会被原封不动的生成到JSP.java
要求:必须保证Java语法的正确性
--%>
<%--
    public static final int PAGE_SCOPE = 1;
    public static final int REQUEST_SCOPE = 2;
    public static final int SESSION_SCOPE = 3;
    public static final int APPLICATION_SCOPE = 4;
--%>
<%
    //从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");  //不存在

    pageContext.forward("/PageDemo02.jsp");  //请求转发到PageDemo02.jsp
%>

<%--使用EL表达式输出${}--%>
取出的值为:
${name1}
${name2}
${name3}
${name4}
${name5}   <%--什么也不会输出，也不报错--%>
<%=name5%>  <%--会输出  null--%>

PageDemo02.jsp

从PageDemo02.jsp页面输出，只输出了 “鲁班三号和鲁班四号” (作用域不同)

<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    Title



<%--脚本片段中的代码，会被原封不动的生成到JSP.java
要求:必须保证Java语法的正确性
--%>
<%
    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}   <%--什么也不会输出，也不报错--%>
<%=name5%>  <%--会输出  null--%>

PageDemo03.jsp

关于作用域的一些方法和类（源码）

<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    Title


<%--PageContextImpl--%>
<%--
    public void setAttribute(String name, Object attribute, int scope) {
        switch(scope) {
        case 1:
            this.mPage.put(name, attribute);
            break;
        case 2:
            this.mRequest.put(name, attribute);
            break;
        case 3:
            this.mSession.put(name, attribute);
            break;
        case 4:
            this.mApp.put(name, attribute);
            break;
        default:
            throw new IllegalArgumentException("Bad scope " + scope);
        }

    }
--%>

<%--PageContext--%>
<%--
public abstract class PageContext extends JspContext {
    public static final int PAGE_SCOPE = 1;
    public static final int REQUEST_SCOPE = 2;
    public static final int SESSION_SCOPE = 3;
    public static final int APPLICATION_SCOPE = 4;
    public static final String PAGE = "javax.servlet.jsp.jspPage";
    public static final String PAGEConTEXT = "javax.servlet.jsp.jspPageContext";
    public static final String REQUEST = "javax.servlet.jsp.jspRequest";
    public static final String RESPonSE = "javax.servlet.jsp.jspResponse";
    public static final String ConFIG = "javax.servlet.jsp.jspConfig";
    public static final String SESSION = "javax.servlet.jsp.jspSession";
    public static final String OUT = "javax.servlet.jsp.jspOut";
    public static final String APPLICATION = "javax.servlet.jsp.jspApplication";
    public static final String EXCEPTION = "javax.servlet.jsp.jspException";
--%>

<%
    pageContext.setAttribute("hello1","hello2",PageContext.SESSION_SCOPE);//等价于session.setAttribute("hello1","hello2");

%>

PageContextDemo02.jsp

两者都可以实现请求转发

<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    Title



<%
    pageContext.forward("/index.jsp");//request.getRequestDispatcher("/index.jsp").forward(request,response);两个都可以实现请求转发
%>

JSP标签 JSTL标签 EL表达式

JSTL标签 EL表达式需要导入相应的包


    javax.servlet.jsp.jstl
    jstl-api
    1.2



    taglibs
    standard
    1.1.2

EL表达式

${ }

获取数据
执行运算
获取web开发的常用对象

JSP标签

<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    Title

JSTL表达式核心标签***

格式：

标签	描述
	用于在JSP中显示数据，就像<%= … >
	用于保存数据
	用于删除数据
	用来处理产生错误的异常状况，并且将错误信息储存起来
	与我们在一般程序中用的if一样
	本身只当做和的父标签
	的子标签，用来判断条件是否成立
	的子标签，接在标签后，当标签判断为false时被执行
	检索一个绝对或相对 URL，然后将其内容暴露给页面
	基础迭代标签，接受多种集合类型
	根据指定的分隔符来分隔内容并迭代输出
	用来给包含或重定向的页面传递参数
	重定向至一个新的URL.
	使用可选的查询参数来创造一个URL

使用JSTL标签的步骤：

引用核心标签库

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

使用其中的方法
在Tomcat也需要引入 jstl-api 和 standard 两个包，否则会报错：JSTL解析错误

c:if c:out

EL表达式获取表单中的数据
${param.username}

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>


    Title




    <%--
    EL表达式获取表单中的数据
    ${param.username}
    --%>
    
    


<%--判断如果提交的用户是管理员，则登录成功--%>

    


<%--自闭和标签--%>

c:set c:choose c:when

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>


    Title



<%--定义一个变量score 值为85--%>



    
           <%--用输出，直接输出也可--%>
        你的成绩为优秀
    
    
        
        你的成绩为良好
    
    
        
        你的成绩为中等
    
    
        
        你的成绩为一般
    
    
        
        你的成绩为不及格

c:forEach

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page import="java.util.ArrayList" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    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:步长
--%>

JavaBean(了解一下)

实体类

JavaBean有特定的写法：

必须要有一个无参构造
属性必须私有化
必须有对应的get/set方法

一般用来和数据库的字段做映射 ORM；

ORM：对象关系映射

表----->类
字段----->属性
行记录----->对象

People表：

id	name	age	address
1	鲁班一号	18	信阳
2	鲁班二号	19	新县
3	鲁班三号	20	潢川

package com.sgl.pojo;

//实体类  一般都是和数据库中的表结构一一对应!
public class People {
    private int id;
    private String name;
    private int age;
    private String address;

    public People() {
    }

    public People(int id, String name, int age, String address) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "People{" +
                "id=" + id +
                ", name='" + name + ''' +
                ", age=" + age +
                ", address='" + address + ''' +
                '}';
    }
}

jsp:useBean jsp:setProperty jsp:getProperty

<%@ page import="com.sgl.pojo.People" %><%--
  Created by IntelliJ IDEA.
  User: shiga
  Date: 2021/9/5
  Time: 20:45
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    Title



<%
    People people02 = new People();
    people02.setAddress("新县");
    people02.setAge(19);
    people02.setId(2);
    people02.setName("鲁班二号");

%>
<%=people02.getAddress()%>
<%=people02.getAge()%>
<%=people02.getId()%>
<%=people02.getName()%>




<%--id="people01"  people01就相当于People类的一个实例化对象--%>






住址:
年龄:
id:
姓名:

在数据库建立对应的表

MVC三层架构

JSP Model2模型采用JSP（View）+Servlet（Controller）+JavaBean（Model）的技术

模型（Model）：负责管理应用程序的业务数据，定义访问控制以及以及修改这些业务数据的业务规则

简单理解：

1. 业务处理：业务逻辑（Service）
2. 数据持久化：CRUD（Dao）

视图（View）：负责与用户交互，它从模型中获取数据向用户展示，同时也能将用户请求传递给控制器进行处理。当模型的状态发送改变时，视图会对用户界面进行同步更新，从而保持与模型数据的一致性

简单理解：

1. 展示数据  
2. 提供链接发送Servlet请求（a，form，img.....）

控制器（Controller）：是负责应用程序中处理用户交互的部分，它负责从视图中读取数据，控制用户输入，并向模型发送数据

简单理解：

1. 接收用户的请求：（req：请求参数、Session信息）
2. 交给业务层处理相对于的代码  3.控制视图的跳转

登录--->接收用户的登录请求--->处理用户的请求（获取用户登录的参数，username，password）--->交给业务层处理登录业务（判断用户密码是否正确：事务）--->Dao层查询用户和密码是否正确--->数据库

JSP Model2工作原理图

3个模型之间的关系和功能图

Filter***

Filter：过滤器，用来过滤网站的数据；

处理中文乱码
登录验证

Filter开发步骤：

导包不要导错

pom.xml

    
    
      javax.servlet
      javax.servlet-api
      4.0.1
    
    
    
      javax.servlet.jsp
      javax.servlet.jsp-api
      2.3.3
    
    
    
      javax.servlet.jsp.jstl
      jstl-api
      1.2
    
    
    
      taglibs
      standard
      1.1.2
    
    
    
      mysql
      mysql-connector-java
      5.1.37

编写过滤器

过滤器：看代码注释理解

package com.sgl.filter;

import javax.servlet.*;
import java.io.IOException;

public class CharacterEncodingFilter implements Filter {
    //初始化：web服务器启动，就初始化，随时等待过滤器对象出现
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("CharacterEncodingFilter初始化");
    }

    //销毁：web服务器关闭的时候，过滤会销毁
    @Override
    public void destroy() {
        System.out.println("CharacterEncodingFilter销毁");
    }

    //filterChain:链
    
    @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执行后...");
    }
}

经过过滤器处理中文乱码的代码

package com.sgl.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class ShowServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().write("你好呀！世界");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

虚拟路径配置 web.xml


        ShowServlet
        com.sgl.servlet.ShowServlet
    
    
        ShowServlet
        /ShowServlet
    

    
        CharacterEncodingFilter
        com.sgl.filter.CharacterEncodingFilter
    
    
        CharacterEncodingFilter
        
        


}

回忆session销毁

手动销毁 getSession().invalidate();
自动销毁在web.xml配置

web.xml中配置监听器

    
    
        com.sgl.listener.OnlineCountListener

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>



当前有 <%=this.getServletConfig().getServletContext().getAttribute("OnlineCount")%>人在线

效果：

过滤器监听器的常见应用

监听器：GUI中经常使用

package com.sgl.listener;

import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

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,0));//设置背景颜色

        panel.setBounds(50,50,300,300);
        panel.setBackground(new Color(0,25,26));

        frame.add(panel);
        frame.setVisible(true);

        //监听事件
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                super.windowClosing(e);
                System.exit(1);
            }
        });
    }
}

JavaWeb基础知识（有错误请大家在评论指出）

Java相关栏目本月热门文章