JavaWebJavaWeb的基本概念 Web开发： web，网页的意思静态web html,css 提供给所有人看的

JavaWeb的基本概念

Web开发：

web，网页的意思
静态web
- html,css
- 提供给所有人看的数据始终不会发生变化
动态web
- 提供给所有人看的数据始终会发生变化，每个人在不同的时间，不同的地点看到的信息各不相同！
- 技术栈：Servlet/ISP,ASP,PHP

在java中，动态web资源开发的技术统称为JavaWeb

Servlet

HelloServlet

构建一个普通的Maven项目，删除里面的src目录，这个空的工程就是Maven的主工程
关于Maven父子工程的理解

父项目中会有

<modules>
  <module>servlet01</module>
</modules>

子项目中会有

<parent>
    <groupId>org.example</groupId>
    <artifactId>untitled12</artifactId>
    <version>1.0-SNAPSHOT</version>
</parent>

父项目中的java子项目可以直接使用

son extends father

Maven环境优化

修改web.xml为最新的

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                      http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0"
         metadata-complete="true">


</web-app>

将maven的结构搭建完整

编写一个Servlet程序
1. 编写一个普通类
2. 实现Servlet接口

package com.kuang.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.io.PrintWriter;

public class HelloServlet extends HttpServlet {
    
    // 由于get或者post只是请求实现的不同方式，可以相互调用，业务逻辑都一样
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        PrintWriter writer = resp.getWriter(); // 响应流
        writer.print("Hello,Servlet");
    }

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

编写Servlet的映射

为什么需要映射： 我们写的是JAVA程序，但需要经过浏览器访问，而浏览器需要连接web服务器，所以我们需要在web服务中注册我们写的Servlet，还需给他们一个浏览器能够访问的路径。

<!-- 注册Servlet -->
<servlet>
   <servlet-name>hello</servlet-name>
   <servlet-class>com.kuang.servlet.HelloServlet</servlet-class>
</servlet>
<!-- Servlet的请求路径 -->
<servlet-mapping>
   <servlet-name>hello</servlet-name>
   <url-pattern>/hello</url-pattern>
</servlet-mapping>

配置Tomcat

注意：配置项目的发布路径

启动测试

Srvlet原理

前端会打包所有信息到request里传到后端来，后端通过response处理好传回前端通过渲染展示

Servlet是由Web服务器调用，web服务器在收到浏览器请求之后，会：

Mapping问题

1. 一个Servlet可以指定一个映射路径

<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>

2. 一个Servlet可以指定多个映射路径

<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello1</url-pattern>
</servlet-mapping>

<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello2</url-pattern>
</servlet-mapping>

<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello3</url-pattern>
</servlet-mapping>

3. 一个Servlet可以指定通用的映射路径

<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello/*</url-pattern>
</servlet-mapping>

4. 可以自定义后缀实现请求映射

<!-- 注意：*前面不能加映射的路径 ->
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>*.qinjiang</url-pattern>
</servlet-mapping>

优先级问题

指定了固有的映射路径优先级最高，如果找不到，就会走默认的处理请求

ServletContext

web容器在启动的时候，它会为每个web程序都创建一个对应的ServletContext对象，它代表当前的web应用；

1.共享数据

我在这个Servlet中保存的数据，可以在另一个Servlet中拿到；

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();

        String username = "秦疆"; // 数据
        context.setAttribute("username",username); // 将一个数据保存在了ServletContext中，名字为：username，值：秦疆

        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);
    }

<servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>com.kuang.servlet.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>

<servlet>
    <servlet-name>getc</servlet-name>
    <servlet-class>com.kuang.servlet.GetServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>getc</servlet-name>
    <url-pattern>/getc</url-pattern>
</servlet-mapping>

2.获得初始化参数

<!-- 配置一些web应用的初始化参数 -->
<context-param>
    <param-name>url</param-name>
    <param-value>jdbc:mysql://localhost:3306/mybatis</param-value>
</context-param>

public class Servletdome03 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 {
        doGet(req, resp);
    }
}

<servlet>
    <servlet-name>gp</servlet-name>
    <servlet-class>com.kuang.servlet.Servletdome03</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>gp</servlet-name>
    <url-pattern>/gp</url-pattern>
</servlet-mapping>

3.请求转发（请求的是sd4，却到了gp的页面）

public class ServletDome04 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        System.out.println("进入了ServeletDemo04");
        // RequestDispatcher requestDispatcher = context.getRequestDispatcher("/gp");// 转发的请求路径
        // requestDispatcher.forward(req,resp); // 调用forward实现请求转发
        context.getRequestDispatcher("/gp").forward(req,resp);
    }

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

<servlet>
    <servlet-name>sd4</servlet-name>
    <servlet-class>com.kuang.servlet.ServletDome04</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>sd4</servlet-name>
    <url-pattern>/sd4</url-pattern>
</servlet-mapping>

4.读取资源文件

Properties

在java目录下新建properties
在resources目录下新建的properties

发现：都打包到了一个路径下：classes，我们俗称这个路径为classpath

思路：需要一个文件流

username = root
password = 123456

public class ServletDome05 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        InputStream is = context.getResourceAsStream("/WEB-INF/classes/db.properties");
        Properties properties = new Properties();
        properties.load(is);
        String username = properties.getProperty("username");
        String password = properties.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；

如果要获取客户端请求过来的参数：找HttpServletResponse
如果要客户端响应一些信息：找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);

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);

2. 常见应用

向浏览器输出消息
下载文件

public class FileServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 1. 要获取下载文件的路径
        String realPath = "C:\Users\Lenovo\IdeaProjects\untitled12\response\target\classes\kl.png";
        System.out.printf("下载文件的路径："+realPath);
        // 2. 下载的文件名叫什么
        String filename = realPath.substring(realPath.lastIndexOf("//") + 1);
        // 3. 设置想办法让浏览器能够支持下载我们需要的东西
        resp.setHeader("Content-Disposition","attachment;filename"+filename);
        // 4. 获取下载文件的输入流
        FileInputStream in = new FileInputStream(realPath);
        // 5. 创建缓冲区
        int len = 0;
        byte[] buffer = new byte[1024];
        // 6. 获取QutputStream对象
        ServletOutputStream out = resp.getOutputStream();
        // 7. 将QutputStream流写入到buffer缓冲区
        while ((len=in.read(buffer))>0){
            out.write(buffer,0,len);
        }

        in.close();
        out.close();

    }

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

3. 验证码功能

public class ImageServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 如何让浏览器3秒刷新一次
        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("Pragme","no-cache");

        // 把图片写给浏览器
        ImageIO.write(image,"jpg", resp.getOutputStream());
    }
    // 生成随机数
    private String makeNum(){
        Random random = new Random();
        String num =  random.nextInt(9999999)+"";
        StringBuffer sb = new StringBuffer();
        for (int i =0;i<7-num.length();i++){
            sb.append("0");
        }
        num = sb.toString() + num;
        return num;
    }


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

实现重定向（重点）

A一个web资源收到客户端B请求后，A他会通知客户端去访问另一个web资源C，这个过程叫重定向

常见场景

用户登录

resp.sendRedirect("/r/img"); // r是Tomcat里面设置的

<html>
<body>
<%@ page contentType="text/html; charset=UTF-8" %>
<h2>Hello World!</h2>
<%--  这里提交的路径，需要寻找到项目的路径  --%>
<%--${pageContext.request.contextPath}代表当前项目--%>
    <form action="${pageContext.request.contextPath}/login" method="get">
        用户名：<input type="text" name="username"><br>
        密码： <input type="password" name="password"><br>
        <input type="submit">
    </form>
</body>
</html>

public class RequestTest extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 处理请求
        String username = req.getParameter("username");
        String password = req.getParameter("password");

        System.out.printf(username+":"+password);

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

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

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>Success</h1>
</body>
</html>

HttpServletRequest

HttpServletRequest代表客户端的请求，用户通过Http协议访问服务器，HTTP请求中的所有信息会被封装到HttpServletRequest，通过这个HttpServletRequest的方法，获得客户端的所有信息；

获得前端传递的参数

// 重点常用的
req.getParameter();
req.getParameterValues()

请求转发

<html>
<head>
    <title>登录</title>
</head>
<body>
<h1>登录</h1>

<div style="text-align: center">
<%--  这里表单表示的意思是，一post方式提交表单，提交到我们的login请求  --%>
    <form action="${pageContext.request.contextPath}/login" method="post">
        用户名：<input type="text" name="username"><br>
        密码:<input type="password" name="password"><br>
        爱好：
        <input type="checkbox" name="hobbys" value="女孩">女孩
        <input type="checkbox" name="hobbys" value="代码">代码
        <input type="checkbox" name="hobbys" value="唱歌">唱歌
        <input type="checkbox" name="hobbys" value="电影">电影
        <br>
        <input type="submit">
    </form>
</div>
</body>
</html>

public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String username = req.getParameter("username");
        String password = req.getParameter("password");

        // 多个
        String[] hobbys = req.getParameterValues("hobbys");


        // 通过请求转发
        // 这里的/ 代表当前的web应用
        req.getRequestDispatcher("/sussess.jsp").forward(req,resp);

    }

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

Cookie.Session

会话

会话： 用户打开了一个浏览器，点击了很多超链接，访问了多个web资源，关闭浏览器，这个过程可以被称之为会话

有状态会话: 一个同学来过教室，下次来教室，我们会知道这个同学曾经来过，称之为有状态对话；

一个网站，怎么证明你来过？
客户端 ~~~~~~ 服务端

给服务端给客户端一个信件，客户端下次访问服务器带上信件就可以了；Cookie
服务器登记你来过了，下次你来的时候我来匹配你；Session

保存会话的两种技术

cookie：

一种客户端技术（请求，响应） session：
服务器技术，利用这个技术可以保存用户的会话信息，我们可以把信息或者数据放在Session中。

Cookie

从请求中拿到cookie信息
服务器响应给客户端cookie

public class CookieDemo01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 服务器，告诉你，你来的时间，你把这个时间封装成一个信件，下次再来，就知道你来了

        // 解决中文乱码
        req.setCharacterEncoding("utf-16");
        resp.setCharacterEncoding("utf-16");

        PrintWriter out = resp.getWriter();

        // Cookie,服务器从客户端获取
        Cookie[] cookies = req.getCookies();// 这里返回数组说明可以储存多个

        // 判断Cookie是否存在
        if (cookies!=null){
            out.write("您上次访问点时间");
            for (int i = 0; i < cookies.length; i++) {
                Cookie cookie = cookies[i];
                // cookie.getName()  获取cookie的key
                if (cookie.getName().equals("lastLoginTime")){
                    // 获取cookie的值
                    long lastLoginTime = Long.parseLong(cookie.getValue());
                    Date date = new Date(lastLoginTime);
                    out.write(date.toLocaleString());

                }
            }
        }else {
            out.write("这是您的第一次访问");
        }

        // 服务器给客户端响应一个Cookie；
        Cookie cookie = new Cookie("lastLoginTime",System.currentTimeMillis()+"");

        // cookie有效期为一天
        cookie.setMaxAge(24*6*60);

        resp.addCookie(cookie);
    }

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

cookie的细节问题：

一个Cookie只能保存一个信息
一个web站点可以给浏览器发送多个cookie，最多存放20个cookie
cookie的大小有限制4KB
300个cookie浏览器上限

删除Cookie：

不设置有效期，关闭浏览器，自动失效
设置有效期时间为0

Session（重点）

Session：

服务器会给每一个用户（浏览器）创建一个Seesion对象；
一个Seesion独占一个浏览器，只要浏览器没有关闭，这个Session就存在；
用户登录之后，整个网站都可以访问，-->保存用户信息；保存购物车信息......

Session和Cookie的区别

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

Session的使用：

package com.kuang.pojo;

public class Persen {
    private String name;
    private int age;

    public Persen(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

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.setContentType("text/html;charset=utf-8");

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

        // 给Session中存数据
        session.setAttribute("name",new Persen("zcw",1));

        // 获取Session的ID
        String id = session.getId();

        // 判断Session是不是新创建
        if(session.isNew()){
            resp.getWriter().write("Session创建成功，ID："+id);
        }else {
            resp.getWriter().write("Session已经在服务器中存在了，ID"+id);
        }

    }

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

获取Session信息

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.setContentType("text/html;charset=utf-8");

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

        Persen persen = (Persen) session.getAttribute("name");
        System.out.println(persen.toString());
    }

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

Session手动删除

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默认失效的时间 -->
  <session-config>
<!--  15分钟后Session自动失效  ，以分钟为单位  -->
    <session-timeout>1</session-timeout>
  </session-config>

JSP

什么是JSP

Java Server Pages ： Java服务器端页面，也和Servlet一样，用于动态Web技术！最大的特点：

写JSP就像在写HTML
区别
- HTML只能给用户静态页面
- JSP页面可以嵌入JAVA代码，为用户提供动态数据

JSP原理

浏览器向服务器发送一个请求，无论访问什么资源，其实都是在访问Servlet，JSP最终也会被转化成Java类，JSP本质就是一个Servlet

// 初始化
  public void _jspInit() {
    }
// 销毁
    protected void _jspDestroy() {
    }
// JSPservice
    public void _jspService(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException;

判断请求
内置一些对象

    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; charset=UTF-8");  // 设置响应的页面类型
      pageContext = _jspxFactory.getPageContext(this, request, response,
      			null, false, 8192, true);
      _jspx_page_context = pageContext;
      application = pageContext.getServletContext();
      config = pageContext.getServletConfig();
      out = pageContext.getOut();
      _jspx_out = out;

JSP的基础语法

首先配置依赖

<!--  Servlet 依赖  -->
    <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
    </dependency>
<!-- JSP依赖 -->
    <!-- https://mvnrepository.com/artifact/javax.servlet.jsp/javax.servlet.jsp-api -->
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>javax.servlet.jsp-api</artifactId>
      <version>2.3.3</version>
    </dependency>
<!-- JSTL依赖 -->
    <!-- https://mvnrepository.com/artifact/javax.servlet.jsp.jstl/jstl-api -->
    <dependency>
      <groupId>javax.servlet.jsp.jstl</groupId>
      <artifactId>jstl-api</artifactId>
      <version>1.2</version>
    </dependency>
<!--  standard 标签库  -->
    <!-- https://mvnrepository.com/artifact/taglibs/standard -->
    <dependency>
      <groupId>taglibs</groupId>
      <artifactId>standard</artifactId>
      <version>1.1.2</version>
    </dependency>

任何语言都有自己的语法，JAVA中有，JSP作为java技术的一种应用，它拥有一些自己扩充的语法（了解，只到即可），java语法都支持！

JSP表达式

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

JSP脚本片段

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

脚本片段再实现

<%
    int x =10;
    out.println(x);
%>
<p>这是一个JSP文档</p>
<%
    out.println(x);
%>

<hr>

<%
    for (int i = 0; i < 5; i++) {
%>
<p>hello   <%=i %> </p>
<%
    }
%>

JSP声明

<%!
    static {
        System.out.println("Loading Servlet");
    }
    
    private int globalvar = 0;
    
    public void zhuang(){
    System.out.println("进入了方法zhang！");
    }
%>

JSP声明： 会被编译到JSP生成的Java类中！其他的，就会被生成到_jspServlet方法中

JSP指令

<%@ page args...... %>
<%@ include file=" " %>

JSP标签

<jsp:include page="/commom/header.jsp"/>

9大内置对象

PageContext 存东西
Request 存东西
response
Session 存东西
Application [SerlvetContext] 存东西
config [ServletConfig]
out
page 几乎不用
exception

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<%--内置对象--%>
<%
    pageContext.setAttribute("name1","zcw1"); // 保存的数据只在一个页面内有效
    request.setAttribute("name2","zcw2"); // 保存的数据只在一次请求中有效，请求转发会携带这个数据
    session.setAttribute("name3","zcw3"); // 保存的数据只在一次对话中有效，从打开浏览器到关闭浏览器
    application.setAttribute("name4","zcw4"); // 保存的数据只在服务器中有效，从打开服务器，到关闭服务器
%>

<%--脚本片段的代码会被原封不动的生成到JSP.java
要求：这里面的代码：必须保证Java语法的正确性
--%>
<%
    // 从pageContext取出
    pageContext.getAttribute("name1");
    // 通过寻找的方式
    // 从底层到高层（作用域）： page-->request-->session-->application
    String name1 =(String) pageContext.findAttribute("name1");
    String name2 =(String) pageContext.findAttribute("name2");
    String name3 =(String) pageContext.findAttribute("name3");
    String name4 =(String) pageContext.findAttribute("name4");
%>

<%--使用EL表达式输出  ${}--%>
<h1>取出的值为</h1>
<h3>${name1}</h3>
<h3>${name2}</h3>
<h3>${name3}</h3>
<h3>${name4}</h3>
</body>
</html>

JSP标签.JSTL标签.EL表达式

EL表达式：${......}

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

需要导入需要的java包

<!-- JSTL依赖 -->
    <!-- https://mvnrepository.com/artifact/javax.servlet.jsp.jstl/jstl-api -->
    <dependency>
      <groupId>javax.servlet.jsp.jstl</groupId>
      <artifactId>jstl-api</artifactId>
      <version>1.2</version>
    </dependency>
<!--  standard 标签库  -->
    <!-- https://mvnrepository.com/artifact/taglibs/standard -->
    <dependency>
      <groupId>taglibs</groupId>
      <artifactId>standard</artifactId>
      <version>1.1.2</version>
    </dependency>

JSP标签

<body>
<%--<jsp:include page=""></jsp:include>
连接页面
--%>
1
<jsp:forward page="/jsp2.jsp">
  <jsp:param name="name1" value="zhang"/>
  <jsp:param name="name2" value="chen"/>
</jsp:forward>
</body>

JSTL标签库

JSTL标签库的使用是为了弥补HTML标签的不足；它自定义许多标签，可以供我们使用，标签的功能和java代码一样！ [JSP 标准标签库]

标签库:

核心标签(重点掌握)

引用核心标签库的语法如下：

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

JSTL标签库使用步骤

引入对应的taglib
使用其中的方法（Tomcat也需要引入jatl包，否则会报错：JSTL解析错误）

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%--引入JSTL核心标签库，我们才能使用JSTL标签 --%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h4>if测试</h4>
<form action="coreif.jsp" method="get">
<%--
  EL表达式获取表单中的信息
  ${param.参数名}
  --%>
    <input type="text" name="username" value="${param.username}">
    <input type="submit" value="登录">


<%--  判断，如果提交的用户名是管理员，则登录成功  --%>
    <c:if test="${param.username=='admin'}" var="isAdmin">
        <c:out value="管理员欢迎您"/>
    </c:if>

    <c:out value="${isAdmin}"/>
</form>
</body>
</html>

格式化标签

引用格式化标签库的语法如下：

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

SQL标签

引用SQL标签库的语法如下：

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

XML 标签

引用XML标签库的语法如下：

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

JSTL函数

引用JSTL函数库的语法如下：

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

JavaBean

实体类

JavaBean有特定写法：

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

package com.kuang.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 + ''' +
                '}';
    }
}

一般用来和数据库的字段做映射 ORM ORM：对象关系映射

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

<%@ page import="com.kuang.pojo.People" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>

<html>
<head>
    <title>Title</title>
</head>
<body>
<%
    // People people = new People();
%>

<jsp:useBean id="people" class="com.kuang.pojo.People" scope="page"/>

<jsp:setProperty name="people" property="name" value="zcw"/>
<jsp:setProperty name="people" property="id" value="1"/>
<jsp:setProperty name="people" property="age" value="3"/>
<jsp:setProperty name="people" property="address" value="山东"/>

<jsp:getProperty name="people" property="name"/>
<jsp:getProperty name="people" property="id"/>
<jsp:getProperty name="people" property="age"/>
<jsp:getProperty name="people" property="address"/>
</body>
</html>

MVC三层架构

什么是MVC：model ， view ， Controller 模型，视图，控制器

早些年

MVC三层架构

用户直接访问控制层，控制层直接操作数据库；

servlet--CRUD-->数据库
弊端：程序十分的臃肿，不利于维护
servlet的代码中：处理请求，响应，视图跳转，处理JDBC，处理业务代码，处理逻辑代码

架构：没有什么事加一层解决不了的
程序员调用-->JDBC-->Mysql ， Oracle ， SqlServer......

Model：

业务处理：业务逻辑（Service）
数据持久层：CRUD（Dao）

View：

展示数据
提供连接发起的Servlet请求（a，form，img...）

Controller（Servlet）

接收用户请求：（req：请求参数，Session信息...）
交给业务层处理对应代码
控制视图跳转

过滤器Filter（重点）

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

处理中文代码
登录验证...

Filter的开发步骤：

导包

<!--   连接数据库   -->
      <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
      <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>8.0.27</version>
      </dependency>

编写过滤器

导包不要错

必须选择javax.servlet的Filter

2. 实现Filter接口，重写对应的方法

public class CharaterEncodingFilter 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>CharaterEncodingFilter</filter-name>
        <filter-class>com.kuang.filter.CharaterEncodingFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>CharaterEncodingFilter</filter-name>
<!--    只要是/servlet的任何请求，就会经过这个过滤器     -->
        <url-pattern>/servlet/*</url-pattern>
    </filter-mapping>

监听器

public class OnlineCountListener implements HttpSessionListener {
    @Override
    public void sessionCreated(HttpSessionEvent se) {
        // 创建Session监听：看你的一举一动
        // 一旦创建Session就会触发这个事件
        ServletContext cxt = se.getSession().getServletContext();

        Integer onlineCount = (Integer) cxt.getAttribute("OnlineCount");

        if (onlineCount==null){
            onlineCount = new Integer(1);
        }else {
            int count = onlineCount.intValue();
            onlineCount = new Integer(count+1);
        }

        cxt.setAttribute("OnlineCount",onlineCount);
    }

    @Override
    public void sessionDestroyed(HttpSessionEvent se) {
        // 销毁session监听
        // 一旦销毁Session就会触发这个事件！
        ServletContext cxt = se.getSession().getServletContext();

        Integer onlineCount = (Integer) cxt.getAttribute("OnlineCount");

        if (onlineCount==null){
            onlineCount = new Integer(0);
        }else {
            int count = onlineCount.intValue();
            onlineCount = new Integer(count-1);
        }

        cxt.setAttribute("OnlineCount",onlineCount);
    }
}

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>当前有<span><%= this.getServletConfig().getServletContext().getAttribute("OnlineCount")%></span>人在线</h1>
</body>
</html>

<!--  注册监听器  -->
    <listener>
        <listener-class>com.kuang.listener.OnlineCountListener</listener-class>
    </listener>

过滤器监听器的常见应用

用户登录后才能进入主页，用户注销之后就不能进入主页了！

用户登录之后，向Session中放入用户数据
进入主页的时候要判断用户是否已经登录

public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 获得前端请求的参数
        String username = req.getParameter("username");

        if (username.equals("admin")){ // 登陆成功
            req.getSession().setAttribute("USER_SESSION",req.getSession().getId());
            resp.sendRedirect("/sys/success.jsp");

        }else {// 登录失败
            resp.sendRedirect("/errer.jsp");
        }
    }

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

public class SysFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        // ServletRequest , HttpServletResponse
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;

        if (request.getSession().getAttribute("USER_SESSION")==null){
            response.sendRedirect("/errer.jsp");
        }
        filterChain.doFilter(request,response);

    }

    @Override
    public void destroy() {

    }
}

JDBC

JDBC：java连接数据库

需要jar包的支持

java.sql
javax.sql
mysql-conneter-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','zs@qq.com','2000-01-01');

INSERT INTO users(id,`name`,`password`,email,birthday)
VALUES(2,'李四','123456','ls@qq.com','2000-01-01');

INSERT INTO users(id,`name`,`password`,email,birthday)
VALUES(3,'王五','123456','ww@qq.com','2000-01-01');

SELECT * FROM users

导入数据库依赖

<!--   连接数据库   -->
      <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
      <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>8.0.27</version>
      </dependency>

JDBC固定步骤

加载驱动
连接数据库
向数据库发送SQL的对象Statement:CRUD
编写SQL
执行查询SQL，返回一个ResultSet：结果集
关闭连接，释放资源（一定要做）先开后关

public class TextJdbc {
   public static void main(String[] args) throws ClassNotFoundException, SQLException {
       // 配置信息
       // useUnicode=true&characterEncoding=utf8 解决中文乱码
       String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true";
       String username = "root";
       String password = "123456";

       // 1.加载驱动
       Class.forName("com.mysql.jdbc.Driver");
       // 2.连接数据库
       Connection connection = DriverManager.getConnection(url, username, password);

       // 向数据库发送SQL的对象Statement:CRUD
       Statement statement = connection.createStatement();

       // 4. 编写SQL
       String sql = "select * from users";

       // 5. 执行查询SQL，返回一个ResultSet：结果集
       ResultSet resultSet = statement.executeQuery(sql);

       while (resultSet.next()){
           System.out.println("id="+resultSet.getObject("id"));
           System.out.println("name="+resultSet.getObject("name"));
           System.out.println("password="+resultSet.getObject("password"));
           System.out.println("email="+resultSet.getObject("email"));
           System.out.println("birthday="+resultSet.getObject("birthday"));
       }

       // 6. 关闭连接，释放资源（一定要做）先开后关
       resultSet.close();
       statement.close();
       connection.close();
   }
}

事务

Junit单元测试 依赖

<!--   单元测试   -->
      <!-- https://mvnrepository.com/artifact/junit/junit -->
      <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.13.2</version>
      </dependency>

简单使用，@Test注解只对在方法上有效

package com.kuang.text;

import org.junit.Test;

public class Testjdbc3 {
    @Test
    public void test(){
        System.out.println("hello");
    }
}