Servlet和postman的使用

已于 2023-05-13 17:23:38 修改
阅读量4.3k 收藏 8
点赞数 5
分类专栏： 网络编程 文章标签： servlet java tomcat
于 2022-08-15 16:43:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yahid/article/details/126331671
版权

目录

Servlet的概念

Servlet主要的工作 

Servlet API 

servlet的运行原理 

HttpServlet

HttpServlet中主要的方法 

 HttpServlet的调用时机

Servlet的使用过程 

HttpServletRequest 

HttpServletRequest的方法

postman的使用 

HttpServletResponse 

HttpServletRequest和HttpServletResponse的区别

HttpServletResponse的方法 

Servlet的概念：服务器上能够响应客户端请求的对象 

Servlet是一组  Tomcat服务器提供给程序员开发网站的API，Servlet是一种实现动态页面的技术，也就是页面会根据时间、用户、输入参数不同发生相应的改变。Servlet技术的核心就是在服务器端创建能够响应用户请求的对象，被创建的对象习惯上被称为一个Servelt。

Servlet主要的工作 

1.初始化：这个过程允许程序员注册一个类到Tomcat中，让这个类和HTTP中的一个特定的请求相关联(特定的请求比如：doGet、doPost、doPut.......) ，这个过程类似于JS中给按钮关联一个点击事件。

2.进入循环(循环的处理多个请求)，这一步又有很多过程：

a).读取http请求，Servlet解析这个请求字符串，然后生成一个HttpServletRequest对象；

b).根据请求对象生成一个HttpServletResponse对象来表示响应，根据请求生成响应，这个过程就是初始化阶段的类里面的代码完成的； 

c).把HttpServletResponse对象转换成HTTP响应，返回给浏览器；

上面的1、a、c这几个步骤是由Tomcat/Servlet完成的；

b过程是由程序员完成的，也就是说程序员只需要根据请求来写响应里面的业务逻辑即可，比如用户在浏览器中输入花，那么我们这边的服务器程序就应该将有关花的信息返回给浏览器 

Servlet API 

整个Servlet中最核心的类HttpServlet、HttpServletRequest、HttpServletResponse

一个Servlet程序的结构是下面这样：

@WebServlet("/路径")//功能是为了把这个类和一个具体的HTTP请求的路径关联起来
public class 类名 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest rep,HttpServletResponse resp) throws ServletException, IOException{
        //要执行的任务
    }
}

这个结构中一定不要忘了也不要写错类上面的注解@WebServlet("/路径")，它的功能是把写的这个类和一个具体的HTTP请求的路径关联起来。 

servlet的运行原理 

 1.用户在浏览器中输入URL，然后浏览器构造一个HTTP请求。

2.这个HTTP请求经过网络协议栈逐层进行封装，然后生成二进制的数据流经过物理层的硬件设备装换成光电信号传输出去。

3.经过在网络上的传播最终到达服务器主机，服务器将二进制数据流层层解析，还原成HTTP请求，然后交给Tomcat中的进程处理。

4.Tomcat通过Socket读取到这个请求，并按照HTTP请求的格式来解析这个请求，并根据请求中的Context Path确定一个webapp，再通过Servlet Path确定一个具体的类，再根据当前请求的方法(GET/POST/...)来决定调用这个类的doGet或者doPost等方法，然后HttpServletRequest中就包含了这个HTTP请求的详细信息。

5.在doGet或者doPos中，写一些我们自己的业务逻辑，然后将这些信息放入到HttpServletResponse中。

6.doGet或者doPos执行完毕后，Tomcat就会自动把HttpServletResponse设置成一个HTTP格式的字符串，通过Socket发送出去。

7.再通过网络传输到达客户端浏览器，浏览器再经过层层解析将响应HTTP中body部分的内容加载到浏览器界面上。

 

Tomcat服务器里面Servlet引擎对请求进行解析，根据Servlet Path找到要访问的Servelt，然后实现了Servelt类(比如做登录功能的类)处理清理里面的业务，将执行的结果通过HttpServletResponse返回给Tomcat。

Servelt引擎访问Servelt的过程

 

如果是第一次请求，Servlet引擎会找到相应的Servlet类/对象，然后Servelt类/对象就会创建Servlet实例并调用init()方法进行初始化设置，然后调用service方法处理浏览器请求，最终将业务结果返回给Servlet引擎，最终返回给Tomcat服务器。

如果是第二次请求，Servlet引擎会找到相应的Servlet类/对象，然后直接调用service()方法处理业务，最终将结果返回给Tomcat。这中间就没有进行Servlet实例化和初始化。

Servelt引擎判断是否是第一次请求主要是靠Servlet里面的service方法：

 

Servlet请求在调用Servlet里面的service方法之前，会先创建request对象和空的response对象，然后service方法读取request请求，将处理的结果放在响应response里面。下一次请求的时候，service方法再次读取请求的时候，请求里面多少就会带上上一次响应的东西，根据这个信息的有无判断是否是第一次请求。

HttpServlet

我们写Servlet代码的时候，首先第一步就是创建类，让这个类去继承HttpServlet，并重写HttpServlet里面的相关方法。

重写的目的主要是为了将业务逻辑插入到Tomcat框架中，让Tomcat能够进行调用。

HttpServlet中主要的方法 

doGet                 功能：处理客户的GET请求(当客户使用GET方式请求Servlet时，Web容器调用doGet方法处理请求)        调用时机：收到GET请求时
doPost                功能：处理客户的POST请求        调用时机：收到POST请求时
doPut/doDelete/...

 HttpServlet的调用时机(生命周期)

 调用时机就是方法被调用的时间，它也被称为Servlet的生命周期 

Servlet的生命周期：Servlet在实例化时调用一次，然后Servlet每次收到请求时会被调用一次，Servlet在销毁时会被调用一次。

 

Servlet的使用过程 

1.创建一个maven项目。

2.引入依赖。

3.创建目录结构  webapp/WEB-INF/web.xml。

4.编写代码。

1).创建一个类，继承自HttpServlet。

2).给类上面加上一个注解@WebServlet("/...")，把这个类和一个具体的HTTP请求的路径关联起来。

3).重写HttpServlet中的方法(doGet/doPost)。

4). 在方法里面根据计算响应。

5.打包，使用maven，其中pom.xml要修改打包的类型为war包，然后可以指定一下包的名字。

6.部署，将war包拷贝到Tomcat的webapps目录中，Tomcat就会自动对这个war包进行解压缩，得到一个同名目录。

7.输入URL进行验证。

下面演示一下Servlet如果使用(如果你的IDEA是社区版的话就不能创建maven文件了，所以去网上买一个专业版吧)：

1.创建一个maven项目

2.引入依赖，这个需要一个Servlet的API，然后可以去中央仓库去下载(https://mvnrepository.com/)：

在里面搜索servlet，然后下载第一个

3.创建目录结构  webapp/WEB-INF/web.xml。

向web.xml中添加这样一段代码，这段代码主要是web-app开发所需要的相当于工具类的东西 

<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
  <display-name>Archetype Created Web Application</display-name>
</web-app>

4.编写代码

5.打包，使用maven，其中pom.xml要修改打包的类型为war包，然后可以指定一下包的名字

按着步骤来打包，如果你的第5步没有成功，可能是你的pom.xml文件的依赖没有引入成功。关于maven工具的使用，可以看我前面的博客。

上面虽然包已经打出来了，但这个包是一个jar包，并不是我们想要的，我们想要的是一个war包。

jar包和war包的区别

jar包是普通的java程序打包的结果，里面包含一些.class文件。war包是java web的程序，里面除了会包含.class文件之外，还会包含HTML，CSS，JavaScript，图片，以及其他的jar包，打成war包格式才能被Tomcat识别。

为了打war包，需要在pom.xml中新增一个packing标签，表示打包的方式是一个war包

<packaging>war</packaging>

然后为了修改war包的名字，则需要在pom.xml中新增一个build标签，内置一个finalName标签，表示war包的名字是HelloServlet

<build>
    <finalName>HelloServlet</finalName>
</build>

 

6.部署，将war包拷贝到Tomcat的webapps目录中，Tomcat就会自动对这个war包进行解压缩，得到一个同名目录

7.输入URL进行验证

在进行验证前不要忘了运行Tomcat

上面这种使用Servlet的方法非常不方便，如果我们更改方法里面的内容，就要重新打包，然后将war包拷贝到webapps目录下面，所有的前提还要让Tomcat处于运行状态。因此在实际开发中一般不会用这种方法，下面介绍另一种方法，不用打包和手动启动Tomcat。

在IDEA的设置中，插件目录下面下载一个Smart Tomcat，安装以后重启IDEA。然后点击Add Configurations

然后点击运行

然后在浏览器中输入URL，注意这回的URL的路径：

演示Servlet处理GET和POST请求

在webapp目录下面准备一个testMethod.html文件在里面写相关的事件。然后在创建一个新的类MethodServlet，并在里面重写doGet和doPost方法

下面是testMethod.html文件：

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>

</head>
<body>
    <script src="http://code.jquery.com/jquery-2.2.1.min.js"></script>
    <button onclick="sendGet()">发送Get请求</button>
    <button onclick="sendPost()">发送Post请求</button>
    <script>
        function sendGet(){
            $.ajax({
                type:'GET',
                url:'method',
                success:function (data,status){
                    console.log(data);
                    console.log(status);
                }
            });
        }
        function sendPost() {
            $.ajax({
                type: 'POST',
                url: 'method',
                body:'request body',
                success:function (deta,status){
                    console.log(deta);
                    console.log(status);
                }
            });
        }
    </script>
</body>
</html>

上面url中的路径写的是相对路径，它的基准目录是http://127.0.0.1:8080/Test/，若要写成绝对路径的话可以写成这样——http://127.0.0.1:8080/Test/testMethod.html 

 下面是testMethod.java文件：

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("/method")
public class testMethod extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html,charset=utf-8");
        resp.getWriter().write("hello");
    }


    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html,charset=utf-8");
        resp.getWriter().write("goodbey");
    }
}

代码里面指定编码格式一定要在 

运行结果：

HttpServletRequest 

当Tomcat通过Socket API读取HTTP请求(字符串)，并且按照HTTP协议的格式把字符串解析成HttpServletRequest，HtttServletRequest这个类就表示HTTP请求，理解这个类就是在理解HTTP协议的格式。

HttpServletRequest的方法

HttpServletRequest的方法很多，这里就不依依列举，只讨论几个重要的方法：

http:127.0.0.1:8080/Test/method?a=10&b=20&c=30
Host: 127.0.0.1:8080
user-Agent: xxxx
Referer: http://127.0.0.1:8080/login
Enumeration getParameterNames()                    功能：得到所有的a、b、c...
String getParameter(String name)                   功能：根据a、b、c得到它们对应的值
String[] getParameterValues(String name)           功能：将a、b、c对应的值放入一个String类型的数组，数组里面允许有相同的值

Enumeration getHeaderNames()                       功能：得到header中的所有键值对
String getHeader(String name)                      功能：根据header里面的键和到它们对应的值
InputStream getInputStream()                       功能：获取InputStream对象里面的body

通过几个案例来演示它们的使用：

创建ShowRequest类

@WebServlet("/show")
public class ShowRequest extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //给响应的HTTP协议设置字符编码
        resp.setContentType("text/html,charset=utf-8");
        //创建一个容器来存放HTTP中的内容
        StringBuilder respBody = new StringBuilder();
        //得到请求协议的名称和版本号
        respBody.append(req.getProtocol()+"<br>");
        //得到请求协议中的方法名
        respBody.append(req.getMethod()+"<br>");
        //得到请求协议中的url
        respBody.append(req.getRequestURL()+"<br>");
        //得到请求协议中url中从端口号后面直到后面
        respBody.append(req.getRequestURI()+"<br>");
        //得到请求协议的ContextPath————文件路径
        respBody.append(req.getContextPath()+"<br>");
        //得到请求协议的查询字符串
        respBody.append(req.getQueryString()+"<br>");
        //得到请求协议的正文部分
        respBody.append("<h3>header:</h3>");
        Enumeration<String> headerNames = req.getHeaderNames();
        while(headerNames.hasMoreElements()){
            String headerName = headerNames.nextElement();
            respBody.append(headerName+": ");
            respBody.append(req.getHeader(headerName)+"<br>");
        }
        //将字符串结果按照HTTP协议格式写到reponse中
        resp.getWriter().write(respBody.toString());
    }
}

此处补充一个知识点：

GET请求中参数一般都是通过query string传递给服务器的，而POST请求中参数一般通过body传递给服务器，它们都可以通过getParameter来获取参数的值。 

这里写一个通过ajax来构造一个body为json格式的数据：

创建PostParameterjson类和testPostjson文件

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
<button onclick="sendJson()">发送Json格式的Post</button>
    <script src="http://code.jquery.com/jquery-2.1.1.min.js"></script>

    <script>
        function sendJson(){
            let body = {
                classId:1,
                userId:100
            };
            $.ajax({
                url: 'post',
                method: 'POST',
                contentType:'application/json;charset=utf-8',
                data: JSON.stringify(body),
                success: function (body, status) {
                    console.log(body);
                }
            });
        }
    </script>
</body>
</html>
@WebServlet("/json")
public class PostParameterJson extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String body = readBody(req);
        resp.getWriter().write(body);
    }
    private String readBody(HttpServletRequest req) throws IOException {
        int contentLength = req.getContentLength();
        byte[] buffer = new byte[contentLength];
        InputStream inputStream = req.getInputStream();
        inputStream.read(buffer);
        return new String(buffer,"utf-8");
    }
}

但是上面只是在控制台中输出了，若想要获取到userId和classId的具体的值，还需要搭配JSON库进一步解析。

换一种方法来获取POST请求中的参数：

引入Jackson这个库，进行JSON解析，去中央仓库搜索Jackson，选择JackSon Databind，然后将依赖添加到pom.xml中，像下面这样：

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.12.3</version>
</dependency>

总的pom.xml代码

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

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

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
            <!--provided标签表示，当前jar包里只是在开发阶段使用，而不需要打包到最终的发布包中
            Tomcat里面内置了Servlet，把程序部署到Tomcat上的时候，已经就有Servlet了
            就不需要把你自己的代码里面把Servelet也打包一份放到Tomcat上-->
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.12.3</version>
        </dependency>
    </dependencies>

    <packaging>war</packaging>
    <build>
        <finalName>ServletHelloWorld</finalName>
    </build>
</project>

PostParameterjson类：

class JsonData {
    public String userId;
    public String classId;
}
@WebServlet("/json")
public class PostParameterJson extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String body = readBody(req);
        //创建ObjectMapper对象，这个是Jackson中的核心类，
        ObjectMapper objectMapper = new ObjectMapper();
        //通过readvalue方法把body这个字符串转成JsonData对象
        JsonData jsonData = objectMapper.readValue(body,JsonData.class);
        resp.getWriter().write("userId: "+jsonData.userId+","+"classId: "+jsonData.classId);

    }
    private String readBody(HttpServletRequest req) throws IOException {
        int contentLength = req.getContentLength();
        byte[] buffer = new byte[contentLength];
        InputStream inputStream = req.getInputStream();
        inputStream.read(buffer);
        return new String(buffer,"utf-8");
    }
}

上面代码中最重要的两段就是：

        ObjectMapper objectMapper = new ObjectMapper();
        //通过readvalue方法把body这个字符串转成JsonData对象
        JsonData jsonData = objectMapper.readValue(body,JsonData.class);

 上面这两段代码完成了Json格式的字符串到java对象的解析过程，body就是Json格式的字符串；JsonData.class是一个类对象，他主要完成以下工作：

1.先把Json格式的字符串转换成类似于HashMap的键值对结构：

"userId" => 100、"classId" => 1

2.根据类对象获取到要转换结果的类都有那些属性，每个属性的名字是什么，这个例子中就通过反射机制获取到JsonData这个类对象里面有两个属性，名字分别是userId和classId。关于反射可以去看我的另一篇博客 反射机制和类加载机制_咸鱼吐泡泡的博客-CSDN博客_反射和类加载

3.拿着JsonData这里的每个属性的名字，去第一步构造出来的哈希表里面拿去对应的值，如果查找到了，就把查询的值赋值到JsonData对应的属性里面。这里要求创建JsonData类的时候，就需要这里的成员的名字得和Json字符串里的key是匹配的

最终结果：

postman的使用 

在上面几个案例中，构造HTTP请求都是通过自己写一个页面html，使用form或者ajax来构造请求。这种构造请求的方式比较麻烦，如果服务器这边每次写了一个新的API，提供了一个新的接口，我们不可能每次都写一个html来测试。更简单的方法是我们可以使用专门的第三方工具来构造请求，postman就是其中一个。

去浏览器搜索postman，然后下载安装并注册登录：

创建请求： 

post还可以根据body生成对应的代码：

利用postman可以创建各种格式的请求，可以很方便的帮助我们测试接口。

HttpServletResponse 

Servlet中的doXXX方法的目的就是根据请求计算得到响应，然后把响应的数据设置到HttpServletResponse对象中，然后Tomcat就会把这个HttpServletResponse对象按照HTTP协议的格式，转成一个字符串，并通过Socket写回给浏览器。

HttpServletRequest和HttpServletResponse的区别

HttpServletRequest里面的内容，是客户端构造的，服务器需要做的是获取到这里面的内容，因此它的方法否是get开头的；

HttpServletRsponse里面的内容，是服务器构造的，要返回给客户端，所以它的方法都是以set开头。

HttpServletResponse的方法 

它的方法有很多，这里只讲最常用的：

void setContentType(String type)                        功能：设置发送到客户端响应内容的类型
void setCharacterEncoding(String charset)               功能：设置发送到客户端响应内容里面的字符编码，例如：utf-8
void sendRedirect(String location)                      功能：使用指定的URL发送临时响应到客户端
PrintWriter getWriter()                                 功能：用于往body中写入文本格式数据
OutputStream getOutputStream()                          功能：用于往body中写入二进制数据格式

演示几个案列：

设置状态码：

@WebServlet("/status")
public class StatusServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String status = req.getParameter("status");
        if(status!=null){
            resp.setStatus(Integer.parseInt(status));
        }
        resp.getWriter().write("status: "+status);
    }
}

 

当什么都不输入是，状态码为空

当输入状态码为200时，可以看到响应里面的状态码也是200 

Servlet中的上传文件 

Servlet也支持上传文件的功能。

在日常开发中通常是利用前后端交互的方式来上传文件，前端代码中有一个input标签里面的type类型，当类型为file是表示一个文件类型，每个文件就是一个Part ：

<input type="file" name="MyImage">
<input type="submit" value="提交图片">

后端则是通过Part类里面的方法，利用每个文件都有自己的name，服务器就可以根据这个name找到对应的Part，然后进行上传操作。

在写前端代码的时候要注意：上传文件一般都是通过POST请求的表单来实现的，而且在form中要加上nectype="multipart/form-data"字段。

上传文件的核心方法

HttpServletRequest类里面的上传文件的方法：

Part getPart(String name)                功能：获取请求中给定的name文件
collection<Part> getParts()              功能：获取所有的文件

Part类里面的方法：

String getSubmittedFileName()                        功能：获取提交的文件名
String getContentType()                              功能：获取提交文件的类型
long getSize()                                       功能：获取文件的大小
void write(String path)                              功能：把提交的文件写入磁盘文件

下面演示如何通过网页提交一个图片到服务器上：

准备一张图片到webapp目录下面： 

在webapp目录下面创建一个Uplode.html文件：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <form action="upload" enctype="multipart/form-data" method="post">
        <input type="file" name="2">
        <input type="submit" value="提交图片">
    </form>
</body>
</html>

然后在JAVA目录下面创建一个UploadServlet文件：

@MultipartConfig
@WebServlet("/upload")
public class UploadServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //获取到请求中指定的图片
        Part part = req.getPart("2");
        
        //获取文件的属性
        System.out.println(part.getSubmittedFileName());
        System.out.println(part.getContentType());
        System.out.println(part.getSize());
        
        //将文件保存到本地
        part.write("e:/2.png");
        
        //向服务器上传一张图片
        resp.getWriter().write("upload ok");
    }
}

启动服务器，在浏览器中输入URL： 

 上面的一定要给UploadServlet类上面加上一个@MultipartConfig注解，否者服务器代码无法使用getPart方法；

getPart的参数需要和form中input标签的name属性对应；

总结Servlet  

Servelt是Web服务器(比如Tomcat)里面的一个个解决用户请求的对象，在Servelt和Web服务器之间还有一层Servlet引擎，通过它来管理Servlet。Servlet里面的service方法是沟通Servlet引擎的桥梁，通过request对象和response对象来处理完成业务逻辑。Servlet的生命周期实例化——初始化——service——destroy。

  

咸鱼吐泡泡
关注
专栏目录
Java开发学习----使用PostMan完成不同类型参数传递
m0_73257876的博客
08-18 3287
请求路径设置好后，只要确保页面发送请求地址和后台Controller类中配置的路径一致，就可以接收到前端的请求，接收到请求后，如何接收页面传递的参数?关于请求参数的传递与接收是和请求方式有关系的，目前比较常见的两种请求方式为：GETPOST针对于不同的请求前端如何发送，后端如何接收?1.1 环境准备创建一个Web的Maven项目pom.xml添加Spring依赖​​​​​创建对应的配置类​}}}}...
使用Tomcat搭建一个Servlet项目
weixin_46429649的博客
08-25 2431
Tomcat maven 使用 创建maven项目 管理依赖 实践 使用总结 GET,POST请求应用场景 Servlet运行原理 Tomcat伪代码 Tomcat初始化 Tomcat处理请求 Servlet的关键API HTTPServlet HttpServletRequest和HttpServletResponse 例子1： 例子2： body格式 请求body格式 响应body格式 Cookie和Session HttpServletRequest类中的相关方法 HttpServletRespons
使用Postman模拟Request Payload发送post请求
热门推荐
道阻且长，行则将至
12-05 4万+
Postman模拟Request Payload发送请求，如下图所示：
使用postman发送HttpServletRequest请求
happy_star123的博客
03-28 1万+
使用postman发送HttpServletRequest请求
请求中多次调用getInputStream解决方案
最新发布
qq_44541402的博客
10-11 310
在处理HTTP请求时，HttpServletRequest 对象的 getInputStream 方法只能被调用一次。这是因为请求的输入流（InputStream）是一个一次性资源，一旦被读取，就不能再次读取。因此，如果你在同一个请求中多次调用 getInputStream，后续的调用将会返回一个空的输入流或者抛出异常。
httpservlet_response
12-31
本文件为博客https://blog.csdn.net/aiming66/article/details/85410558的匹配代码文件。
Postman 调用 webservice
daocaoren92wq的博客
05-10 1292
webservice地址： http://www.webxml.com.cn/WebServices/WeatherWebService.asmx?wsdl 请求方式： POST header: Content-Type:text/xml;charset=utf-8 body: <?xml version="1.0" encoding="utf-8"?> ...
用idea写一个servlet，并用postman使用post方法传输json数据
summersadness的博客
02-15 1064
一、首先创建一个servlet项目 1.注意tommat是否安装 2.web文件夹下是否有web.xml文件（如果没有，解决方法：File->Project Structur->Modules，在Deployment Descriptor 下点击＋号添加web,xml文件，注意文件路径，一定要在/web/WEB-INF目录下） ...
postman调用servlet返回中文乱码
u014064071的专栏
10-17 895
j2ee.jar 和 servlet-api.jar 都存在处理servlet的包 response.setContentType("application/json;GBK"); response.setCharacterEncoding("GBK"); request.setCharacterEncoding("UTF-8"); 直接把j2ee.jar...
Servlet实现的论坛系统（纯后台） 所有接口经过PostMan测试.zip
07-24
java web开发，jsp，servlet框架，mysql，适合个人研究学习，用于毕业设计，课程设计等 java web开发，jsp，servlet框架，mysql，适合个人研究学习，用于毕业设计，课程设计等 java web开发，jsp，servlet框架，...
使用servlet的简单服务器demo
03-19
在本文中，我们将深入探讨如何使用Servlet创建一个简单的服务器示例，这个示例包含了GET和POST请求的处理，以及注册和登录功能。Servlet是Java Web开发中的核心组件，用于接收和响应HTTP请求。 首先，我们需要了解...
HttpServletRequest-response方法总结
04-17
如题，HttpServletReques HttpServletResponse很常见的
(HttpServletRequest获得请求参数
12-11
将获取http请求的参数转换成Map集合
Postman插件以及文档
04-19
**二、Postman使用教程** 1. **安装与启动**：首先，从官方网站下载并安装Postman应用程序，启动后即可看到简洁的界面。 2. **新建请求**：点击"+"号创建新请求，输入URL并选择HTTP方法。在Body选项卡中，可选择...
一篇文章带你爆杀JavaWeb-Tomcat、Servlet、HttpServlet、请求方式、Postman的使用！
2301_79104307的博客
05-17 1337
需要重点掌握HttpServlet类的使用方法，清楚GET、POST请求方式的区别，并且熟练使用postman进行测试
Postman的使用
weixin_61321344的博客
09-26 1496
简单参数：在向服务器发起请求时，向服务器传递的是一些普通的请求数据。 在后端程序中，在Controller中，我们要想获取Request对象，可以直接在方法的形参中声明 HttpServletRequest 对象。然后就可以通过该对象来获取请求信息： SpringBoot方式： 在Springboot的环境中，对原始的API进行了封装，接收参数的形式更加简单。 如果是简单参数，参数名与形参变量名相同，定义同名的形参即可接收参数。 postman测试( GET 请求)：postman测试( POST
HttpServletResponse对应postman中的响应
qq_40684045的博客
07-25 1934
response与响应报文
创建Servlet的几种方式+web.xml中关于servlet的一些配置+浏览器、服务器交互Postman测试
qq_39773004的博客
08-28 592
1.继承Servlet接口,重写servlet方法 package d01; import javax.servlet.*; import java.io.IOException; import java.util.Date; /** * zt * 2020/8/28 * 10:53 */ public class MyServlet implements Servlet { /** * 初始化servlet，只执行一次 * @param servletConfig
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

咸鱼吐泡泡

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值