标签：HttpServletRequest javaweb int resp req 笔记 SC 狂神 void

1、基本概念

1.1 前言

静态web：

提供给所有人看到的数据不会发生变化
HTML，CSS

动态web：

有数据交互，登录账号密码等，网站访问人数等
技术栈：severlet、jsp，asp，php

在java中，动态web资源开发技术统称javaweb；

1.2Web应用程序

web应用程序：可以提供浏览器访问的程序；

统一的web资源会被放在同一个文件夹下

Web 应用程序 —> Tomcat：服务器一个 Web 应用由多部分组成（静态Web、动态Web）

HTML,CSS,JavaScript
JSP,Sevelet
java程序
jar包
配置文件（properties）

编写完毕后，若想提供给外界访问：需要一个服务器来统一管理；

1.3动态Web的访问过程

浏览器发送HTTP请求，服务器Tomcat接受请求，servlet容器从磁盘加载servlet程序处理请求request，处理结束返回response

2、Web服务器

2.1 技术讲解

PHP:

开发速度很快，功能很强大，跨平台
无法承载访问量的情况

Jsp/Servlet：

基于Java语言

Tomcat是Apache 软件基金会的Jakarta 项目中的一个核心项目。

Tomcat 技术先进、性能稳定，而且免费

3、Tomcat

3.1 安装Tomcat

Tomcat官网：http://tomcat.apache.org/

3.2Tomact启动和配置

文件夹

可能遇到的问题

1.Java 环境变量没有配置导致闪退
2.乱码问题：可在配置文件中配置

3.3配置

Servlet核心配置文件目录

可以配置的启动端口号

Tomcat的默认端口号为：8080
mysql：3306
http：80
https：443

<Connector port="8081" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443" />

可以配置主机名称

默认的主机名为：localhost--> 127.0.0.1
默认网站应用存放的位置：webapps

<Host name="www.qinjiang.com"  appBase="webapps"
        unpackWARs="true" autoDeploy="true">

面试题：

在浏览器输入一个域名，回车；
本机查看 C:\Windows\System32\drivers\etc\hosts配置文件是否有相应的域名映射
- 若有，则直接映射到对应的IP地址，进行访问
- 若无，则去DNS服务器上查找对应的IP，找到就返回相应的IP,找不到就不返回

4、HTTP

4.1什么是HTTP

HTTP超文本传输协议

文本：HTML，字符串...
超文本：图片，音乐，视频，定位，地图...
端口号：80端口

HTTPS是以安全为目标的 HTTP 通道，在 HTTP 的基础上通过传输加密和身份认证保证了传输过程的安全性。HTTPS 在HTTP 的基础下加入SSL 层，HTTPS 的安全基础是 SSL。

HTTPS端口号：443

4.2两个时代

HTTP/1.0

HTTP/1.0:客户端与web服务器连接后，只能获得一个wen资源，然后就断开连接，加入某个页面有多个图片资源需要加载，那么需要连接多次，影响服务器和客户端的性能

HTTP/2.0

HTTP/1.1:客户端可以与web服务器连接，获得多个web资源

4.3HTTP请求

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

百度：

Request URL:https://www.baidu.com/     //请求地址
Request Method:GET 						//get方法 /post方法
Request Method:GET 						//状态码，200
Remote（远程） Address:14.215.177.39:443
==============================================
Accept:text/html  
Accept-Encoding:gzip, deflate, br
Accept-Language:zh-CN,zh;q=0.9    语言
Cache-Control:max-age=0
Connection:keep-alive

1.请求行

请求行中的请求方式：GET

请求方式：Get,Post,Head,delete,put,tract...

get:请求能够携带的参数比较少，大小有限制，会在浏览器的URL地址显示数据内容，不安全，但高效
post：请求能够携带的参数没有限制，大小没有限制，不会在浏览器的URL地址显示数据内容安全，但不高效。

2.消息头

Accept:
Accept-Encoding:支持哪种编码格式 GBK UTF-8 GB2312 ISO8859-1
Accept-Language  语言环境
Connection：请求完成是断开还是保持连接
HOST：主机...

4.4HTTP响应

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

百度：

Cache-Control:private   缓存控制
Connection:Keep-Alive 	连接
Content-Encoding:gzip	编码
Content-Type:text/html	类型

响应体

Accept：告诉浏览器，它所支持的数据类型
Accept-Encoding：支持哪种编码格式  GBK   UTF-8   GB2312  ISO8859-1
Accept-Language：告诉浏览器，它的语言环境
Cache-Control：缓存控制
Connection：告诉浏览器，请求完成是断开还是保持连接
HOST：主机..../.
Refresh：告诉客户端，多久刷新一次；
Location：让网页重新定位；

响应状态码

200:请求响应成功200

3xx:请求重定向

重定向：重新定位到新的位置上去

4xx：找不到资源 404

5xx:服务器代码错误 500 502：网关错误

5、Maven

5.1为什么要要学Maven

在Javaweb开发中，需要使用大量的jar包，我们手动去导入
如何能够让一个东西自动帮我导入和配置这个jar包
- 由此Maven诞生

5.2Maven项目架构管理工具

Maven的核心思想：约定大于配置

有约束，不要去违反
Maven会龟定好你该如何去编写我们的java代码，必须要按照做这个规范来；

5.3下载安装Maven和配置Maven环境

下载链接：https://maven.apache.org/

右键 "计算机"，选择 "属性"，之后点击 "高级系统设置"，点击"环境变量"，来设置环境变量，有以下系统变量需要配置：

新建系统变量 MAVEN_HOME，变量值：D:\apache-maven

编辑系统变量 Path，添加变量值

5.4在idea中使用Maven

1.启动idea

2.创建一个Mavenweb项目

在这里插入图片描述

5.5创建一个普通的Maven项目

5.6标记文件夹功能

5.7在IDEA中配置Tomcat

在webapp-maven项目中

解决警告问题
必须要的配置：为什么会有这个问题：我们访问一个网站

5.8pom文件

遇到写的配置文件无法被导出或生效问题

<!--在build中配置resources，来防止我们资源导出失败的问题-->
<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

6、Servlet简介

6.1什么是servlet

Servlet 就是 Sun 公司开发动态 Web 的一门技术

Sun 在这些 API 中提供一个接口叫做：Servlet，如果你想开发一个Servlet程序，只需要完成两个小步骤：

编写一个类，实现Servlet接口
把开发好的java类部署到web服务器中

把实现了Servlet接口的java程序叫做Servlet

6.2 HelloServlet

Serlvet 接口 Sun 公司有两个默认的实现类：HttpServlet，GenericServlet

关于Maven父子工程的理解

父项目中会有：

 <modules>
        <module>servlet-01</module>
 </modules>

子项目中会有：

  <parent>
        <artifactId>javaweb-02-servlet</artifactId>
        <groupId>com.kuang</groupId>
        <version>1.0-SNAPSHOT</version>
   </parent>

6.3Maven环境优化

修改web.xml为最新的
将maven的结构搭建完整

6.4编写Servlet程序

编写一个普通类：

public class Helloservlet extends HttpServlet {
    @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 {
        doPost(req, resp);
    }
}

编写映射：

为什么需要映射：我们写的Java程序，但是要通过浏览器访问，而浏览器需要连接web服务器，所以我们需要在web服务器中注册所写的servlet

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

6.5启动测试！

测试结果：

跳转界面测试：

6.6servlet原理

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

6.7Mapping问题

1 一个servelet可以指定一个映射路径

  <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>/hello</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello2</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello3</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello4</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello5</url-pattern>
    </servlet-mapping>

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>/*</url-pattern>
    </servlet-mapping>

5.指定一些后缀或者前缀等等...

<!--可以自定义后缀实现请求映射
    注意点，*前面不能加项目映射的路径
    hello/sajdlkajda.qinjiang
    -->
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>*.qinjiang</url-pattern>
</servlet-mapping>

6.优先级问题

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

<!--404-->
<servlet>
    <servlet-name>error</servlet-name>
    <servlet-class>com.kuang.servlet.ErrorServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>error</servlet-name>
    <url-pattern>/*</url-pattern>
</servlet-mapping>

7、ServletContext

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

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

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

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.setCharacterEncoding("utf-8");
        resp.setContentType("text/html");
        resp.getWriter().print("姓名:"+username);
    }

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

<servlet>
  <servlet-name>hello</servlet-name>
  <servlet-class>HelloServlet</servlet-class>
</servlet>
  <servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/s1</url-pattern>
  </servlet-mapping>

  <servlet>
    <servlet-name>get</servlet-name>
    <servlet-class>getServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>get</servlet-name>
    <url-pattern>/s2</url-pattern>
  </servlet-mapping>

测试访问结果；

7.2获取初始化参数

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

public class HelloServlet02 extends HelloServlet{
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        String url =context.getInitParameter("url");
    }

7.3请求转发

<servlet>
    <servlet-name>H2</servlet-name>
    <servlet-class>HelloServlet02</servlet-class>
  </servlet>
  <servlet-mapping>
  <servlet-name>H2</servlet-name>
  <url-pattern>/h2</url-pattern>
  </servlet-mapping>


<servlet>
    <servlet-name>H3</servlet-name>
    <servlet-class>HelloServlet03</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>H3</servlet-name>
    <url-pattern>/h3</url-pattern>
  </servlet-mapping>

public class HelloServlet02 extends HelloServlet{
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
      ServletContext context = this.getServletContext();
      String url =context.getInitParameter("url");
      resp.getWriter().print(url);
    }
}

public class HelloServlet03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        resp.setCharacterEncoding("utf-8");
        resp.setContentType("text/html");
        System.out.println("进入了ServletDome03");

        context.getRequestDispatcher("/h2").forward(req,resp);
    }
}

7.4读取资源文件

Properties

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

username=root
password=123456

public class HelloServlet04 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        InputStream is = this.getServletContext().getResourceAsStream("/WEB-INF/classes/abc.properties");


        Properties prop=new Properties();
        prop.load(is);
        String user = prop.getProperty("username");
        String pwd = prop.getProperty("password");
        resp.getWriter().print(user+":"+pwd);
        }

 <servlet>
    <servlet-name>H4</servlet-name>
    <servlet-class>HelloServlet04</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>H4</servlet-name>
    <url-pattern>/h4</url-pattern>
  </servlet-mapping>

8、HttpServletResponse

Web 服务器接收到客户端的 http 请求，针对这个请求，分别创建一个代表请求的 HttpServletRequest 对象，代表响应的一个 HttpServletResponse；

如果想要获取客户端请求过来的参数：找HttpServletRequest
如果要给客户端响应一些信息：找HttpServletResponse

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

    void addIntHeader(String var1, int var2);

响应的状态码

 int SC_CONTINUE = 100;
    int SC_SWITCHING_PROTOCOLS = 101;
    int SC_OK = 200;
    int SC_CREATED = 201;
    int SC_ACCEPTED = 202;
    int SC_NON_AUTHORITATIVE_INFORMATION = 203;
    int SC_NO_CONTENT = 204;
    int SC_RESET_CONTENT = 205;
    int SC_PARTIAL_CONTENT = 206;
    int SC_MULTIPLE_CHOICES = 300;
    int SC_MOVED_PERMANENTLY = 301;
    int SC_MOVED_TEMPORARILY = 302;
    int SC_FOUND = 302;
    int SC_SEE_OTHER = 303;
    int SC_NOT_MODIFIED = 304;
    int SC_USE_PROXY = 305;
    int SC_TEMPORARY_REDIRECT = 307;
    int SC_BAD_REQUEST = 400;
    int SC_UNAUTHORIZED = 401;
    int SC_PAYMENT_REQUIRED = 402;
    int SC_FORBIDDEN = 403;
    int SC_NOT_FOUND = 404;
    int SC_METHOD_NOT_ALLOWED = 405;
    int SC_NOT_ACCEPTABLE = 406;
    int SC_PROXY_AUTHENTICATION_REQUIRED = 407;
    int SC_REQUEST_TIMEOUT = 408;
    int SC_CONFLICT = 409;
    int SC_GONE = 410;
    int SC_LENGTH_REQUIRED = 411;
    int SC_PRECONDITION_FAILED = 412;
    int SC_REQUEST_ENTITY_TOO_LARGE = 413;
    int SC_REQUEST_URI_TOO_LONG = 414;
    int SC_UNSUPPORTED_MEDIA_TYPE = 415;
    int SC_REQUESTED_RANGE_NOT_SATISFIABLE = 416;
    int SC_EXPECTATION_FAILED = 417;
    int SC_INTERNAL_SERVER_ERROR = 500;
    int SC_NOT_IMPLEMENTED = 501;
    int SC_BAD_GATEWAY = 502;
    int SC_SERVICE_UNAVAILABLE = 503;
    int SC_GATEWAY_TIMEOUT = 504;
    int SC_HTTP_VERSION_NOT_SUPPORTED = 505;

8.2下载文件

1.要获取下载文件的路径
2.下载的文件名是什么？
3.设置浏览器使其支持下载的内容
4.获取下载文件的输入流
5.创建缓冲区
6.获取 OutputStream 对象
7.将 FileOutputStream 写入到 buffer缓冲区
8.使用 OutputStream 将缓冲区中的数据输出到客户端

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 // 1.要获取下载文件的路径
     String realPath="D:\\IDEAtest\\javaweb-03\\src\\main\\resources\\1.png";
        System.out.println("下载文件的路径："+realPath);
     //2.下载的文件名是什么？
       String fileName= realPath.substring(realPath.lastIndexOf("\\")+1);

//  3.设置浏览器使其支持下载的内容,中文文件名URLEncoder.encode编码，否则有可能乱码
        resp.setHeader("Content-Disposition","attachment;filename="+ URLEncoder.encode(fileName,"UTF-8"));
//4.获取下载文件的输入流
        FileInputStream in = new FileInputStream(realPath);
//5.创建缓冲区
        int len = 0;
        byte[] buffer = new byte[1024];
//6.获取 OutputStream 对象
        ServletOutputStream out = resp.getOutputStream();
//7.将 FileOutputStream 写入到 buffer缓冲区
        while ((len=in.read(buffer))>0){
            out.write(buffer,0,len);
        }

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

<servlet>
    <servlet-name>file</servlet-name>
    <servlet-class>FileServlet</servlet-class>
</servlet>
    <servlet-mapping>
        <servlet-name>file</servlet-name>
        <url-pattern>/f1</url-pattern>
    </servlet-mapping>

8.3Response验证码

public class IamgeServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //如何让浏览器4秒自动刷新一次
        resp.setHeader("refresh","4");

        //在内存中创建一个图片
        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.cyan);
        g.setFont(new Font(null,Font.BOLD,20));
        g.drawString(makeNum(),0,20);

        //告诉浏览器，这个请求用图片的方式打开
        resp.setContentType("image/jpep");
        //网站在缓存，不让浏览器缓存
        resp.setDateHeader("expires",-1);
        resp.setHeader("Cache-Control","no-cache");
        resp.setHeader("Pragma","no-cache");
        //把图片写给浏览器
        ImageIO.write(image,"jpg",resp.getOutputStream());
    }

    //生成随机数
    private  String makeNum(){
        Random random = new Random();
        String num=random.nextInt(9999999)+"";
        StringBuffer sb=new StringBuffer();
        for (int i = 0; i < 7-num.length(); i++) {
            sb.append("0");
        }
        num=sb.toString()+num;
        return num;
    }

   <servlet>
        <servlet-name>image</servlet-name>
        <servlet-class>IamgeServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>image</servlet-name>
        <url-pattern>/i1</url-pattern>
    </servlet-mapping>

8.4实现重定向

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

常见场景：

用户登录

void sendRedirect(String var1) throws IOException;

public class RedirectServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.sendRedirect("/javaweb_03_war/i1");
    }

  <servlet>
        <servlet-name>RedirectServlet</servlet-name>
        <servlet-class>RedirectServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>RedirectServlet</servlet-name>
        <url-pattern>/r1</url-pattern>
    </servlet-mapping>

面试题：重定向与转发的区别？

相同点：

页面都会实现跳转

不同点

请求转发时URL不会发生变化
重定向时URL会发生变化

8.5简单实现登录重定向

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

<form action="${pageContext.request.contextPath}/r2" method="get">
    用户名：<input type="text" name="username"> <br>
    密码：<input type="password" name="password"> <br>
    <input type="submit">
</form>

 protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        String username=req.getParameter("username");
        String password=req.getParameter("password");
        System.out.println(username+":"+password);

        resp.sendRedirect("/javaweb_03_war/success.jsp");
    }

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

 <servlet>
        <servlet-name>RequestTest</servlet-name>
        <servlet-class>RequestTest</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>RequestTest</servlet-name>
        <url-pattern>/r2</url-pattern>
    </servlet-mapping>

9、HttpServletRequest

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

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[] hobbys = req.getParameterValues("hobbys");
        System.out.println("==================");

        System.out.println(username);
        System.out.println(password);
        System.out.println(Arrays.toString(hobbys));
        System.out.println("==================");

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

index.jsp


<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>登录</h1>
<div>
    <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="唱歌">唱歌
        <br>
        <input type="submit">
    </form>
</div>

</body>
</html>

success.jsp

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

映射文件

    <servlet>
        <servlet-name>LoginServlet</servlet-name>
        <servlet-class>LoginServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>LoginServlet</servlet-name>
        <url-pattern>/login</url-pattern>
    </servlet-mapping>

10、Cookie

cookie

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

session

服务器技术，利用这个技术，可将信息或数据放在session中

从请求中拿到 cookie 信息

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

        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的名字
                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()+"");
        resp.addCookie(cookie);
    }

   <servlet>
        <servlet-name>CookieDemo01</servlet-name>
        <servlet-class>CookieDemo01</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>CookieDemo01</servlet-name>
        <url-pattern>/c1</url-pattern>
    </servlet-mapping>

2.服务器响应给客户端 cookie

Cookie[] cookies = req.getCookies(); //获得Cookie
cookie.getName(); //获得cookie中的key
cookie.getValue(); //获得cookie中的vlaue
new Cookie("lastLoginTime", System.currentTimeMillis()+""); //新建一个cookie
cookie.setMaxAge(24*60*60); //设置cookie的有效期
resp.addCookie(cookie); //响应给客户端一个cookie

11、Session(重点)

1.什么是session

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

SessionServlet01

生成ssion,并且存入信息，这里存入一个对象

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

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

        //给session存东西
        session.setAttribute("name",new Person("杜鹏",1));

        //获取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);
    }
}

SessionServlet02

创建一个对象，并且输出

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

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

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

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

SessionServlet03

得到session值移除，重新生成

public class SessionServlet03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        HttpSession session = req.getSession();
        session.removeAttribute("name");
        session.invalidate();

    }

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

映射和会话过期时间设置

    <servlet>
        <servlet-name>SessionServlt01</servlet-name>
        <servlet-class>SessionServlet01</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>SessionServlt01</servlet-name>
        <url-pattern>/ss1</url-pattern>
    </servlet-mapping>

    <servlet>
        <servlet-name>SessionServlt02</servlet-name>
        <servlet-class>SessionServlet02</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>SessionServlt02</servlet-name>
        <url-pattern>/ss2</url-pattern>
    </servlet-mapping>

    <servlet>
        <servlet-name>SessionServlt03</servlet-name>
        <servlet-class>SessionServlet03</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>SessionServlt03</servlet-name>
        <url-pattern>/ss3</url-pattern>
    </servlet-mapping>


    <!--   会话自动过期   15分钟自动过期 -->
    <session-config>
        <session-timeout>15</session-timeout>
    </session-config>

2.session和cookie的区别

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

使用场景：

保存一个登录用户的信息；
购物车信息；
在整个网站中经常会使用的数据，我们将它保存在 Session 中；

12、JSP

1.什么是JSP

Java Servlet Pages：java服务器端页面，也和servlet一样，用于动态web技术

最大特点：写Jsp就像在写html
区别：
- HTML只给用户提供静态的数据
- Jsp页面中可以嵌套java代码，为用户提供动态数据

2.JSP原理

服务器内部工作

Tomcat 中有一个 work 工作目录；
IDEA 中使用 Tomcat 的会在 IDEA 中 Tomcat 中生产一个 work 目录

发现页面转变成java程序

JSP最终也会转换成一个java类
JSP 本质上就是一个 Servlet

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

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

输出页面钱增加的代码

response.setContentType("text/html");       //设置响应的页面类型
pageContext = _jspxFactory.getPageContext(this, request, response,
                                          null, true, 8192, true);
_jspx_page_context = pageContext;
application = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
_jspx_out = out;

以上这些对象可直接在JSP中使用

3.JSP基础语法

JSP表达式

 <%= 变量或者表达式%>  

<%= new java.util.Date()%>

JSP脚本片段

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

脚本片段再实现

<%--  在HMTL代码嵌入HTML元素--%>
<%
  for (int i = 0; i <5 ; i++) {
%>
  <h1>hello,word <%=i%> </h1>
  <%
  }
  %>

JSP声明

<%-- JSP声明--%>
<%!
  static {
    System.out.println("loading servlet");
  }
  private int globavar=0;
  public void dupeng(){
    System.out.println("进入了方法");
  }
%>

4.JSP指令

定制错误页面

这里配置404页面，500页面同理

错误页面

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

<%--定制错误页面--%>
<%--<%@ page errorPage="error/500.jsp" %>--%>
<html>
<head>
    <title>Title</title>
</head>
<body>
<%
int x=1/0;
%>
</body>
</html>

错误跳转图片页面 404

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<img src="../img/404.jpg" alt="404">
</body>
</html>

也可以在xml中配置错误页面

<error-page>
    <error-code>404</error-code>
    <location>/error/404.jsp</location>
</error-page>

头部页面和尾部页面 common

编写头部页面和尾部页面

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

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

用include导入

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<%@include file="common/header.jsp"%>
<h1>网页主体</h1>
<%@include file="common/footer.jsp"%>
</body>
</html>

5.九大内置对象

PageContext 存东西
Request 存东西
Response
session 存东西
Application（Servletcontext）存东西、
config （servletconfig）
out
page 基本不用
exception

request：客户端向服务器发送请求，产生的数据，用户看完就没用了。比如：新闻

session：客户端向服务器发送请求，产生的数据，用户用完一会还有用，比如：购物车

application：客户端向服务器发送请求，产生的数据，，一个客户用完了，其他用户还可能使用，比如：聊天数据；

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

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

<%--
脚本片段中的代码，会原封不动生成到.JSP.JAVA
要求：这里面的代码，必须保证java语法的正确性
--%>
<%
    //从pageContext取出，我们通过寻找的方式来
    //从底层到高层（作用域）：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");
    String name5 = (String) pageContext.findAttribute("name5");
%>

<%--
使用el表达式输出
<%=%>等价于${}
--%>
<h1>取出的值为：</h1>
<h3>${name1}</h3>
<h3>${name2}</h3>
<h3>${name3}</h3>
<h3>${name4}</h3>
<h3><%=name5%></h3>
    
</body>
</html>

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

<!-- JSTL表达式依赖 -->
<dependency>
    <groupId>javax.servlet.jsp.jstl</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>

<!--standard标签库-->
<dependency>
    <groupId>taglibs</groupId>
    <artifactId>standard</artifactId>
    <version>1.1.2</version>
</dependency>

EL表达式：${}

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

JSP标签

<jsp:forward page="/jsptag2.jsp">
    <jsp:param name="name" value="kuangshen"></jsp:param>
    <jsp:param name="age" value="12"></jsp:param>
</jsp:forward>

JSTL表达式

JSTL标签库的使用就是为了弥补HTML标签的不足；它自定义许多标签,可以供我们使用，标签的功能和java一样

格式化标签

SQL标签

XML 标签

格式化标签

SQL标签

XML 标签(掌握部分)

c:if

<%@ 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>
<h4>if测试</h4>

<hr>
<form action="coreif.jsp" method="post">
    <%--
    EL表达式获取表单中的数据
    ${param.参数名}
    --%>
    <input type="text" name="username" value="${param.username}">
    <input type="submit" value="登录">


</form>


<c:if test="${param.username=='admin'}" var="isadmin">
    <c:out value="管理员欢迎你"/>
</c:if>

<c:out value="${isadmin}"/>

</body>
</html>

c:when

<%--定义一个变量score，值为55--%>
<c:set var="score" value="55"/>
<c:choose>
    <c:when test="${score>=90}">
        你的成绩为优秀
    </c:when>
    <c:when test="${score>=80}">
        你的成绩为良好
    </c:when>
    <c:when test="${score>=70}">
        你的成绩为一般
    </c:when>
    <c:when test="${score<=60}">
        你的成绩为不及格
    </c:when>

13、Javabean

实体类

Javabean有特定的写法：

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

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

ORM：对象关系映射

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

id	name	age	address
1	张三	18	上海
2	李四	23	北京
3	王五	22	西安

<%@ page import="com.dupeng.entity.People" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>


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

<jsp:setProperty name="people" property="id" value="1"/>
<jsp:setProperty name="people" property="name" value="张三"/>
<jsp:setProperty name="people" property="age" value="18"/>
<jsp:setProperty name="people" property="address" value="上海"/>



id：<jsp:getProperty name="people" property="id"/>
姓名：<jsp:getProperty name="people" property="name"/>
年龄：<jsp:getProperty name="people" property="age"/>
地址：<jsp:getProperty name="people" property="address"/>
</body>
</html>

14、MVC三层架构

MVC:Model View Controller 模型、视图、控制器

以前

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

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

架构：没有什么是加一层解决不了的！
程序猿调用
 |
JDBC
 |
Mysql Oracle SqlServer ....

MVC三层架构

Model

业务处理：业务逻辑
数据持久层：CURD

View

展示数据
提供链接发起servlet请求（a,form,img..)

Controller(servlet)

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

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

15、Filter（重点）

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

处理中文乱码
登录验证

Filter开发步骤：

1.导包

2.编写过滤器

编写输出语句

package com.dupeng.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 {
        super.doPost(req, resp);
    }
}

编写过滤器语句

package com.dupeng.filter;

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

public class CharacterEncodingFilter implements Filter {
    @Override
    //初始化：web服务器启动，就已经初始化了，随时等待过滤对象出现
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("ShowFilter初始化");
    }
/*
* 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("ShowFilter执行前....");
        Chain.doFilter(request,response);
        System.out.println("Filter执行后....");
    }

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

映射文件和过滤器映射文件

<?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>Showservlet</servlet-name>
        <servlet-class>com.dupeng.servlet.Showservlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>Showservlet</servlet-name>
        <url-pattern>/show1</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>Showservlet</servlet-name>
        <url-pattern>/servlet/show1</url-pattern>
    </servlet-mapping>

    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>com.dupeng.filter.CharacterEncodingFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/servlet/*</url-pattern>
    </filter-mapping>
</web-app>

16 监听器

实现一个监听器：

编写监听器，实现监听器接口

package com.dupeng.Listener;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

public class OnlineCountListener implements HttpSessionListener {
    @Override
    public void sessionCreated(HttpSessionEvent se) {
        ServletContext ctx = se.getSession().getServletContext();
        System.out.println(se.getSession().getId());
        Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount");

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

        ctx.setAttribute("OnlineCount",onlineCount);

    }

    @Override
    public void sessionDestroyed(HttpSessionEvent se) {
        ServletContext ctx = se.getSession().getServletContext();

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

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

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

web.xml中注册

<listener>
    <listener-class>com.dupeng.Listener.OnlineCountListener</listener-class>
</listener>

jsp页面显示

<%@ page contentType="text/html; charset=gb2312"%>
<html>
<body>
<h2>当前有<span style="color: yellow"> <%=this.getServletConfig().getServletContext().getAttribute("OnlineCount")%>人在线</span></h2>
</body>
</html>

17 JDBC

什么是JDBC：JAVA连接数据库

需要jar包的支持：

java.sql
javax.sql
mysql-conneter-java 连接驱动（必须导入）

CREATE TABLE user(
 id INT (10) PRIMARY KEY,
 `name`  VARCHAR(10),
`password`  VARCHAR(20),
email VARCHAR(60),
birthday DATE
)
INSERT INTO user(id,`name`,`password`,email,birthday) VALUES(1,"张三","123456","[email protected]",'2000-01-01');
INSERT INTO user(id,`name`,`password`,email,birthday) VALUES(2,"李四","123456","[email protected]",'2000-01-01');
INSERT INTO user(id,`name`,`password`,email,birthday) VALUES(3,"王五","123456","[email protected]",'2000-01-01');

导入数据库依赖

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

JDBC固定步骤

1.加载驱动

2.连接数据库，代表数据库

3.向数据库发送SQL的对象statement;CURD

4.编写SQL(根据业务，不同SQL）

5.执行SQL

6.关闭连接（先开的后关）

package com.dupeng.test;

import java.sql.*;

public class TestJdbc {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //配置信息
        //jdbc:mysql://localhost:3306 链接数据库
        // /jdbc选择数据库中名称为jdbc的数据表
        //useUnicode=true&characterEncoding=utf-8" 解决中文乱码问题
        String url="jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8";
        String username="root";
        String password="123456";
        //1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");

        //2.连接数据库，代表数据库
        Connection connection = DriverManager.getConnection(url, username, password);
        //3.编写sql
        Statement statement = connection.createStatement();

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

        //5.执行查询sql，返回 ResultSet ： 结果集
        ResultSet rs = statement.executeQuery(sql);
        while (rs.next()){
            System.out.println("id="+rs.getObject("id"));
            System.out.println("name="+rs.getObject("name"));
            System.out.println("password="+rs.getObject("password"));
            System.out.println("email="+rs.getObject("email"));
            System.out.println("birthday="+rs.getObject("birthday"));
        }
        //6.关闭连接，释放资源 先开后关
        rs.close();
        statement.close();
        connection.close();

    }
}

标签：HttpServletRequest,javaweb,int,resp,req,笔记,SC,狂神,void
From： https://www.cnblogs.com/DuPengBG/p/16844022.html

狂神说javaweb笔记