javaweb知识点总结

http

• http(HyperText Transfer Protocol)是超文本传输协议，规定了浏览器和服务器之间数据传输规则

• 基于TCP协议：面向连接，安全

• 基于请求-响应模型：一次请求对应一次响应

• Http协议是无状态的协议：对于事务处理没有记忆能力。每次请求-响应是独立的

  • 缺点：多次请求之间不能共享数据。java解决会话问题
  • 优点：速度快

  ​

• http请求数据格式

  • 请求行：请求数据的第一行。其中GET表示请求方式，/表示请求资源路径
  • 请求头：第二行开始，格式为key、value形式
  • 请求体：post请求的最后一部分，存放请求参数

• http响应数据格式

  • 响应行：响应的第一行，像是http的版本、响应状态码、响应状态码描述
  • 响应头：第二行开始，格式为key、value形式
  • 响应体：最后一部分，存放响应的数据

创建一个java web项目

配置容器有两种方式：1、引入插件 2、配置本地服务器

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <port>8090</port>
                    <uriEncoding>UTF-8</uriEncoding>
<!--                    <path></path>-->
                </configuration>
            </plugin>
        </plugins>
    </build>

servlet入门

• Servlet是java提供的一门动态web资源开发技术
• Servlet快速入门

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>

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

@WebServlet(urlPatterns = "/demo1", loadOnStartup = 1)
public class ServletDemo1 implements Servlet {
    private ServletConfig config;
    
    @Override
    public void init(ServletConfig config) throws ServletException {
        this.config = config;
    }

    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("hello servlet!");
    }

    @Override
    public String getServletInfo() {
        return null;
    }

    @Override
    public void destroy() {

    }
}

Servlet执行流程

访问地址

http://localhost:8090/web-demo/demo1

tomcat由Servlet实现，Servlet方法由web服务器调用

• Servlet生命周期

  • 加载和实例化：默认情况下，当Servlet第一次被访问时，由容器创建Servlet对象

  ​

  • 初始化：在Servlet实例化之后，容器将调用Servlet的init()方法初始化这个对象，完成一些如加载配置文件、创建连接等初始化工作，该方法只执行一次

  ​

  • 请求处理：每次请求Servlet时，Servelt容器都会调用Servelt的service()方法对请求进行处理

  ​

  • 服务终止：当需要释放内存或者容器关闭时，容器就会调用Servlet实例的destroy()方法完成资源的释放。destroy()方法调用之后，容器会释放Servlet实例，该实例随后会被java的垃圾回收器回收

  ​

  • loadOnstartup：-1第一次被访问时创建Servlet对象 0或者正整数：服务器启动时创建Servlet对象，值越小，优先级越高

    @WebServlet(urlPatterns = "/demo1", loadOnStartup = 1)，
    

Servlet体系结构

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

@WebServlet("/demo2")
public class ServletDemo2 extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("...get");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("...post");
    }
}

访问

http://localhost:8090/web-demo/demo2

http://localhost:8090/web-demo/a.html

自定义Servlet

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

public class MyHttpServlet implements Servlet {
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {

    }

    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

    @Override
    public void service(ServletRequest servletRequest, ServletResponse response) throws ServletException, IOException {
        //根据不同的请求，做不同的处理
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        //获取请求类型
        String method = request.getMethod();
        //判断是什么请求
        if ("GET".equals(method)) {
            doGet(request,response);
        }else if("POST".equals(method)){
            doPost(request,response);
        }
    }

    protected void doPost(HttpServletRequest request, ServletResponse response) {
    }

    protected void doGet(HttpServletRequest request, ServletResponse response) {
    }

    @Override
    public String getServletInfo() {
        return null;
    }

    @Override
    public void destroy() {

    }
}

import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServletRequest;

@WebServlet("/demo4")
public class ServletDemo4 extends MyHttpServlet{
    @Override
    protected void doGet(HttpServletRequest request, ServletResponse response) {
        System.out.println("get....");
    }

    @Override
    protected void doPost(HttpServletRequest request, ServletResponse response) {
        System.out.println("post...");
    }
}

urlPatter匹配规则

@WebServlet(urlPatterns = {"/demo5","/demo6"})
public class ServletDemo5 extends MyHttpServlet{

    @Override
    protected void doGet(HttpServletRequest request, ServletResponse response) {
        System.out.println("demo5 get...");
    }


    @Override
    protected void doPost(HttpServletRequest request, ServletResponse response) {
        super.doPost(request, response);
    }
}

• 精确匹配

• 目录匹配

• 扩展名匹配

• 任意匹配
  • /，会覆盖掉tomcat的DefaultServlet，当匹配不到其它urlPattern，就会走DefaultServlet
  • /*，匹配任意路径

XML配置方式编写Servlet

• Servlet3.0之后支持使用注解配置，3.0之前只支持 XML配置方式
• 步骤
  • 编写Servlet类
  • 在web.xml配置该Servlet

package com.konglz.web;

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 ServletDemo6 extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("get demo6....");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("post demo6....");
    }
}

<?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">


    <servlet>
        <servlet-name>demo6</servlet-name>
        <servlet-class>com.konglz.web.ServletDemo6</servlet-class>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>demo6</servlet-name>
        <url-pattern>/demo6</url-pattern>
    </servlet-mapping>


</web-app>

访问地址：http://localhost:8090/web-demo/demo6

Request

• 继承体系

• 请求行
  • String getMethod()：获取请求方式
  • String getContextPath()：获取虚拟目录即项目访问路径(也叫虚拟目录)
  • StringBuffer getRequestURL()：获取URL全地址
  • String getRequestURI()：获取URI
  • String getQueryString()：获取请求参数

package com.konglz.web;

import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

@WebServlet("/demo3")
public class ServletDemo3 implements Servlet {
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {

    }

    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        //根据不同的请求，做不同的处理
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        //获取请求类型
        String method = request.getMethod();
        String contextPath = request.getContextPath();
        StringBuffer url = request.getRequestURL();
        String uri = request.getRequestURI();
        String params = request.getQueryString();

        System.out.println(method);
        System.out.println(contextPath);
        System.out.println(url);
        System.out.println(uri);
        System.out.println(params);
        //判断是什么请求
        if ("GET".equals(method)) {

        }else if("POST".equals(method)){

        }
    }

    @Override
    public String getServletInfo() {
        return null;
    }

    @Override
    public void destroy() {

    }
}

地址：http://localhost:8090/web-demo/demo3?name=klz

• 请求头
  • String getHead(String name)：根据请求头名称，获取值
• 请求体
  • ServletInputStream getInputStream()：获取字节输入流
  • BufferedReader getReader()：获取字符输入流

package com.konglz.web;

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

@WebServlet("/demo2")
public class ServletDemo2 extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("...get");
        String name = req.getParameter("name");
        resp.setHeader("content-type", "text/html;charset=utf-8");
        resp.getWriter().write("<h3>"+name+"</h3>");
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("...post");

        String method = request.getMethod();
        String contextPath = request.getContextPath();
        StringBuffer url = request.getRequestURL();
        String uri = request.getRequestURI();
        String params = request.getQueryString();

        System.out.println(method);
        System.out.println(contextPath);
        System.out.println(url);
        System.out.println(uri);
        System.out.println(params);

        String accept = request.getHeader("accept");
        String accept_encoding = request.getHeader("accept-encoding");
        String user_agent = request.getHeader("user-agent");
        System.out.println(accept);
        System.out.println(accept_encoding);
        System.out.println(user_agent);

        //获取输入字节流
        BufferedReader br = request.getReader();
        //读取数据
        String line = br.readLine();
        System.out.println(line);
    }
}

地址: http://localhost:8090/web-demo/a.html

• 请求参数
  • Map<String, String[]> getParameterMap()：获取所有参数Map集合
  • String[] getParameterValues(String name)：根据名称获取参数值(数组)
  • String getParameter(String name)：根据名称获取参数值(单个值)

请求参数中文乱码

• post请求中文乱码： response.setCharacterEncoding("UTF-8");
• get请求中文乱码：name = new String(name.getBytes(StandardCharsets.ISO_8859_1),StandardCharsets.UTF_8);

package com.konglz.web;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.IOException;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;

@WebServlet("/demo2")
public class ServletDemo2 extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("...get");
        String name = request.getParameter("name");

        //get请求编码主要是对url进行编码，解码方式默认使用的iso-8859-1,我们要设置解码方式为utf-8,web8默认解码方式是utf-8，不用解决编码方式
        name = new String(name.getBytes(StandardCharsets.ISO_8859_1),StandardCharsets.UTF_8);

        resp.setHeader("content-type", "text/html;charset=utf-8");
        resp.getWriter().write("<h3>"+name+"</h3>");
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("...post");
        //设置字符输入流的编码
        response.setCharacterEncoding("UTF-8");

        //获取输入字节流
        BufferedReader br = request.getReader();
        //读取数据
        String line = br.readLine();
        System.out.println(line);
    }
}

idea自定义Servlet模板

请求转发

• 请求转发
  • 浏览器地址栏路径不会变化
  • 只能转发到当前服务器的内部资源
  • 一次请求，可以在转发的资源键使用request共享数据

//请求转发，携带上request、response,将当前资源数据传输给另外一个资源
request.getRequestDispatcher("/").forward(request,response);

• 请求转发资源间共享数据：使用Request对象
  • void setAtrribute(String name, Object o)：存储数据到request域中
  • Object getAttribute(String name)： 根据key，获取值
  • void removeAttribute(String name)：根据key，删除该键值对

Response

• 继承体系

• 响应行、响应头、响应体

  • void setStatus(int sc)：设置响应状态
  • void setHeader(String name, String value)：设置响应头键值对
  • PrintWriter getWriter()：获取字符输出流
  • ServletOutputStream getOutputStream()：获取字节输出流

• 响应字符数据：需要设置编码

package com.konglz.web.response;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;
import java.io.PrintWriter;

@WebServlet("/resp3")
public class ResponseDemo3 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //字符输出流
        PrintWriter writer = response.getWriter();
        //conten-type
        response.setHeader("content-type", "text/html");
        response.setContentType("text/html;charset=utf-8");
        writer.write("klz");
        writer.write("<h3>klz</h3>");
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request, response);
    }
}

• 响应字节数据

package com.konglz.web.response;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

@WebServlet("/resp4")
public class ResponseDemo4 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //读取文件
        System.out.println(this.getClass().getClassLoader().getResource("img.png").getPath());
        System.out.println(this.getClass().getClassLoader().getResource("img.png").getFile());
        FileInputStream fis = new FileInputStream(new File(this.getClass().getClassLoader().getResource("img.png").getPath().substring(1)));
        //获取response字节输出流
        ServletOutputStream os = response.getOutputStream();

        //完成流的copy
        byte[] buffer = new byte[1024];
        int len = 0;
        while ((len = fis.read(buffer)) != -1){
            os.write(buffer,0,len);
        }
        fis.close();
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request, response);
    }
}

地址：http://localhost:8090/web-demo/resp4

重定向

• 重定向：一种资源跳转方式，两次请求
  • 浏览器地址栏不改变
  • 可以重定向到任意位置的资源(服务器内部，外部均可)
  • 两次请求，不能在多个资源使用request共享资源
• response.sendRedirect(“xxx”);

package com.konglz.web.response;

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

@WebServlet("/resp1")
public class ResponseDemo1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("....resp1");
      	//第一种方式
        //response.setStatus(302);
        //response.setHeader("location","/web-demo/resp2");
        //第二种方式
     	response.sendRedirect("/web-demo/resp2");
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request,response);
    }
}

package com.konglz.web.response;

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

@WebServlet("/resp2")
public class ResponseDemo2 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("....resp2");
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }
}

地址：http://localhost:8090/web-demo/resp1 重定向到 http://localhost:8090/web-demo/resp2

路径问题

• 浏览器使用：需要加虚拟目录(项目访问路径)
• 服务端使用：不需要加虚拟目录
• 动态获取虚拟目录：String getContextPath()：获取虚拟目录即项目访问路径(也叫虚拟目录)
• 获取文件路径：https://zhuanlan.zhihu.com/p/487928660

mybatis集成mysql

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.5</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.15</version>
        </dependency>

• mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--起别名-->
    <typeAliases>
        <package name="com.itheima.pojo"/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///db1?useSSL=false&amp;useServerPrepStmts=true&amp;serverTimezone=Asia/Shanghai"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!--扫描mapper-->
        <package name="com.itheima.mapper"/>
    </mappers>
</configuration>

• myabtis使用SessionFactory，这个地方使用的是单例模式写的工厂

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

public class SqlSessionFactoryUtils {

    private static SqlSessionFactory sqlSessionFactory;

    static {
        //静态代码块会随着类的加载而自动执行，且只执行一次

        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    public static SqlSessionFactory getSqlSessionFactory(){
        return sqlSessionFactory;
    }
}

@WebServlet("/loginServlet")
public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1. 接收用户名和密码
        String username = request.getParameter("username");
        String password = request.getParameter("password");

        //2. 调用MyBatis完成查询
        //2.1 获取SqlSessionFactory对象
       /* String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);*/

        SqlSessionFactory sqlSessionFactory = SqlSessionFactoryUtils.getSqlSessionFactory();
        //2.2 获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //2.3 获取Mapper
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //2.4 调用方法
        User user = userMapper.select(username, password);
        //2.5 释放资源
        sqlSession.close();


        //获取字符输出流，并设置content type
        response.setContentType("text/html;charset=utf-8");
        PrintWriter writer = response.getWriter();
        //3. 判断user释放为null
        if(user != null){
            // 登陆成功
            writer.write("登陆成功");
        }else {
            // 登陆失败
            writer.write("登陆失败");
        }
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request, response);
    }
}

jsp快速入门

• 一种动态网页技术，既可以定义html、js、css等静态内容，又可以定义java代码的动态内容
• jsp = html + java
• jsp依赖

      <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
            <scope>provided</scope>
        </dependency>

• hello.jsp

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

    <h1>hello jsp</h1>

    <%
        System.out.print("hello jsp!");
        int i = 3;
    %>

    <%="hello"%>
    <%=i%>

    <%!
        void  show(){}
        String name = "zhangsan";
    %>


</body>
</html>

jsp原理

• jsp本质上是一个Servlet
• 最终提供服务的是字节码文件

jsp脚本

• jsp脚本用于在jsp页面定义java代码

• <% %> : 内容会直接放到_jspService()方法中

• <%= %>：内容会放到 out.print() 中，作为 out.print() 的参数

• <%! %>：内容会放到_jspService()方法之外，被类直接包含

• jsp中java代码嵌套html代码

    <%
        for (int i = 0; i < brands.size(); i++) {
            Brand brand = brands.get(i);
    %>

    <tr align="center">
        <td><%=brand.getId()%></td>
        <td><%=brand.getBrandName()%></td>
        <td><%=brand.getCompanyName()%></td>
        <td><%=brand.getOrdered()%></td>
        <td><%=brand.getDescription()%></td>

        <%
            if(brand.getStatus() == 1){
                //显示启用
        %>
            <td><%="启用"%></td>
        <%
            }else {
                // 显示禁用
        %>
            <td><%="禁用"%></td>
        <%
            }
        %>

        <td><a href="#">修改</a> <a href="#">删除</a></td>
    </tr>

    <%
        }
    %>

jsp的缺点

• 书写麻烦
• 阅读麻烦
• 复杂度高：依赖各种环境
• 占内存和磁盘
• 调试困难
• 不利于团队协作

el表达式、jstl标签

• 为了解决书写麻烦、阅读麻烦等问题利用el表达式、jstl标签来处理java代码
• el表达式：显示数据${}
• jstl标签：逻辑判断判断if、foreach等标签

el表达式

• java代码和html嵌套在一起，看的脑壳疼，所以搞出了el表达式

• expression language表达式语言，用于简化jsp页面内的java代码

• javaweb中四大作用域

  • page：当前页面有效
  • request：当前请求有效
  • session：当前会话有效
  • application：当前应用有效

• 使用

  • java代码放在servlet
  • 通过request.setAttribute()，将对象存放在request域中
  • 通过request.getRequestDispatcher(“/xxx.jsp”).forward(request,response)将java的数据传递到指定的jsp页面

import com.itheima.pojo.Brand;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

@WebServlet("/demo1")
public class ServletDemo1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1. 准备数据
        List<Brand> brands = new ArrayList<Brand>();
        brands.add(new Brand(1,"三只松鼠","三只松鼠",100,"三只松鼠，好吃不上火",1));
        brands.add(new Brand(2,"优衣库","优衣库",200,"优衣库，服适人生",0));
        brands.add(new Brand(3,"小米","小米科技有限公司",1000,"为发烧而生",1));

        //2. 存储到request域中
        request.setAttribute("brands",brands);

        //3. 转发到 el-demo.jsp
        request.getRequestDispatcher("/el-demo.jsp").forward(request,response);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request, response);
    }
}

• el-demo.jsp： ${brands}会从page、request、session、apllication 中依次找数据

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
	
    ${brands}

</body>
</html>

jstl表达式

• jsp标准标签库(jsp Standarded Tag Library)，使用标签取代jsp页面上的java代码

• 参考：https://www.runoob.com/jsp/jsp-jstl.html

• 依赖

<!--jstl-->
<dependency>
  <groupId>jstl</groupId>
  <artifactId>jstl</artifactId>
  <version>1.2</version>
</dependency>

<dependency>
  <groupId>taglibs</groupId>
  <artifactId>standard</artifactId>
  <version>1.1.2</version>
</dependency>

• ServletDemo1

import com.itheima.pojo.Brand;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

@WebServlet("/demo1")
public class ServletDemo1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1. 准备数据
        List<Brand> brands = new ArrayList<Brand>();
        brands.add(new Brand(1,"三只松鼠","三只松鼠",100,"三只松鼠，好吃不上火",1));
        brands.add(new Brand(2,"优衣库","优衣库",200,"优衣库，服适人生",0));
        brands.add(new Brand(3,"小米","小米科技有限公司",1000,"为发烧而生",1));


        //2. 存储到request域中
        request.setAttribute("brands",brands);
        request.setAttribute("status",1);

        //3. 转发到 el-demo.jsp
        //request.getRequestDispatcher("/el-demo.jsp").forward(request,response);
        //request.getRequestDispatcher("/jstl-if.jsp").forward(request,response);
        request.getRequestDispatcher("/jstl-foreach.jsp").forward(request,response);
    }
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request, response);
    }
}

• jstl-if.js引入标签：<%@ taglib prefix=“c” uri=“http://java.sun.com/jsp/jstl/core” %>

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

<html>
<head>
    <title>Title</title>
</head>
<body>

    <%--
        c:if：来完成逻辑判断，替换java  if else
    --%>
<%--

    <c:if test="true">
        <h1> true</h1>
    </c:if>

    <c:if test="false">
        <h1> false</h1>
    </c:if>
--%>
    <c:if test="${status ==1}">
        启用
    </c:if>

    <c:if test="${status ==0}">
        禁用
    </c:if>

</body>
</html>

• jstl-foreach.jsp

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

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<input type="button" value="新增"><br>
<hr>
<table border="1" cellspacing="0" width="800">
    <tr>
        <th>序号</th>
        <th>品牌名称</th>
        <th>企业名称</th>
        <th>排序</th>
        <th>品牌介绍</th>
        <th>状态</th>
        <th>操作</th>

    </tr>


    <c:forEach items="${brands}" var="brand" varStatus="status">
        <tr align="center">
            <%--<td>${brand.id}</td>--%>
            <td>${status.count}</td>
            <td>${brand.brandName}</td>
            <td>${brand.companyName}</td>
            <td>${brand.ordered}</td>
            <td>${brand.description}</td>
            <c:if test="${brand.status == 1}">
                <td>启用</td>
            </c:if>
            <c:if test="${brand.status != 1}">
                <td>禁用</td>
            </c:if>

            <td><a href="#">修改</a> <a href="#">删除</a></td>
        </tr>

    </c:forEach>

</table>

<hr>

<c:forEach begin="1" end="10" step="1" var="i">
    <a href="#">${i}</a>
</c:forEach>


</body>
</html>

mvc模式和三层架构

• mvc是一种分层开发模式，一种架构模式，一种概念

  • M：model，业务层
  • V：view，视图层
  • C：Controller 控制器，处理请求

  ​

• 三层架构：软件设计架构，可以落地实现，三大框架就是对这三层做的封装

  • 表现层：controller
  • 业务逻辑层: service
  • 数据访问层：dao

会话跟踪技术

• 架构

  • CS架构，也叫做Client-Server模式，client指的是客户端比如：手机、平板、电脑、手表、电视等，常指桌面应用

    • 硬件：基于局域网(10公里范围内)建立，硬件要求高
    • 安全性：用户群体固定(需要登录)，比较安全
    • 客户端要求大：客户端和服务器都需要进行数据，客户端要求配置较高
    • 维护成本高：每次升级，服务器、客户需要升级

    ​

  • BS架构，也叫做Browser-Servfer模式，browser指的是浏览器

    • 硬件：基于广域网搭建(几十公里到几千公里)，硬件要求低
    • 安全性：任何人都可以通过浏览器访问，安全性低
    • 客户端要求小：逻辑业务交给服务器做，客户端(浏览器)负责显示页面
    • 维护成本高：每次升级，服务器升级就可以了

    ​

• 会话：用户打开浏览器，访问web服务器的资源，会话建立，直到有一方断开连接，会话结束。在依次会话中包含多次连接和请求

• BS架构基于HTTP协议，而http协议是一个无状态的协议(协议没有记忆能力)，就是说服务器不知道请求是否来自同一浏览器的，会话跟踪技术就是指session、cookie分别是服务器、browse的一块存储空间，用它们来记录浏览器的的状态，以便在同一次会话的多次请求间共享数据

Cookie

• 客户端的会话技术，将数据保存在客户端，以后每次请求携带cookie数据进行访问
• cookie是基于http协议实现的
  • 响应：set-cooke，服务器设置cookie指发送给浏览器
  • 请求头：cookie， 会把cookie的数据放在请求头发送给服务器
• cookie设置编码和过期时间
  • setMaxAge(int seconds)：设置cookie存活时间
    • 整数：将cooke写到电脑硬盘，持久化存储，到时间自动删除
    • 负数：默认值，Cookie在当前浏览器内存中，浏览器关闭，cookie销毁
    • 0：删除对应的cookie

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //发送Cookie

        //1. 创建Cookie对象
        String value = "张三";
        //URL编码
        value = URLEncoder.encode(value, "UTF-8");
        System.out.println("存储数据："+value);

        Cookie cookie = new Cookie("username",value);

        //设置存活时间   ，1周 7天
        cookie.setMaxAge(60*60*24*7);

        //2. 发送Cookie，response
        response.addCookie(cookie);
    }

Session

• 服务端的跟踪会话技术：将数据存储到服务器

• HttpSession接口：实现一次会话多次请求间数据共享的功能

• 使用

  • HttpSession session = request.getSession();
  • void SetAttribute(String name, Object o)：存储数据到session中
  • Object getAttribute(String name)：根据key，获取值
  • void removeAttribute(Stirng name)：根据key，删除该键值对

• Session是基于cookie实现的，一次会话多次请求的session对象是同一个

  • 当服务器第一次获取session时，会生成一个唯一标识JESSIONID，以cookie响应头的方式发送给浏览器客户端，客户端浏览器用cookie存储JESSIONID
  • 客户端再次向浏览器发请求时，cookie请求头会携带JESSIONID，从而实现一次会话多次请求共享数据

• session钝化、活化

  • 保证服务器重启session依然存在
  • 钝化：服务器关闭后，将session存在硬盘中，文件名是sessions.ser
  • 活化：服务器启动后，会将sessions.ser文件中的数据加载到session中

• session销毁

  • 默认情况下，无操作，30分钟自动销毁

      <session-config>
          <session-timeout>30</session-timeout>
      </session-config>
  

  • 调用session对象的 invalidate() 方法，一般登出时会销毁session对象

Cookie和Session的区别

• 存储位置：cookie存储在客户端、session将数据存储在服务端
• 安全性：cookie安全、session不安全
• 数据大小：cooke最大3kb、session无限制大小
• 存储时间：cookie可以长期存储，session默认30分支
• 服务器性能：cookie不占服务器资源，session占用服务器资源

Filter执行流程

• Filter分为放行前和放行后
  • chain.doFilter(request,response); 之前的代码是放行前的操作，主要对request处理
  • chain.doFilter(request,response); 之后的代码是放行后的操作，主要对response处理

过滤器链

• 一个web应用，可以配置多个过滤器，这多个过滤器称为过滤器链
  • 这个体现在@WebFilter(“/*”)，如果通配符会导致执行多个过滤器
  • 过滤器的执行顺序默认按照字符串比较的自然顺序，也可以配置过滤器的优先级@
    • 在.xml中过滤器的顺序按照配置的顺序执行
    • 注解的话参考：https://www.cnblogs.com/yihuihui/p/11715416.html
• 常用于过滤登录(如果没登陆，就直接跳转到登录页面)和静态资源

Listener

参考： https://www.jianshu.com/p/ec0a382c3d2c

监听器可以监听就是在application、session、request三个对象、销毁或者往其中添加修改删除属性时自动执行的代码，三大器的执行顺序是监听器、过滤器、servlet(小服务程序)

• 监听对象的创建和销毁

ServletRequestListener：可以在请求时获得通知

HttpSessionListener：可以用来收集在线者信息，或者更改会话列表时获得通知

ServletContextListener：可以获取web.xml里面的参数配置

• 监听对象属性变化

ServletContextAttributeListener

HttpSessionAttributeListener

ServletRequestAttributeListener

• 监听Session对象

HttpSessionBindingListener

HttpSessionActivationListener