Servlet-过滤器

落日与晚风，

已于 2023-10-25 15:32:22 修改

阅读量44

点赞数

文章标签： servlet

于 2023-10-18 17:09:08 首次发布

本文链接：https://blog.csdn.net/llllll__ll/article/details/133898477

版权

过滤器Filter

概念：

Filter过滤器，是Web三大组件之一。

作用是将来访问服务器资源的时候，过滤器可以将请求拦截下来，完成一些特殊的操作之后，再将请求继续放行，完成后续的功能

一般可以用来完成一些通用的操作，比如：登录验证、统一的编码处理、敏感字符过滤

使用步骤

1、导包

2、编写过滤器

3、完成过滤后，放行

package com.web;

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

@WebServlet("/ServletFilter")
public class ServletFilter extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
        response.getWriter().write("你好！");
        
        System.out.println("servlet方法执行！");
    }
}

package com.web;

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

public class FilterDemo implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("初始化方法！");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

        System.out.println("执行过滤的方法！");

        //设置格式
        servletRequest.setCharacterEncoding("utf-8");
        servletResponse.setContentType("text/html;charset=utf-8");

        //将数据放行
        filterChain.doFilter(servletRequest,servletResponse);

    }

    @Override
    public void destroy() {

        System.out.println("销毁方法！");

    }
}

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

  <filter>
    <filter-name>demo1</filter-name>
    <filter-class>com.web.FilterDemo</filter-class>

<!--    //可以初始化配置需要被过滤器拦截的资源，可以配置、后缀、前缀、全路径-->
    <init-param>
      <param-name>excludedPaths</param-name>
      <param-value>*.js,*.css,*.ico</param-value>
    </init-param>

  </filter>

  <filter-mapping>
    <filter-name>demo1</filter-name>
<!--url-pattern    指的是会被过滤器拦截的地址-->
    <url-pattern>/*</url-pattern>
  </filter-mapping>

</web-app>

过滤器的生命周期

1，init方法：服务器启动后，会创建Filter对象，调用init 方法，调用一次，用来加载资源

2，doFilter方法：每次请求资源的时候，会执行这个方法，可以执行多次

3，destroy方法：服务器关闭，Filter对象被销毁执行此方法，执行一次，用于释放资源

过滤器配置方法

1，拦截具体资源： /xxx.jsp 只有访问指定资源才被过滤

2，拦截目录：/user/* 只有user目录下的资源被过滤

3，后缀名拦截： *.jsp 访问所有后缀名为jsp资源的时候，会被过滤

4，所有资源拦截： /*

使用注解的方式配置过滤器

使用方式，直接在类上加上 @WebFilter注解

写法：

1，如果直接写过滤资源，直接在括号中写上资源路径@WebFilter("/servletDemo01")

2，如果希望过滤的时候，有不同的过滤方式，可以加上 dispatcherTypes属性值

@WebFilter(value = "/servletDemo01",dispatcherTypes = DispatcherType.FORWARD)

DispatcherType的值：

FORWARD ：将来只有转发的请求，才会被过滤

INCLUDE ：包含访问资源就被过滤

REQUEST ：默认值，浏览器的请求会被过滤

ASYNC：异步访问资源

ERROR ：错误跳转资源被过滤

过滤器链（多个过滤器）

执行顺序：

如果配置两个过滤器，A和B

注解方式：服务器会根据过滤器的名称，完成顺序执行，xml中，会根据filte-mapping的位置，决定执行顺序

1，执行过滤器A

2，执行过滤器B

3，执行请求的资源

4，执行过滤器B

5，执行过滤器A

package com.web;

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

//@WebFilter(value = "/ServletFilter",dispatcherTypes = DispatcherType.FORWARD)
@WebFilter("/ServletFilter")
public class FilterDemo1 implements Filter {
    public void init(FilterConfig config) throws ServletException {
        System.out.println("初始化方法！");
    }

    public void destroy() {
        System.out.println("销毁方法！");
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
        System.out.println("1、执行过滤器A的前置方法！");

        //设置格式
        request.setCharacterEncoding("utf-8");
        response.setContentType("text/html;charset=utf-8");

        //将数据放行
        chain.doFilter(request, response);

        //后置方法
        System.out.println("2、过滤器A的后置方法！");
    }
}

package com.web;

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

@WebFilter("/ServletFilter")
public class FilterDemo2 implements Filter {
    public void init(FilterConfig config) throws ServletException {
    }

    public void destroy() {
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {

        System.out.println("3、执行过滤器B的方法！");

        chain.doFilter(request, response);

        System.out.println("4、过滤器B的后置方法！");
    }
}

监听器Listener

Listener监听器是web的三大组件之一，主要用来监听一些指定的操作

事件监听机制 :

事件：要监听的某件事

事件源：事件发生的位置

监听器：就是一个对象

注册监听：绑定事件、事件源、监听器，当事件发生后，完成指定的操作

监听器的方法：监听器有很多终端，以HttpSessionListener举例

sessionCreated ：创建session对象触发这个方法

sessionDestroyed ：session被销毁触发这个方法

统计在线人数：

使用HttpSessionListener完成

<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
    <title>Listener监听器</title>
</head>
<body>

    <h1>当前有
    ${pageContext.request.servletContext.getAttribute("onlineCount")}
        人在线
    </h1>

</body>
</html>

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

<!--    配置监听器-->
<listener>
    <listener-class>com.web.ListenerDemo1</listener-class>
</listener>

<!--    配置session销毁时间-->
    <session-config>
        <session-timeout>1</session-timeout>
    </session-config>

</web-app>

package com.web;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;

@WebListener
public class ListenerDemo1 implements ServletContextListener, HttpSessionListener, HttpSessionAttributeListener {

    public ListenerDemo1() {
    }

    @Override
    public void contextInitialized(ServletContextEvent sce) {
        /* This method is called when the servlet context is initialized(when the Web application is deployed). */
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        /* This method is called when the servlet Context is undeployed or Application Server shuts down. */
    }

    //Session被创建就会被执行
    @Override
    public void sessionCreated(HttpSessionEvent se) {
        /* Session is created. */
        //先获取session,在通过session获取ServletContext域对象
        ServletContext servletContext = se.getSession().getServletContext();

        //获取域对象中的在线人数，将来在域对象中，会指定一个变量，来存放在线人数
        Integer onlineCount = (Integer) servletContext.getAttribute("onlineCount");

        //如果获取到的数据是null的话，说明没人登录，是第一次访问网站，那么就将在线人数设为1
        if (onlineCount == null){
            onlineCount = new Integer(1);
        }else {
            //已经有人访问网站了，那么onlineCount就不为null
            onlineCount = onlineCount + 1;
        }
        servletContext.setAttribute("onlineCount",onlineCount);

    }

    @Override
    public void sessionDestroyed(HttpSessionEvent se) {
        /* Session is destroyed. */
        //先获取session,在通过session获取ServletContext域对象
        ServletContext servletContext = se.getSession().getServletContext();

        //获取域对象中的在线人数，将来在域对象中，会指定一个变量，来存放在线人数
        Integer onlineCount = (Integer) servletContext.getAttribute("onlineCount");

        //如果获取到的数据是null的话，
        if (onlineCount == null){
            onlineCount = new Integer(0);
        }else {
            //已经有人访问网站了，那么onlineCount就不为null,人走了数量减1
            onlineCount = onlineCount - 1;
        }
        servletContext.setAttribute("onlineCount",onlineCount);

    }

    @Override
    public void attributeAdded(HttpSessionBindingEvent sbe) {
        /* This method is called when an attribute is added to a session. */
    }

    @Override
    public void attributeRemoved(HttpSessionBindingEvent sbe) {
        /* This method is called when an attribute is removed from a session. */
    }

    @Override
    public void attributeReplaced(HttpSessionBindingEvent sbe) {
        /* This method is called when an attribute is replaced in a session. */
    }
}

登录权限判断案例

项目中，用户登录之后，才能进入某些指定的页面，如果用户没登录，或者注销之后，就不能继续访问有权限的页面


<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
    <title>用户登录</title>
</head>
<body>

    <h1>登录页面</h1>
    <form action="/test/loginServlet" method="post">
        用户名:<input type="text" name="username">
        <br>
        <br>
        密  码:<input type="password" name="password">
        <br>
        <input type="submit" value="登录">

    </form>

</body>
</html>

error.jsp


<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
    <title>登录失败</title>
</head>
<body>

    <h1>你还没有登录，没有访问权限</h1>
    <a href="login.jsp">去登录</a>

</body>
</html>

success.jsp


<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
    <title>登录成功</title>
</head>
<body>
    <h1>这是主页，登录之后才能访问</h1>
    <h1>${user},欢迎你</h1>
    <h1><a href="/test/logoutServlet">注销</a></h1>
</body>
</html>

ServletLogin

package com.web.login;

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

@WebServlet("/loginServlet")
public class ServletLogin extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }

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

        //获取前端请求参数
        String username = request.getParameter("username");
        String password = request.getParameter("password");
        if ("admin".equals(username) && "123456".equals(password)) {
            //登录成功
            request.getSession().setAttribute("user", username);
            response.sendRedirect("/test/success.jsp");
        } else {
            response.sendRedirect("/test/error.jsp");
        }
    }
}

ServletLogout

package com.web.login;

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

import static javax.swing.text.html.CSS.getAttribute;

@WebServlet("/logoutServlet")
public class ServletLoginOut extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }

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

        //注销
        HttpSession session = request.getSession();
        Object user = session.getAttribute("user");

        if (user != null){
            //如果有用户信息移除,跳转到登录页面
            session.removeAttribute("user");
            response.sendRedirect("/test/login.jsp");
        }else {
            response.sendRedirect("/test/login.jsp");
        }
    }
}

LoginFilter

package com.web.login;

import javax.servlet.*;
import javax.servlet.annotation.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

@WebFilter("/success.jsp")
public class FilterLogin implements Filter {
    public void init(FilterConfig config) throws ServletException {
    }

    public void destroy() {
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
        request.setCharacterEncoding("utf-8");
        response.setContentType("text/html;charset=utf-8");
        //过滤请求
        //方法中的参数是ServletRequest，获取session要使用HttpServletRequest
        //要做一个转换
        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse resp = (HttpServletResponse) response;
        HttpSession session = req.getSession();
        Object user = session.getAttribute("user");
        if (user == null) {
            //如果用户为null，表示未登录，就跳转到错误界面
            resp.sendRedirect("/test/error.jsp");
        }
        //放行
        chain.doFilter(req,resp);
    }


    }

AJAX+JSON

AJAX

概念：

AJAX = Asynchronous JavaScript And XML. 异步的 JavaScript和XML

AJAX 并非编程语言。

AJAX 仅仅组合了：

浏览器内建的 XMLHttpRequest 对象（从 web 服务器请求数据）

JavaScript 和 HTML DOM（显示或使用数据）

Ajax 是一个令人误导的名称。Ajax 应用程序可能使用 XML 来传输数据，但将数据作为纯文本或 JSON 文本传输也同样常见。

Ajax 允许通过与场景后面的 Web 服务器交换数据来异步更新网页。这意味着可以更新网页的部分，而不需要重新加载整个页

异步和同步的概念：

指的是建立在客户端和服务器相互通信的基础上

ajax指的是无需重新加载整个网页，就能够实现网页更新的技术

实现方式：

原生JS实现

使用XMLHttpRequest 对象

所有现代浏览器都支持 XMLHttpRequest 对象。

XMLHttpRequest对象方法

方法	描述
new XMLHttpRequest()	创建新的 XMLHttpRequest 对象。
abort()	取消当前请求。
getAllResponseHeaders()	返回头部信息。
getResponseHeader()	返回特定的头部信息。
open(method, url, async, user, psw)	规定请求。 method：请求类型 GET 或 POST url：文件位置 async：true（异步）或 false（同步） user：可选的用户名 psw：可选的密码
send()	向服务器发送请求，用于 GET 请求。
send(string)	向服务器发送请求，用于 POST 请求。
setRequestHeader()	将标签/值对添加到要发送的标头。

XMLHttpRequest 对象属性

属性	描述
onload	定义接收到（加载）请求时要调用的函数。
onreadystatechange	定义当 readyState 属性发生变化时调用的函数。
readyState	保存 XMLHttpRequest 的状态。 0：请求未初始化 1：服务器连接已建立 2：请求已收到 3：正在处理请求 4：请求已完成且响应已就绪
responseText	以字符串形式返回响应数据。
responseXML	以 XML 数据返回响应数据。
status	返回请求的状态号 200: "OK" 403: "Forbidden" 404: "Not Found" 如需完整列表请访问 Http 消息参考手册
statusText	返回状态文本（比如 "OK" 或 "Not Found"）

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<input type="text">

<button onclick="fun()">
    点击发送请求
</button>

</body>
<script>
    function fun(){

        // 创建 XMLHttpRequest 对象
        const xhttp = new XMLHttpRequest();

        // 定义回调函数
        // xhttp.onload = function() {
        //     // 您可以在这里使用数据
        // }

        // 发送请求
        xhttp.open("GET", "/test/ajaxServlet?username=jack",false);
        xhttp.send();

        //拿到响应的数据
        xhttp.onreadystatechange = function (){
            //表示有响应，且成功响应
            if (this.readyState == 4 && this.status == 200){
                //拿到响应的数据
                var text = this.responseText;
                alert(text);
            }
        }

    }




</script>
</html>

package com.web.ajax;

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

@WebServlet("/ajaxServlet")
public class ServletAjax extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }

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

        String username = request.getParameter("username");
        System.out.println("后台接收到发送过来的Ajax：" + username);

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        response.getWriter().write("hello.ajax");
    }
}

表单数据提取

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

    用户名:<input type="text" name="username">

    <button onclick="fun()">
        点击发送请求
    </button>

</body>
<script>
    function fun(){

        // 创建 XMLHttpRequest 对象
        const xhttp = new XMLHttpRequest();
       let inputElement = document.querySelector("input");
       var username = inputElement.value;

        // 定义回调函数
        // xhttp.onload = function() {
        //     // 您可以在这里使用数据
        // }

        // 发送请求
        xhttp.open("GET", "/test/ajaxServlet?username="+username,true);
        xhttp.send();

        //拿到响应的数据
        xhttp.onreadystatechange = function (){
            //表示有响应，且成功响应
            if (this.readyState == 4 && this.status == 200){
                //拿到响应的数据
                var text = this.responseText;
                alert(text);
            }
        }

    }




</script>
</html>

多数据提取

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<!--    用户名:<input type="text" name="username">-->
用户名:<input type="text" class="username"><br>
密码:<input type="password" class="password">

    <button onclick="fun()">
        点击发送请求
    </button>

</body>
<script>
    function fun(){

        // 创建 XMLHttpRequest 对象
        const xhttp = new XMLHttpRequest();
       let userNameEle = document.querySelector(".username");
       let passwordEle = document.querySelector(".password");
       var username = userNameEle.value;
       var password = passwordEle.value;

        // 定义回调函数
        // xhttp.onload = function() {
        //     // 您可以在这里使用数据
        // }

        // 发送请求
        xhttp.open("GET", "/test/ajaxServlet?username="+username+"&password="+password,true);
        xhttp.send();

        //拿到响应的数据
        xhttp.onreadystatechange = function (){
            //表示有响应，且成功响应
            if (this.readyState == 4 && this.status == 200){
                //拿到响应的数据
                var text = this.responseText;
                alert(text);
            }
        }

    }




</script>
</html>

package com.web.ajax;

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

@WebServlet("/ajaxServlet")
public class ServletAjax extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }

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

        String username = request.getParameter("username");
        String password = request.getParameter("password");
        System.out.println("后台接收到发送过来的Ajax" );
        System.out.println("用户名:"+username);
        System.out.println("密码::"+password);

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        response.getWriter().write("hello.ajax");
    }
}

通过JQuery实现

实现语法：

$.ajax({

url:请求地址

type:请求方法 get/post

data:表示请求的数据{"键":"值"，"键":"值"}

success：function(resp){

请求成功后，返回的数据

}，

error：function（）{

}，

dataType:响应的数据类型“JSON”

})

语法2：

$.get(

url:待载入页面的URL地址

data:待发送 Key/value 参数。

callback:载入成功时回调函数。

type:返回内容格式，xml, html, script, json, text, _default。

)

语法3：post请求

$.post(

url:待载入页面的URL地址

data:待发送 Key/value 参数。

callback:载入成功时回调函数。

type:返回内容格式，xml, html, script, json, text, _default。

）

<!DOCTYPE html>
<html lang="en">
<head>
 <meta charset="UTF-8">
 <title>Title</title>
</head>
<body>
 用户名:<input type="text" class="username">
 密码: <input type="password" class="password">
 <button onclick="fun()">发送请求</button>
 <div></div>
</body>
<script src="./js/jquery-3.3.1.js"></script>
<script>
 function fun(){
 //document.querySelector(".username").value;
 var username = $(".username").val(); //
 var password = $(".password").val();
 /**
 $.ajax({
 url:"ajaxServlet", //请求资源地址
 type:"get", //请求的方法
 data:{"username":username,"password":password},//携带的数据
 success:function (resp){ //resp表示响应的结果
 //document.querySelector("div").innerHTML = resp;
 $("div").html(resp);
 }
 })
 */
 /**$.get("ajaxServlet",
 {"username":username,"password":password},
 function (resp){ //resp表示响应的结果
 //document.querySelector("div").innerHTML = resp;
 $("div").html(resp);
 })
 */
 $.post("ajaxServlet",
 {"username":username,"password":password},
 function (resp){ //resp表示响应的结果
 //document.querySelector("div").innerHTML = resp;
 $("div").html(resp);
 })
 }
</script>
</html

JSON

JSON: JavaScript Object Notation（JavaScript 对象标记法）。 JSON 是一种存储和交换数据的语法。 JSON 是通过 JavaScript 对象标记法书写的文本。

交换数据

当数据在浏览器与服务器之间进行交换时，这些数据只能是文本。

JSON 属于文本，并且我们能够把任何 JavaScript 对象转换为 JSON，然后将 JSON 发送到服务器。

我们也能把从服务器接收到的任何 JSON 转换为 JavaScript 对象。

以这样的方式，我们能够把数据作为 JavaScript 对象来处理，无需复杂的解析和转译。

为什么使用 JSON？

因为 JSON 格式仅仅是文本，它能够轻松地在服务器浏览器之间传输，并用作任何编程语言的数据格式。

JavaScript 提供內建函数把以 JSON 格式写的字符串转换为原生 JavaScript 对象：

转换方法

JSON.stringify() 将js对象转为JSON格式字符串

JSON.parse() 将JSON格式字符串，转为js对象

JSON语法规则

JSON 语法衍生于 JavaScript 对象标记法语法：

数据在名称/值对中

数据由逗号分隔

花括号容纳对象

方括号容纳数组

有效的数据类型

在 JSON 中，值必须是以下数据类型之一：

字符串 { "name":"Bill" }

数字 { "age":30 }

对象（JSON 对象） {"employee":{ "name":"Bill Gates", "age":62, "city":"Seattle" }}

数组 {"employees":[ "Bill", "Steve", "David" ]}

布尔 { "sale":true }

Null { "middlename":null }

json数据格式的几种常用写法：

//普通的java对象转为json字符串的格式
 let user = {"username":"jack","password":"123456"};
 let username12 = user.username;
 console.log(username);
 //java中list集合的写法
 var users = [
 {"username":"jack","password":"123456"},
 {"username":"tom","password":"11111"},
 {"username":"lucy","password":"33333"}
 ]
 var username1 = users[0].username;
 for (let i = 0; i < users.length; i++) {
 let user = users[i];
 console.log(user.username)
 }
 //java中map转为json的写法
 var usermap = {
 "user1":{"username":"jack","password":"123456"},
 "user2":[
 {"username":"jack","password":"123456"},
 {"username":"tom","password":"11111"},
 {"username":"lucy","password":"33333"}
 ]
 }
 var username2 = usermap.user1.username;
 var username2 = usermap.user2[0].username;

JSON和JAVA对象的转换

使用JSON解析器：jsonlib、fastjson(阿里巴巴)、 jackson(spring)

在Java中将对象、集合转为JSON

json转java对象

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

1，导入jar包依赖 jackson相关

2，创建核心对象 ObjectMapper

3，调用ObjectMapper对象方法，进行转换

//先定义json字符串
 String userJson = "{\"username\":\"jack\",\"password\":\"123456\
 //2，创建核心对象 ObjectMapper
 ObjectMapper objectMapper = new ObjectMapper();
 //3，调用ObjectMapper对象方法，进行转换
 User user = objectMapper.readValue(userJson, User.class);

JAVA对象转Json字符串

1，导入jar包依赖 jackson相关

2，创建核心对象 ObjectMapper

3，调用ObjectMapper对象方法，进行转换

核心方法 writeValue

参数： File ：将对象转成的json字符串，保存在指定的文件中

Writer：将对象转成json字符串，并将json字符串读取到字符输出流 outputStream ：将对象转成json字符串，并将json字符串读取到字节输出流 writeValueAsString(object) : 将对象直接转为json字符串

对象常用注解

// @JsonFormat(pattern = "yyyy-MM-dd") 格式化日期类型

@JsonIgnore 忽略某个属性，加了之后，将来json字符串中，不显示这个属性

public class User {
 private String username;
 private String password;
// @JsonFormat(pattern = "yyyy-MM-dd")
 @JsonIgnore
 private Date birthday;
 public User() {
 }
 public User(String username, String password) {
 this.username = username;
 this.password = password;
 }
 public User(String username, String password, Date birthday) {
 this.username = username;
 this.password = password;
 this.birthday = birthday;
 }
 @Override
 public String toString() {
 return "User{" +
 "username='" + username + '\'' +
 ", password='" + password + '\'' +
 ", birthday=" + birthday +
 '}';
 }
 public String getUsername() {
 return username;
 }
 public void setUsername(String username) {
//先定义java对象
 User user1 = new User("jack", "123");
 //2，创建核心对象 ObjectMapper
 ObjectMapper objectMapper = new ObjectMapper();
 //3，调用ObjectMapper对象方法，进行转换
 //{"username":"jack","password":"123"}
 String s = objectMapper.writeValueAsString(user1);
 System.out.println(s);
 //使用objectMapper将list转为json字符串
 ArrayList<User> userList = new ArrayList<>();
 userList.add(new User("jack", "123"));
 userList.add(new User("tom", "123456"));
 userList.add(new User("lucy", "55555"));
 //创建ObjectMapper
// ObjectMapper objectMapper = new ObjectMapper();
// //调用方法
// String s = objectMapper.writeValueAsString(userList);
// System.out.println(s);
 HashMap<String, Object> map = new HashMap<>();
 map.put("user",new User("jack", "123"));
 map.put("userList",userList);
 //转换格式
 ObjectMapper objectMapper = new ObjectMapper();
 String s = objectMapper.writeValueAsString(map);
 System.out.println(s);

将list中的用户信息，通过ajax展示到表格中

@WebServlet("/servletUser")
public class ServletUser extends HttpServlet {
 @Override
 protected void doGet(HttpServletRequest request, HttpServletResponse re
 ArrayList<User> userList = new ArrayList<>();
 userList.add(new User("jack", "123",new Date()));
 userList.add(new User("tom", "123456",new Date()));
 userList.add(new User("lucy", "55555",new Date()));
 ObjectMapper objectMapper = new ObjectMapper();
 //调用方法
 String s = objectMapper.writeValueAsString(userList);
 response.getWriter().write(s);
 }
 @Override
 protected void doPost(HttpServletRequest request, HttpServletResponse
 this.doGet(request, response);
 }
}

<!DOCTYPE html>
<html lang="en">
 <head>
 <meta charset="UTF-8">
 <title>Title</title>
 </head>
 <body>
 <table border="1px" cellspacing="0" cellpadding="10px">
 <tr>
 <th>用户名</th>
 <th>密码</th>
 <th>生日</th>
 </tr>
 </table>
 <button>点击获取数据</button>
 </body>
 <script src="./js/jquery-3.3.1.js"></script>
 <script>
 $(function (){
 //通过jquery添加点击事件
 // $("button").click(function (){
 $.ajax({
 url: "servletUser",
 type: "get",
 success:function (resp) {
 //先把响应的JSON字符串，转为JS对象
 let users = JSON.parse(resp);
 //遍历转换过后的js对象
 for (let i = 0; i < users.length; i++) {
 console.log(users[i]);
 //创建一个tr节点，并将需要展示的内容写在tr的td中
 var trele = $("<tr>\n" +
 " <td>"+ users[i].username +"</td>\n"
 " <td>"+ users[i].password +"</td>\n"
 " <td>"+ users[i].birthday +"</td>\n"
 " </tr>")
 //通过表格节点添加tr节点
 $("table").append(trele);
 }
 }
 })
 // })
 })
 </script>
</html>

异步验证用户名信息

<!DOCTYPE html>
<html lang="en">
<head>
 <meta charset="UTF-8">
 <title>Title</title>
</head>
<body>
 <h1>修改密码</h1>
 <form action="registerServlet" method="post">
 用户名:<input type="text" name="username" placeholder="请输入用户名"
 原密码: <input type="password" name="oldpassword"> <span></span> <b
 新密码: <input type="password" name="password"> <span></span> <br>
 重复密码: <input type="password" name="repassword"> <span></span> <
 <input type="submit" value="注册">
 </form>
</body>
<script src="./js/jquery-3.3.1.js"></script>
<script>
 //用户名提交的失去焦点事件
 $("input[name='username']").blur(function (){
 //获取输入框的用户名
 var username = $("input[name='username']").val();
 console.log(username);
 $.ajax({
 url:"registerServlet",
 type:"post",
 data:{"username":username},
 success:function (response){
 // console.log(response);
 if (response.userExist){
 $(".usernameText").html(response.userInfo + "√");
 $(".usernameText").css("color","green");
 }else {
 $(".usernameText").html(response.userInfo + "×");
 $(".usernameText").css("color","red");
 }
 },
 dataType:"json"
 })
 })
</script>
</html>

@WebServlet("/registerServlet")
public class ServletRegister extends HttpServlet {
 @Override
 protected void doGet(HttpServletRequest request, HttpServletResponse re
 request.setCharacterEncoding("utf-8");
 response.setContentType("application/json;charset=utf-8");
 //获取请求数据
 String username = request.getParameter("username");
 System.out.println(username);
 //创建一个map用来存放响应消息
 HashMap<String, Object> map = new HashMap<>();
 if (username == "" || username ==null){
 map.put("userExist",false);
 map.put("userInfo","请输入用户名");
 }else {
 //逻辑判断
 if ("jack".equals(username)){
 map.put("userExist",true);
 map.put("userInfo","用户名存在");
 }else {
 map.put("userExist",false);
 map.put("userInfo","用户名不存在");
 }
 }
 //将map响应回去
 ObjectMapper objectMapper = new ObjectMapper();
 //直接传入Writer和map参数响应即可
 objectMapper.writeValue(response.getWriter(),map);
 }
 @Override
 protected void doPost(HttpServletRequest request, HttpServletResponse
 this.doGet(request, response);
 }
}

落日与晚风，

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Servlet-过滤器

过滤器是一种设备或程序，用于根据特定的规则或条件，筛选、处理或阻止特定类型的数据、信息或内容。它可以用来过滤垃圾邮件、广告、恶意软件等不需要或有害的信息，提高网络安全性和用户体验。过滤器可以基于关键词、主题、发件人、网址等进行过滤，并根据预设的策略执行相应的操作，如删除、标记、拦截等。通过帮助用户管理和控制所接收或展示的内容，过滤器有助于提高工作效率和保护个人隐私。
复制链接

扫一扫