Lesson10：ServletAPI详解(HttpServlet、HttpServletRequest、HttpServletResponse)

方法名称	调用时机
doGet()	收到get请求的时候调用
doPost()	收到post请求的时候调用
doPut()、doDelete、doOptions	收到其他请求时调用
init	在HttpServlet实例化后调用一次
destroy	在HttpServlet实例不再使用的时候调用
service	收到HTTP请求的时候调用

在实际开发中，主要是重写doXXX方法。init、destroy、service方法很少被重写。

1.2 servlet的生命周期

Servlet对象是由Tomcat来进行实例化的，并且在实例化完毕之后调用init方法。

Tomcat收到的每个请求，都是通过对应Servlet的service方法来处理。

Tomcat在结束之前，会调用servlet的destroy方法来进行回收资源。

注意事项：

init和service能够保证在各自合适的时机被Tomcat调用到，但destroy不一定。destroy能不能被调用到，取决于Tomcat是如何被结束的。

①直接杀死进程，直接强制把进程给关了，此时就来不及调用destroy，就没了。

②通过Tomcat的管理端口进行关闭，默认是8005，这种是可以调用的。

1.3 如何构造请求

①在浏览器里直接通过url发送的请求是一个get请求。

②构造一个post请求：form、ajax、Java(socket api)。这三种方法都是开发的时候使用的，如果想更方便的测试功能，这几种方法就有点麻烦了。可以使用第三方工具来构造HTTP请求，非常知名的工具—Postman。

Postman

下载地址：Postman

二、HttpServletRequest

Tomcat会按照HTTP协议的格式将HTTP请求(字符串)解析成HttpServletRequest对象。

2.1 核心方法

使用HttpServletRequest的方法，能获得HTTP请求里面的一些信息。但是这些方法使用频率不高，因此，就通过一段代码简单的演示一下各种方法的使用方法。

@WebServlet("/try1")
public class try1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.getProtocol(); // 协议名称
        req.getMethod(); // 获取方法
        req.getRequestURL(); // 获取URL
        req.getContextPath();
        req.getQueryString();
        // 获取请求头
        Enumeration<String> headers = req.getHeaderNames();
        while(headers.hasMoreElements()){
            String headerName = headers.nextElement();
            String headerValue = req.getHeader(headerName);
        }
    }
}

2.2 获取请求中传来的参数

2.2.1 获取query String

采用getParameter方法。

2.2.2 获取body

①如果body里的内容格式，是按照x-www-form-urlencoded也是使用 getParameter来进行处理。

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

②如果body里的内容格式,是json ,此时需要借助第三方库来处理。

step1 引入依赖：Jackson这个库在在中央仓库中获取(搜索 Jackson databind)。

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

将这段代码复制到pom.xml里面就可了。

step2 前后端需要约定HTTP的请求格式：

客户端按照这个格式发HTTP请求，服务器按照这个格式解析HTTP请求。

step3 程序逻辑

版本1：

import com.fasterxml.jackson.databind.ObjectMapper;

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.io.InputStream;
import java.util.Enumeration;

@WebServlet("/try1")
public class try1 extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=utf-8");
        // 1.先把整个请求的body都读出来
        String body = readBody(req);
        // 2.再按照json的格式进行解析。(对于json的解析，Java标准库里没有内置的方法，Servlet也没有现成的方法，就需要使用第三方库)
        // 想拿到的是用户名和密码，就需要针对这里的json数据进行解析，变成一个键值对结构或者变成一个对象
        // 创建ObjectMapper对象，这个是Jackson的中心类
        ObjectMapper objectMapper = new ObjectMapper();
        // 通过readValue方法把body这个字符串转为类对象
        // objectMapper遍历UserInfo中的每个成员的名字，去json字符串的key中查找，找到的结果就会赋值给UserInfo对象中
        UsrInfo usrInfo = objectMapper.readValue(body,UsrInfo.class);
        resp.getWriter().write("username:" + usrInfo.username + " password:" + usrInfo.password);
    }
    // 通过这个方法来读取整个请求中的body。
    // 核心操作是req.getInputStream这个方法，通过这个方法可以获得getInputStream对象，然后就可以进一步的读取里面的内容了
    public String readBody(HttpServletRequest req) throws IOException {
        // 1.先拿到body的长度，单位是字节
        int contentLength = req.getContentLength();
        // 2.准备一个字节数组，来存放body的内容
        byte[] buffer = new byte[contentLength];
        // 3.获取到InputStream对象
        InputStream inputStream = req.getInputStream();
        // 4. 读取数据，从InputStream对象中，读到数据，放到buffer这个数组中
        inputStream.read(buffer);
        // 5.将得到的结果构成一个String并返回
        return new String(buffer,"utf-8");
    }
}
// 创建一个类表示JSON数据，属性的名字要和JSON字符串的key一致
class UsrInfo{
    public String username;
    public String password;
}

注意：Jackson库的核心类为ObjectMapper。

readValue方法：把一个JSON字符串转成JAVA对象。readValue的第二个参数为JsonData的类对象，通过这个类对象，在readValue的内部就可以借助反射机制来构造出JsonData对象，并且根据JSON中key的名字，把对应的value赋值给JsonData的对应字段。

writeValueAsString方法：把一个Java对象转成JSON格式字符串。

版本2：

三、HttpServletResponse

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

3.1 核心方法

方法	描述
void setStatus(int a)	为该响应设置状态码
void setHeader(String name.String value)	设置报头，如果name已经存在，就覆盖旧的值
void addHeader(String name,String value)	设置报头，如果name已经存在，不覆盖，并列添加新的键值对
void setContentType(String type)	设置响应的内容类型
void setCharacterEncoding(String charset)	设置相同的字符编码
void sendRedirect(String location)	使用指定的重定向位置URL发送临时重定向响应到客户端
PrintWriter getWriter()	用于向body中写入文本格式数据
OutputStream getOutputStream()	用于向body中写入二进制格式数据

注意：对于状态码/响应头的设置要放到 getWriter / getOutputStream 之前，否则可能设置失效。

3.2 练习

3.2.1 设置状态码

@WebServlet("/status")
public class StatusServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=utf-8");
        int status = 200;
        resp.setStatus(status);
        resp.getWriter().write("status:"+status);
    }
}

3.2.2 设置header头—自动刷新

每隔一秒钟，自动刷新一下页面

@WebServlet("/autoRefresh")
public class AutoRefreshServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=utf-8");
        resp.setHeader("Refresh","1");
        resp.getWriter().write("currentTime:"+ System.currentTimeMillis());
    }
}

3.2.3 重定向

@WebServlet("/redirect")
public class RedirectServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setStatus(302);
        resp.setHeader("Location","https://www.baidu.com");
        // 由于重定向是一个常见操作，因此，还有一个简单的方法来完成这里的重定向
        resp.sendRedirect("https://www.baidu.com");
    }
}

四、Cookie和Session

4.1 Cookie的引入

在Lesson7：HTTP协议_刘减减的博客-CSDN博客

的5.3.6小节中指出，Cookie是浏览器提供的一种程序员在本地存储信息的机制，Cookie里面存的是键值对，并且键值对都是程序员自定义的。关于Cookie的一个非常典型的使用场景是：用Cookie来保存用户的登录信息。当登录成功后，后续再访问该网站时，就不用再重新输入用户名和密码。

但是，在实际生活中，和用户强相关的数据非常多，以电商网站为例，和用户相关的信息除了用户名密码，还有浏览记录、爱好、购物车、历史订单等等属性。这些和用户强相关的数据都是需要保存的。

由于这些信息太多了，传输过程中太占资源，因此不适合保存在客户端，保存在服务器最合适。保存方式就是通过session(会话)的方式来保存的。

服务器这边，根据当前用户登录成功后，就会生成一个键值对，key是sessionId，是一个随机不重复唯一的字符串，value就是要保存的身份信息。服务器以键值对的方式把这些会话管理起来(每个用户的登录都会生成一个会话)客户端只需要保存这个sessionID即可，在后续的请求中也是带上sessionID，然后服务器根据sessionID来查找，找到详细信息。

4.2 Cookie的优点

客户端很轻量，不用保存太多资源。

客户端和服务器之间传输的数据量小，节省带宽。

数据都在服务器存储，如果客户端出现问题，数据不会丢失。

4.3 Cookie和Session的区别

cookie：是客户端存储数据的一种机制，可以存储身份信息，也可以存储其他，由程序员自己定义session：是服务器存储数据的一种机制，也是键值对结构，主要用来存储身份相关的信息。

一个网站的登录功能，往往是结合这两个机制，共同实现。

4.4 核心方法

Servlet里面对Cookie和Session的操作提供了一些封装。

4.4.1 HttpServletRequest类中提供的相关方法

方法	描述
HttpSession getSession()	在服务器中获取会话。
Cookie[] getCookies()	返回一个数组，包含客户端发送该请求的所有的Cookie对象，会自动把Cookie中的格式解析成键值对。

注意：

getSession参数为true：先看当前请求中是否有sessionID和sessionID是否合法，如果有sessionID，就根据这个sessionID找到对应的HttpSesson对象。如果没有，就生成一个sessionID，并创建一个HttpSession对象，将这一组键值对插入到服务器管理session的hash表中，同时把sessionID通过Set-Cookie在响应中返回给客户端。

getSession参数为false：先看当前请求中是否有sessionID和sessionID是否合法，如果有sessionID，就根据这个sessionID找到对应的HttpSesson对象。如果没有，就直接返回null。

4.4.2 HttpServletResponse类中提供的相关方法

方法	描述
void addCookies()	把指定的cookie添加到响应中

4.4.3 HttpSession类中提供的相关方法

一个HttpSession对象里面包含多个键值对，可以往HttpSession对象存任何我们需要的信息。

方法	描述
Object getAttribute(String name)	在HttpSession对象中，根据key获取value
void setAttribute(String name,Object value)	在HttpSession对象中，根据key设置value
boolean isNew()	判断当前是否创建出新的对象

4.5 案例：登录功能，记录访问次数。

前端代码：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <form action="login" method="post">
        <input type="text" name="username" >
        <input type="text" name="password" >
        <input type="submit" value="提交">
    </form>
</body>
</html>

后端代码：

1. 登录页面的实现逻辑

①从HTTP请求中读出登录信息，即得到用户名的密码。

采用的时from表单发送请求，body的格式是application/x-www-form-urlencoded，即username=XX&password=XX。可以使用getParameter方法获取。

②对用户名和密码进行校验。

③判断是否登录成功

④登录成功后就创建一个会话

⑤重定向到一个新页面。

2. 代码

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 javax.servlet.http.HttpSession;
import java.io.IOException;
@WebServlet("/login")
public class LoginServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=utf-8");
        // 1.从请求中拿到用户名和密码 .form表单，利用getParameter方法
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        //2.校验是否用户名和密码是否合法
        if("".equals(username) || "".equals(password) || password == null || username == null){
            resp.getWriter().write("<h3>输入不合法</h3>");
            return;
        }
        //3. 判断是否登录成功.此处假设用户名叫做 admin, 密码叫做 123
        if(!username.equals("admin") || !password.equals("123")){
            resp.getWriter().write("<h3>用户名或者密码错误</h3>");
            return;
        }
        // 4.登录成功，创建新会话,来保存当前用户的信息
        HttpSession session = req.getSession(true);
        // 通过这个操作就给会话中保存了一个程序员自定义的信息
        session.setAttribute("visitCount",0);
        // 5. 将登录成功的结果返回给客户端，不能只是简单的提示登录成功，而是跳转到指定页面
        // 重定向的网站主页的servletpath是showIndex 
        resp.sendRedirect("showIndex");
    }
}

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 javax.servlet.http.HttpSession;
import java.io.IOException;

@WebServlet("/showIndex")
public class ShowIndexServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=utf8");
        // 1.先拿到session对象
        HttpSession session = req.getSession(false);
        if(session == null){
            resp.getWriter().write("<h3>您当前未登录</h3>");
            return;
        }
        // 2. 显示登录次数
        int count = (Integer)session.getAttribute("visitCount");
        count++;
        // 3. 将新的登录次数写回到session对象里
        session.setAttribute("visitCount",count);
        resp.getWriter().write("<h2>登录次数:" + count + "</h2>");
    }
}

五、上传文件

上传文件也是日常开发中的一类常见需求。

5.1 核心方法

5.1.1 HttpServletRequest类方法

方法	描述
Part getPart(String name)	获取请求中指定name的文件
Collection<Part> getParts()	获取所有文件。

5.1.2 Part类方法

方法	描述
String getSubmittedFileName()	获取提交的文件的名字
long getSize()	获取提交的文件的大小
String getContentType()	获取提交的文件的类型
void write(String path)	将提交的文件写入磁盘文件

5.2 上传文件案例

5.2.1前端代码

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <form action="upload" method="post" enctype="multipart/form-data">
        <input type="file" name="cat" >
        <input type="file" name="word" >
        <input type="submit" value="提交">
    </form>
</body>
</html>

enctype="multipart/form-data"。enctype字段就决定了请求的body中的格式。默认是x-www-form-urlencoded，对于上传文件来说,此时固定使用这个multipart/form-data

5.2.2 后端代码

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

@MultipartConfig
@WebServlet("/upload")
public class UploadServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=utf-8");
        // 1.获取从前端传来的文件
        Part part = req.getPart("cat");
        System.out.println(part.getSubmittedFileName()); // 文件的名字
        System.out.println(part.getSize());  // 大小
        System.out.println(part.getContentType());  //类型
        part.write("C:\\Users\\piyou\\Desktop\\java\\uploadFile\\cat.jpg"); // 文件保存在本地
        Part part1 = req.getPart("word");
        System.out.println(part1.getSubmittedFileName()); // 文件的名字
        System.out.println(part1.getSize());  // 大小
        System.out.println(part1.getContentType());  //类型
        part1.write("C:\\Users\\piyou\\Desktop\\java\\uploadFile\\word1.txt");
        resp.getWriter().write("<h3>上传完毕</h3>");
    }
}

当响应中返回中文的时候，就会出现乱码，原因是，处理数据的各个环节编码方式不统一

IDEA：UTF-8

浏览器：浏览器默认的是跟随系统的编码方式，Win10中文版编码方式是gbk

如何解决：思路：保证数据的构造和解析都是同一种编码方式

浏览器按照utf-8

程序返回的数据是bgk的编码

resp.setContentType("utf-8"); content-Type：描述了HTTP请求、响应正文的数据格式

六、表白墙(交互数据为Json)

6.1搭建项目文件

①创建maven工程文件。

②引入依赖。包括servlet、Jackson、mysql 的依赖。

③新建项目文件。webapp-WEB-INF-web.xml 。并将之前写好的MessageWall.html拷到webapp目录下。

④写代码。先写一个helloServlet的测试代码。

⑤使用SmartTomcat完成打包部署。

⑥验证程序是否正确。

6.2 约定前后端交互的接口

约定好前端发啥请求，服务器对应的返回啥响应。

6.3 编写代码

6.3.1 前端代码

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>表白墙</title>
</head>
<body>
    <style>
        /* 清空浏览器默认样式 */
        * {
            margin: none;
            padding: none;
            box-sizing: border-box;
        }
        .container {
            width: 300px;
            /* 水平居中 */
            margin: 0 auto;
        }
        h3 {
            text-align: center;
            padding: 10px 0;
        }
        p {
            text-align: center;
            font-size: 15px;
            color: rgb(196, 180, 159);
        }
        .row {
            display: flex;
            width: 100%;
            font-size: 18px;
            justify-content: center;
            align-items: center;
            height: 40px;
        }
        .edit {
            margin: 2px 0;
            height: 38px;
            width: 200px;
        }
        span {
            width: calc(100% - 200px);
        }
        .submit {
            width: 300px;
            height: 35px;
            background-color: pink;
            color: azure;
            font-size: 20px;
            border-radius: 3px;
            border: 0;
        }
        .submit:active {
            background-color: green;
        }
    
    </style>
    <!-- 给外层加个容器，通过这个容器实现对齐的效果 -->
    <div class="container">
        <h3>表白墙</h3>
        <p>输入后点击提交,会将信息显示在表格中</p>  
        <div class="row">
            <span>谁：</span>
            <input type="text" class="edit" id="name1">
        </div>
        <div class="row">
            <span>对谁：</span>
            <input type="text" class="edit" id="name2">
        </div>
        <div class="row">
            <span>说什么：</span>
            <input type="text" class="edit" id="message">
        </div>
        <div class="row">
            <input type="button" value="提交" class="submit">
        </div>
        
    </div> 
    <script src="http://libs.baidu.com/jquery/2.0.0/jquery.min.js"></script>
    <script>
        let submitButton = document.querySelector('.submit');
        submitButton.onclick = function(){
            // 先获取三个输入
            let name1 = document.querySelector('#name1');
            let name2 = document.querySelector('#name2');
            let message = document.querySelector('#message');
            // 判断输入是否合法
            if(name1 =='' || name2 == '' || message == ''){
                return;
            }
            // 创建一个div对象
            let div = document.createElement('div')
            div.innerHTML = name1.value + '对' + name2.value + '说' + message.value;
            div.style.textAlign = 'center';
            let container = document.querySelector('.container');
            // 将div对象加到dom树上
            container.appendChild(div);
            let body = {
                from: name1.value,
                to: name2.value,
                message: message.value
            }
            // 将输入发送给服务器
            $.ajax({
                method: 'post',
                url: 'message',
                contentType: 'application/json;charset=utf8',
                // JSON.stringify相当于Java objectMapper.writeValue
                data: JSON.stringify(body),
                success:function(data,status){
                    console.log(data);
                }
            });
            // 清空输入框
            name1.value = '';
            name2.value = '';
            message.value = '';
        }
        // 1.在页面加载的时候，从服务器拿到消息列表，并显示在网页上
        function load(){
            $.ajax({
                method: 'get',
                // 这里写的是相对路径
                url: "message",
                success:function(data,status){
                    // 此时的data已经被jQuery给转成一个对象数组了。转换的前提是，服务器响应的header设置content-type是application/json
                    let container = document.querySelector('.container');
                    for(let message of data){
                        // 遍历每一个元素，针对每个元素，创建div标签
                        let row = document.createElement('div');
                        row.className = 'row';
                        row.innerHTML = message.from + " 对 " + message.to + " 说 " + message.message;
                        console.log(row);
                        container.append(row);
                    }
                }
            });
        }
        load();
        // 2.当用户点击提交的时候，将当前的消息发送给服务器
    </script>
</body>
</html>

6.3.2 数据库代码

为了实现持久化存储数据，可以建立一个数据库，将数据存储在数据库中。

create database if not exists messageWall ;
use messageWall;
drop table if exists message;
create table message(
    'from' varchar(50),
    'to' varchar(50),
    'message' varchar(1024)
);

建立一个DBUtil类，封装数据库的相关操作。

import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;
import javax.sql.DataSource;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Connection;

public class DBUtil {
    private static final String URL = "jdbc:mysql://127.0.0.1:3306/messageWall?characterEncoding=utf8&useSSL=false";
    private static final String userName = "root";
    private static final String password = "1111";
    private static DataSource dataSource = new MysqlDataSource();
    static {
        ((MysqlDataSource)dataSource).setURL(URL);
        ((MysqlDataSource)dataSource).setUser(userName);
        ((MysqlDataSource)dataSource).setPassword(password);
    }
    public static Connection getConnections() throws SQLException {
        return dataSource.getConnection();
    }
    public static void close(Connection connection, PreparedStatement statement , ResultSet resultSet){
        if(resultSet != null){
            try {
                resultSet.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(statement != null){
            try {
                statement.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(connection != null){
            try {
                connection.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}

6.3.3 Servlet代码

import com.fasterxml.jackson.databind.ObjectMapper;

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.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;


class Message{
    public String from;
    public String to;
    public String message;
}
@WebServlet("/message")
public class MessageWallServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("get");
        resp.setContentType("applicatipon/json;charset=utf-8");
        ObjectMapper objectMapper = new ObjectMapper();
        // 将java代码中的对象，转成JSON字符串
        // 当前的message是一个List，得到的结果也就是一个JSON数组
        String jsonString = objectMapper.writeValueAsString(GetMessages());
        resp.getWriter().write(jsonString);
    }
    // 从数据库中读数据
    public List<Message> GetMessages(){
        System.out.println("getmessages");
        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        List<Message> messages = new ArrayList<>();
        try {
            // 1.和数据建立连接
            connection = DBUtil.getConnections();
            // 2.构造sql语句
            String sql = "select * from message";
            statement = connection.prepareStatement(sql);
            // 3.执行sql
            resultSet = statement.executeQuery();
            // 4.遍历结果集合
            while (resultSet.next()){
                Message message = new Message();
                message.from = resultSet.getString("from");
                message.to = resultSet.getString("to");
                message.message = resultSet.getString("message");
                System.out.println(message.toString());
                messages.add(message);
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            DBUtil.close(connection,statement,resultSet);
        }
        return messages;
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 读取请求中的JSON字符串，转成Message对象，然后往messages里面添加即可
        System.out.println("post");
        resp.setContentType("text/html;charset=utf-8");
        ObjectMapper objectMapper = new ObjectMapper();
        Message message = objectMapper.readValue(req.getInputStream(),Message.class);
        addMessage(message);
        resp.getWriter().write("insert ok");
    }
    public void addMessage(Message message){
        System.out.println("插入数据");
        Connection connection = null;
        PreparedStatement statement = null;
        try {
            // 1.和数据建立连接
            connection = DBUtil.getConnections();
            // 2.构造sql语句
            String sql = "insert into message values(?,?,?)";
            statement = connection.prepareStatement(sql);
            statement.setString(1,message.from);
            statement.setString(2,message.to);
            statement.setString(3,message.message);
            statement.executeUpdate();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            DBUtil.close(connection,statement,null);
        }
    }
}

刘减减

关注

2
点赞
踩
8

收藏

觉得还不错? 一键收藏
打赏
2
评论
Lesson10：ServletAPI详解(HttpServlet、HttpServletRequest、HttpServletResponse)

介绍了HttpServlet、HttpServletRequest和HttpServletResponse三个类的相关方法，并给出了获得请求中传来的参数的思路和方法；介绍了Session的相关概念和方法，基于Session和Cookie实现了一个登录页面的设计；介绍了如何实现上传文件功能；在最后以表白墙为例，对以上方法进行了综合运用。
复制链接

扫一扫