Servle+mvc ,jar包的介绍和导入使用

Bubblesorts

已于 2023-04-17 16:59:10 修改

阅读量1.8k

点赞数 8

文章标签： java

于 2023-04-14 14:08:14 首次发布

本文链接：https://blog.csdn.net/m0_75238194/article/details/130086344

版权

一.servlet

1.概念：server applet

运行在服务器端的小程序。其主要功能在于交互式地浏览和修改数据，生成动态Web内容。狭义的Servlet是指Java语言实现的一个接口，广义的Servlet是指任何实现了这个Servlet接口的类，一般情况下，人们将Servlet理解为后者。Servlet运行于支持Java的应用服务器中。从实现上讲，Servlet可以响应任何类型的请求，但绝大多数情况下Servlet只用来扩展基于HTTP协议的Web服务器。

Servlet就是一个接口，定义了java类被浏览器访问到（tomcat识别）的规则。
将来我们自定义一个类，实现servlet接口，复写方法。

2.创建Web项目

这是我遇到的第二个问题
在这里插入图片描述

新建一个模块

在这里插入图片描述

New Module 命名为javaweb
单击右键选择Add Framework Support…
选择Web Application，点击OK
生成了web.xml,就创建好了web

3.Servlet的实现

（1）创建JavaEE项目

在这里插入图片描述

在src下创建一个包

（2）定义一个类，实现servlet接口

public class ServletDemo01 implements Servlet

在这里插入图片描述

定义一个类
实现servlet接口

（3）实现接口中的抽象方法

在这里插入图片描述

写入方法

（4）配置Servlet

servlet爆红问题
这是遇到的第一个问题
在这里插入图片描述

选择File>Project Structure…
点击Libraries>点击左上角==+==>双击Java

在这里插入图片描述

选择jsp-api.jar和servlet-api.jar
选中你创建的项目
配置servlet

<?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>
        <servlet-name>demo01</servlet-name>
        <servlet-class>cn.itcast.web.servlet.ServletDemo01</servlet-class>
    </servlet>
   
    <servlet-mapping>
        <servlet-name>demo01</servlet-name>
        <url-pattern>/demo01</url-pattern>
    </servlet-mapping>
</web-app>

4.示例代码

package cn.itcast.web.servlet;

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

public class ServletDemo01 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 {

    }

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

    @Override
    public void destroy() {

    }
}

5.执行原理

当服务器接收到客户端浏览器的请求后，会解析请求的URL路径，获取访问的Servlet的资源路径
查找web.xml文件，是否有对应的标签体内容
tomcat会即将字节码文件加载进内存，并且创建其对象
调用其方法

6.Servlet的生命周期

Servlet没有main0方法，不能独立运行，它的运行完全由Servlet 引擎来控制和调度。所谓生命周期，指的是servlet 容器何时创建 servlet 实例、何时调用其方法进行请求的处理、何时并销毀其实例的整个过程。
实例和初始化时机
当请求到达容器时，容器查找该 servlet 对象是否存在，如果不存在，则会创建实例并进行初始化。
就绪/调用/服务阶段
有请求到达容器，容器调用servlet 对象的 service0方法,处理请求的方法在整个生命周期中可以被多次调用；
HttpServlet 的service(方法，会依据请求方式来调用 doGetl或者 doPost0方法。但是，这两个 do 方法默认情况下，会抛出异常，需要子类去 override。
销毀时机
当容器关闭时(应用程序停止时），会将程序中的Servlet 实例进行销毀。

上述的生命周期可以通过 Servlet 中的生命周期方法来观察。在Servlet 中有三个生命周期方法，不由用户手动调用，而是在特定的时机有容器自动调用，观察这三个生命周期方法即可观察到 Servlet 的生命周期。

init方法

 /**
     * 初始化方法
     * 在servlet被创建时执行，只会执行一次
     * @param servletConfig
     * @throws ServletException
     */
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {
        System.out.println("实例创建了");
    }

service方法

  /**
     * 提供服务方法
     * 每一次Servlet被访问时，执行，执行多次
     * @param servletRequest
     * @param servletResponse
     * @throws ServletException
     * @throws IOException
     */
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("服务器调用了");
    }

destroy方法


    /**
     * 销毁方法
     * 在Servlet被杀死时执行（在服务器正常关闭时执行，只执行一次）
     */
    @Override
    public void destroy() {
        System.out.println("实例销毁了");
    }

7.HttpServletRequest 对象

主要作用是用来接收客户端发送过来的请求信息，例如：请求的参数，发送的头信息等都属于客户端发来的信息，service0方法中形参接收的是 HttpServletRequest 接口的实例化对象，表示该对象主要应用在西TP协议上，该对象是由Tomcat封装好传递过来。

HttpServletRequest 是 ServletRequest 的子接口，ServletRequest 只有一个子接口，就是HttpservletRequest。既然只有一个子接口为什么不将两个接口合并为一个？

从长远上讲：现在主要用的协议是 HTTP 协议，但以后可能出现更多新的协议。若以后想要支持这种新协议，只需要直接继承ServletRequest 接口就行了。

在HttpServletRequest 接口中，定义的方法很多，但都是国绕接收客户端参数的。但是怎么拿到该对象呢？
不需要，直接在 Service 方法中由容器传入过来，而我们需要做的就是取出对象中的数据，进行分析、处理。

（1）接受请求

常用方法

BetRequestURL(）	获取客户端发出请求时的完整 URL
getRequestURI()	获取请求行中的资源名称部分（项目名称开始）
getQueryString()	获取请求行中的參数部分
getMethod()	获取客户端请求方式
getProtocol()	获取 HTTP 版本号
getContextPath()	获取 webapp 名字

示例代码

package com.xxxx.servlet;

import jdk.nashorn.internal.objects.AccessorPropertyDescriptor;

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("/s01")
public class Servlet01 extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse response) throws ServletException, IOException {
        super.service(req, response);
        /*常用方法*/
        //获取请求时的完整路径 （从http开始，到“？”前面结束）
        String url = req.getRequestURL() + "";
        System.out.println("获取请求时的完整路径: " + url);
        //获取请求时的部分路径 （从项目的站点名开始，到“？”前面结束）
        String uri = req.getRequestURI();
        System.out.println("获取请求时的部分路径 :" + uri);
        //获取请求时的参数字符串 （从“？”后面开始到最后）
        String qureyString = req.getQueryString();
        System.out.println("获取请求时的参数字符串 " + qureyString);
        //获取请求方式 （GET和POST)
        String method = req.getMethod();
        System.out.println("获取请求方式 :"+ method);
        //获取当前协议版本 （Http/1.1)
        String protocol = req.getProtocol();
        System.out.println("获取当前协议版本" + protocol);
        //获取项目的站点名 （项目对外访问路径）
        String webapp = req.getContextPath();
        System.out.println("获取项目的站点名:" + webapp);
    }
}

在这里插入图片描述

（2）乱码问题

由于现在的request 属于接收客户端的参数，所以必然有其默认的语言编码，主要是由于在解析过程中默认使用的编码方式为 1S0-8859-1（此编码不支持中文)，所以解析时一定会出现乱码。要想解决这种乱码问题，需要设置request 中的编码方式，告诉服务器以何种方式来解析数据。或者在接收到乱码数据以后，再通过相应的编码格式还原。

package com.xxxx.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;

/**
 * 请求乱码问题
 *
 * 由于在解析过程中默认使用的编码方式为 ISO-8859-1（此编码不支持中文），所以解析式一定会出现乱码
 *         Tomcat8以上版本
 *GET请求    不会乱码
 * POST请求    会乱码，通过设置服务器解析编码的格式
 *            req.setCharacterEncoding("UTF-8);
 */
@WebServlet("/s02")
public class Servlet02 extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.service(req, resp);
        //设置请求的编码格式
        req.setCharacterEncoding("UTF-8");
        //获取客户端传输的参数
        String uname = req.getParameter("uname");
        String upad = req.getParameter("upad");

        System.out.println("姓名： " + uname);
        System.out.println("密码： "  + upad);
    }
}

方式一：
new String(request. getParameter (name).getBytes (“ISO-8859-1”), “UTF-8”);
借助了String 对象的方法，该种方式对任何请求有效，是通用的。
Tomcat8起，以后的GET方式请求是不会出现乱码的。
在这里插入图片描述

方式二：
request.setcharacterencoding(“UTF-8”);
这种方式只针对 POST 有效（必须在接收所有的数据之前设定）
在这里插入图片描述

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登录</title>
</head>
<body>
    <form  method="post" action="s02">
        姓名：<input type="text" name="uname"> <br>
        密码：<input type="password" name="upad"> <br>
        <button>登录</button>
    </form>
</body>
</html>

（3）请求跳转

请求转发，是一种服务器的行为，当客户端请求到达后，服务器进行转发，此时会将请求对象进行保存，地址栏中的 URL地址不会改变，得到响应后，服务器端再将响应发送给客户端，从始至终只有一个请求发出。

在这里插入图片描述

示例代码

package com.xxxx.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;

/**
 * 请求转发跳转
 * req.getRequestDispatcher(url).forward(req,resp);
 * 可以让请求从服务端跳转到客户端（或者跳转到指定的Servlet）
 * 服务端行为
 */
@WebServlet("/s03")
public class Servlet03 extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        //接收客户端的参数
        String uname = req.getParameter("uname");
        System.out.println("Servlet03 uname : " + uname);
        //请求转发跳转到Servlet04
       req.getRequestDispatcher("/s04").forward(req,resp);
        //请求转发跳转到jsp页面
//       req.getRequestDispatcher("login.jsp").forward(req,resp);
//'
//        System.out.println(req.getParameter("uname"));
//        req.getRequestDispatcher("/s04").forward(req,resp);
        return;
    }
}

package com.xxxx.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;

/**
 * 请求转发跳转
 * 可以让请求从服务端跳转到客户端（或者跳转到指定的Servlet）
 * 服务端行为
 */
@WebServlet("/s04")
public class Servlet04 extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        //接收客户端的参数
        String uname = req.getParameter("uname");
        System.out.println("Servlet04 uname : " + uname);
//        System.out.println(req.getParameter("uname"));

    }
}

（4）request作用域

通过该对象可以在一个请求中传递数据，作用范围：在一次请求中有效，即服务器跳转有效。

//设置域对象内容
request. setAttribute(String name, String value);

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;
import java.util.ArrayList;
import java.util.List;

/**
 * request作用域，通过该对象可以在一个请求中传递数据，作用范围：在一次请求中有效，即服务器跳转有效。（请求转发跳转时）
 * //设置域对象内容
 * request. setAttribute(String name, String value);
 * //获取域对象内容
 * request.getattribute (String name);
 * //删除域对象内容
 * request. refroveAttribute (String name);
 */
@WebServlet("/s05")
public class Servlet05 extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("Servlet05");
        //设置域对象内容
        req. setAttribute("name","admin");
        req.setAttribute("age",18);
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        req.setAttribute("list",list);

        //请求转发跳转到Servlet06
        req.getRequestDispatcher("s06").forward(req,resp);
        //请求转发跳转到JSP，并通过域对象传递数据
       //req.getRequestDispatcher("index.jsp").forward(req,resp);
    }
}

//获取域对象内容
request.getattribute (String name);

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;
import java.util.ArrayList;
import java.util.List;

/**
 * request作用域，通过该对象可以在一个请求中传递数据，作用范围：在一次请求中有效，即服务器跳转有效。（请求转发跳转时）
 * //设置域对象内容
 * request. setAttribute(String name, String value);
 * //获取域对象内容
 * request.getattribute (String name);
 * //删除域对象内容
 * request. refroveAttribute (String name);
 */
@WebServlet("/s06")
public class Servlet06 extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("Servlet06");
        //获取域对象内容
         String name = (String) req.getAttribute("name");
        System.out.println("name:" + name);
        Integer age = (Integer) req.getAttribute("age");
        System.out.println("age:" + age);
        List<String> list = (List<String>) req.getAttribute("list");
        System.out.println(list.get(0));
    }
}

//删除域对象内容
request. refroveAttribute (String name);

request 域对象中的数据在一次请求中有效，则经过请求转发，request 域中的数据依然存在，则在请求转发的过程中可以通过 request 来传输/共享数据。

在这里插入图片描述

8.HttpServletResponse对象

（1）响应数据

接收到客户端请求后，可以通过 HttpServletResponse 对象直接进行响应，响应时需要获取输出流。
有两种形式：

setWriter(） 获取字符流(只能响应回字符)

getoutputstream(）获取字节流(能响应一切数据）

注意：两者不能同时使用。

//字符输出流
Printwriter writer = response .getwritero;
writer.write("Hello")；
writer.write("ch2>He1lox/h2>")：

//字节输出流
ServletOutputStream out = response.getOutputStream ();
out.write ("Hello" .getBytes ()) ;
out.write ("<h2>Hello</h2>" .getBytes ());

（2）响应乱码问题

在响应中，如果我们响应的内容中含有中文，则有可能出现乱码。这是因为服务器响应的数据也会经过网络传输，服务器端有一种编码方式，在客户端也存在一种编码方式，当两端使用的编码方式不同时则出现乱码。

getWriter()的字符乱码

对于 getWriterQ获取到的字符流，响应中文必定出乱码，由于服务器端在进行编码时默认会使用 1IS0-8859-1
格式的编码，该编码方式并不支持中文。
要解决该种乱码只能在服务器端告知服务器使用一种能够支持中文的编码格式，比如我们通常用的"UTF-8”。

response.setcharacterencoding("UTF-8");

此时还只完成了一半的工作，要保证数据正确显示，还需要指定客户端的解码方式。

response. setHeaderC" content-type"', "text/html ;charset=UTF-8")；

两端指定编码后，乱码就解决了。一句话：保证发送端和接收端的编码一致

//设置服务端的编码
response.setcharacterencoding("UTF-8");
//设置客户端的响应类型及编码
response. setHeader ("content-type" "text/html ;charset=UTF-8");
//得到字符输出流
Printwriter writer = response .getwritero；
writer.write("ch2>你好</h2>"；

以上两端编码的指定也可以使用一句替代，同时指定服务器和客户端

（3）重定向

重定向是一种服务器指导，客户端的行为。客户端发出第一个请求，被服务器接收处理后，服务器会进行响应，在响应的同时，服务器会给客户端一个新的地址（下次请求的地址 response.sendRedirect(urD:)，当客户端接收到响应后，会立刻、马上、自动根据服务器给的新地址发起第二个请求，服务器接收请求并作出响应，重定向完成。

从描述中可以看出重定向当中有两个请求存在，并且属于客户端行为。
// 重定向跳转到index.jsp
response . sendRedirect("index .jsp");

通过观察浏览器我们发现第一次请求获得的响应码为 302，并且含有一个 location 头信息。并且地址栏最终看到的地址是和第一次请求地址不同的，地址栏已经发生了变化。

 Response Headers view parsed
HТТР/1.1 302
Location: index. jsp
Content-Length: 0

在这里插入图片描述

数据不共享
在这里插入图片描述

示例代码

package com.xxxx.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;

/**
 * 重定向
 * 服务端指导  客户端行为
 * 存在两次请求
 *
 * 地址栏会发生改变
 * request数据不共享
 */
@WebServlet("/s07")
public class Servlet07 extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("Servlet07");
        //接收参数
        String uname = req.getParameter("uname");
        System.out.println("Servlet07 uname : " + uname);
        //重定向跳转到s05
        resp.sendRedirect("s08");
    }
}

package com.xxxx.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("/s08")
public class Servlet08 extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("Servlet08");
        String uname = req.getParameter("uname");
        System.out.println("Servlet08 uname : " + uname);
    }
}

9.cookie对象

Cookie是浏览器提供的一种技术，通过服务器的程序能将一些只须保存在客户端，或者在客户端进行处理的数据，放在本地的计算机上，不需要通过网络传输，因而提高网页处理的效率，并旦能够减少服务器的负载，但是由于 Cookie 是服务器端保存在客户端的信息，所以其安全性也是很差的。例如常见的记住密码则可以通过Cookie 来实现。

有一个专门操作Cookie的类 javax.servlet.http.cookie。
随着服务器端的响应发送给客户端，保存在浏览器。当下次再访问服务器时把Cookie再带回服务器。
cookie 的格式：键值对用”=“链接，多个键值对间通过”：“隔开。

（1）cookie的创建的发送

通过 new Cookie('key " value");来创建一个Cookie 对象，要想将 Cookie 随响应发送到客户端，需要先添加到response 对象中，response.addcookie(cookie);此时该 cookie对象则随着响应发送至了客户端。在浏览器上可以看见。

//创建Cookie対象
Cookie cookie = new Cookie("uname", "zhangsan");
//安送Cookie対象
response. addcookie (cookie);

在这里插入图片描述

package com.xxxx.servlet;

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

/**
 * Cookie的创建和发送
 */
@WebServlet("/s07")
public class Servlet07 extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       //Cookie的创建
        Cookie cookie = new Cookie("name","admin");
        //发送Cookie对象
        resp.addCookie(cookie);
    }
}

（2）cookie的获取

在服务器端只提供了一个 getCookies0的方法用来获取客户端回传的所有 cookie 组成的一个数组，如果需要获取单个 cookie 则需要通过遍历，getName(获取 Cookie 的名称，getValue(获取 Cookie 的值。

//获取cookie数组
Cookie [] cookies = request.getCookies ();
//判断数组是否为空
if (cookies != null && cookies. length > 0) {
//遍历cookie数组
for (Cookie cookie : cookies) {
System.out.println(cookie.getName ());
System.out.println(cookie.getvalue));
}

在这里插入图片描述

示例代码

package com.xxxx.servlet;

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

/**
 * Cookie的获取
 * 返回的是cookie数组
 */
@WebServlet("/s07")
public class Servlet07 extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //获取cookie数组
        Cookie[] cookies = req.getCookies();
        //判断cookie是否为空
        if (cookies!=null&&cookies.length>0){
            //遍历cookie数组
            for(Cookie cookie:cookies) {
                //获取cookie的名称和数值
                String name = cookie.getName();
                String value = cookie.getValue();
                System.out.println("名称："+name+", 值："+ value);
            }
        }
    }
}

（3）Cookie设置到期时间

除了 Cookie 的名称和内容外，我们还需要关心一个信息，到期时间，到期时间用来指定该 cookie 何时失效。默认为当前浏览器关闭即失效。我们可以手动设定 cookie 的有效时间(通过到期时间计算），通过setMaxAge(int time)方法设定 cookie 的最大有效时间，以秒为单位。
到期时间的取值
•负整数
若为负数，表示不存储该 cookie。

cookie 的maxAge 属性的默认值就是-1，表示只在浏览器内存中存活，一旦关闭浏览器窗口，那么cookie 就
会消失。
•正整数
若大于。的整数，表示存储的秒数。

表示cookie对象可存活指定的秒数。当生命大于口时，浏览器会把 Cookie 保存到硬盛上，就算关闭刘览器，就算重启容户端电脑，cookie 也会存活相应的时间。
•零
若为 0，表示删除该 cookie。

cookie 生命等于口是一个特殊的值，它表示 cookie 被作废！也就是说，如果原来浏览器已经保存了这个cookie，那么可以通过 Cookie 的setMaxAge(0)来删除这个 Cookie。无论是在浏览器内存中，还是在客户端硬盘上都会删除这个 Cookie。
设置Cookie对象指定时间后失效

// 创建cookie对象
Cookie cookie = new Cookie("uname", "zhangsan");

（4）Cookie的路径

Cookie的setPathQ置cookie的路径，这个路径直接决定服务器的请求是否会从浏览器中加载某些cookie。

情景一：当前服务器下任何项目的任意资源都可获取Cookie对象

/* 当前项目路径为：s01 */
cookie cookie = new cookie("xxx"," xxx");
//设置路径为"/ ，表示在当前服务器下任何项目都可访问到Cookie对象
cookie.setPath("/");
response. addcookie (cookie);

情景二：当前项目下的资源可获取Cookie对象（默认不设置Cookie的path）

/* 当前项目路径为：s01 */cookie cookie = new cookie("xxx"," xxx")；
1/设置路径为"/s01"，表示在当前项目下任何项目都可访问到cookie对象
cookie.setPathC”/s01")；// 默认情况，可不设置path的值
response. addCookie(cookie);

情景三：指定项目下的资源可获取Cookie对象

/* 当前项目路径为：s01 */cookie cookie = new cookie ("xxx"," xxx")；
1/设置路径为"/s02"，表示在s02项目下才可访问到cookie对象
cookie.setPathC"/s02“)；// 只能在$02项目下获取cookie，就算cookie是s01产生的，s01也不能获取它

10.HttpSession对象

HttpSession对象是 javax.servlet.http.HttpSession 的实例，该接口并不像 HttpServletRequest 或HttpServletResponse 还存在一个父接口，该接口只是一个纯粹的接口。这因为 session 本身就属于 HTTP 协议的范畴。
对于服务器而言，每一个连接到它的客户端都是一个 session, servlet 容器使用此接口创建 HTTP 客户端和
HTTP 服务器之间的会话。会话将保留指定的时间段，跨多个连接或来自用户的页面请求。
可以通过此接口查看和操作有关某个会话的信息，比如会话标识符、创建时间和最后一次访问时间。在整个 session 中，最重要的就是厲性的操作。
session 无论客户端还是服务器端都可以感知到，若重新打开一个新的浏览器，则无法取得之前设置的session，因为每一个 session 只保存在当前的刘览器当中，井在相关的页面取得。
Session 的作用就是为了标识一次会话，或者说确认一个用户；并旦在一次会话（一个用户的多次请求）期间
共享数据。我们可以通过 request.getsession0方法，来获取当前会话的session 对象。

二.MVC

1.MVC理解

MVC（Model View Controller）是软件工程中的一种软件架构模式，它把软件系统分为模型、视图和控制器三个基本部分。用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。（不是很理解🙃）

2.MVC开发模式优点：

1.提高Javarieb开发的代码复用性，避免了重复性开发
2.有效括助开发人员实现业务开发中【事务管理】

3.MVC开发角色组成：

C：controller,控制层
M:mode1,业务模型层，完成业务处理
1 .dao层：直接操作数据库
2.service层：调用dao层水完成业务实現，负责管理所调用的
dao层的【事务管理】
V:view 视图层：将处理结果写入到包 JSP
① M o d e l ModelModel（模型）：数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或JavaBean组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据Dao）和服务层（行为Service）。也就是该模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。
② V i e w ViewView（视图）：负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。
③ C o n t r o l l e r ControllerController（控制器）：接收用户请求，委托给模型进行处理（状态改变），处理完毕后把返回的模型数据返回给视图，由视图负责展示。

4.示例代码

编写一个Servlet类，用来处理用户的请求
在这里插入图片描述
编写login.jsp，在WEB-INF目录下新建一个jsp的文件夹，新建logon.jsp

在web.xml中注册Servlet
在这里插入图片描述

三.Jar包

1.jar包的理解

jar包是对写好的类进行了打包。我们可以通过将jar包放到lib目录下来使用这些jar包中的类、属性和方法。

JAR文件是Java Archive File-java档案文件的简称，是与平台无关的文件格式，基于zip文件格式将许多文件合成一个压缩文件.jar，区别是比zip多了一个包含了一个 META-INF/MANIFEST.MF 文件，这个文件是在生成 JAR 文件的时候自动创建的。

2.jar包的作用

JAR 文件不仅用于压缩和发布，而且还用于部署和封装库、组件和插件程序，并可被像编译器和 JVM 这样的工具直接使用。在 JAR 中包含特殊的文件，如 manifests 和部署描述符，用来指示工具如何处理特定的 JAR。
涉及因特网应用时，JAR文件显得特别有用。在JAR文件之前，Web浏览器必须重复多次请求Web服务器，以便下载完构成一个“程序片”（Applet）的所有文件；但在将所有这些文件合并到一个JAR文件里以后，只需向远程服务器发出一次请求即可。除此以外，每个文件都是未经压缩的，由于采用了压缩技术，所以可在更短的时间里获得全部数据。

3.jar包的创建

在这里插入图片描述

4.jar包的使用

在这里插入图片描述

5.jar包的删除

在这里插入图片描述

课后总结

1.不建议手动定义Servlet对象的构造函数，Tomcat服务器使用反射机制创建Servlet对象，如若重写构造函数造成无参构造函数消失，创建对象时会导致服务器内部错误（500错误）需要长久保存的信息，在destroy中重写。
2.GenericServlet
直接编写Servlet，比较复杂，有时候init，destroy方法不一定需要，但是却必须重写，导致大量无用代码生成。

构建一个GenericServlet（通用Servlet）抽象类，其中重写所有Servlet接口的方法，并将service方法设置为abstract

我们需要使用Servlet的时候可以继承GenericServlet，减少重写的代码量，同时必须继承service方法实现用户逻辑
3.ServletConfig
Servlet的配置信息对象

存储了web.xml中的配置信息
一个Servlet对应一个ServletConfig对象
在Servlet的init函数调用时会传入一个ServletConfig对象

public String getInitParameter(String name); // 通过初始化参数的name获取value
public Enumeration<String> getInitParameterNames(); // 获取所有的初始化参数的name
public ServletContext getServletContext(); // 获取ServletContext对象
public String getServletName(); // 获取Servlet的name

4.HTTP协议
HTTP协议：是W3C制定的一种超文本传输协议，包括请求协议于响应协议。
请求协议其包括四部分：
请求行
请求头
空白行
请求体
响应协议也包括四部分：
状态行
响应头
空白行
响应体
5.最终Servlet应用开发方法：

创建一个Servlet应用类继承HttpServlet。
重写doGet或者doPost
将Servlet配置到web.xml文件中或者使用注解配置
编写或者导入相应的前端页面，进行测试
6.请求域相关方法
HttpServletRequest属于请求域，可以通过它对请求域的数据进行操作
请求域只在一次请求范围内有效，相比于应用域，其作用域要小得多
一次请求之后，这个请求域将会销毁
7.WEB-INF的访问权限
WEB-INF中的文件不能被访问，静态资源必须放在其目录之外
8.Session的作用
保存用户状态。
由于HTTP是无状态协议（每次请求是独立的），需要一个机制来识别哪些请求来自同一个用户，例如登录一次后，在浏览器开启状态下继续使用无需重新登陆。
为什么不设计成有状态协议
有可能连接的用户数量非常多，无状态方便节省资源，不需要始终保持一个连接。

Bubblesorts

关注

8
点赞
踩
22

收藏

觉得还不错? 一键收藏
1
评论
Servle+mvc ,jar包的介绍和导入使用

狭义的Servlet是指Java语言实现的一个接口，广义的Servlet是指任何实现了这个Servlet接口的类，一般情况下，人们将Servlet理解为后者。也就是该模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。Cookie是浏览器提供的一种技术，通过服务器的程序能将一些只须保存在客户端，或者在客户端进行处理的数据，放在本地的计算机上，不需要通过网络传输，因而提高网页处理的效率，并旦能够减少服务器的负载，但是由于 Cookie 是服务器端保存在客户端的信息，所以其安全性也是很差的。
复制链接

扫一扫