59、SpringBoot 自定义JSON的序列化器和反序列化器

news2025/1/24 22:37:57

Serialization(序列化)： 将java对象以一连串的字节码保存在磁盘文件中的过程，也可以说是保存java对象状态的过程。序列化可以将数据永久保存在磁盘上(通常保存在文件中)。

deserialization(反序列化)： 将保存在磁盘文件中的java字节码重新转换成java对象称为反序列化。

★ 自定义JSON的序列化器和反序列化器

▲ 注册自定义序列化器和反序列化器有两种方式：

- 方式1：利用Jackson的模块机制来注册自定义序列化器和反序列化器。

- 方式2：利用Spring Boot提供的@JsonComponent来注册自定义序列化器和反序列化器。

第一种方式是Jackson原生的注册方式，一般不推荐。推荐使用第二种方式。

★ 使用@JsonComponent注册序列化器或反序列化器

Spring Boot提供了@JsonComponent注解来注册自定义自定义序列化器和反序列化器，
该注解有两种使用方式：

-方式1： 直接使用 @JsonComponent 注解修饰JsonSerializer、JsonDeserializer或KeyDeserializer实现类，
  这些实现类将会由Spring Boot注册为自定义JSON序列化器和反序列化器。
  @JsonComponent 注解修饰 JsonSerializer，就是自定义 JSON 序列化器
  @JsonComponent 注解修饰 JsonDeserializer，就是自定义 JSON 反序列化器
  

-方式2：使用 @JsonComponent 修饰包含JsonSerializer/JsonDeserializer内部实现类的外部类，
  这些内部实现类将会由Spring Boot注册为自定义JSON序列化器和反序列化器。
  这种方式相当于将序列化器和反序列化器都定义在一个外部类中，这种方式具有更好的内聚性，
  通常推荐用方式2。

内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类

Token定义
Token是Fastjson中定义的json字符串的同类型字段，即"{“、”["、数字、字符串等，用于分隔json字符串不同字段。
例如，{“姓名”：“张三”,“年龄”:“20”}是一个json字符串，在反序列化之前，需要先将其解析为
{ 、 姓名、 ：、 张三、 ,、 年龄、 ：、 20、 }这些字段的Token流，随后再根据class反序列化为响应的对象。
在进行Token解析之前，json字符串对程序而言只是一个无意义的字符串。需要将json字符串解析为一个个的Token，并以Token为单位解读json数据。

代码演示：

自定义序列化和反序列化器的代码

package cn.ljh.app.custom;


import cn.ljh.app.domain.Book;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import lombok.SneakyThrows;
import org.springframework.beans.BeanUtils;
import org.springframework.boot.jackson.JsonComponent;

import java.io.IOException;

//内部类就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类,这个 CustomSeDe 就是外部类
//使用 @JsonComponent 修饰包含JsonSerializer/JsonDeserializer内部实现类的外部类，
//这些内部实现类将会由Spring Boot注册为自定义JSON序列化器和反序列化器。
@JsonComponent
public class CustomSeDe
{
    //在该类中可定义自定义的序列化器和反序列化器


    //postman 用get请求时走这个方法
    //自定义序列化器，这个就是内部类
    public static class MySerializer extends JsonSerializer<Book>
    {

        @Override
        public void serialize(Book book, JsonGenerator jsonGenerator,
                              SerializerProvider serializerProvider) throws IOException
        {
            //在该方法中完成自定义的序列化输出，将对象输出成 json 或者是 xml 字符串

            jsonGenerator.writeStartObject(); //输出 {  这个花括号 ， 输出对象用这个括号
//            jsonGenerator.writeStartArray();  //输出 [ 这个中括号  ， 输出数值用这个括号
            jsonGenerator.writeNumberField("id", book.getId());
            //将book对象的name属性，序列化为title 属性
            jsonGenerator.writeStringField("title", book.getName());
            jsonGenerator.writeNumberField("price", book.getPrice());
            jsonGenerator.writeStringField("author", book.getAuthor());
//            jsonGenerator.writeEndArray();   // 输出这个 ] 中括号
            jsonGenerator.writeEndObject();  //输出这个 } 花括号
        }
    }

    //postman 用post的请求访问到这个方法
    //自定义反序列化器，这个就是内部类
    public static class MyDeserializer extends JsonDeserializer<Book>
    {
        //这个方法负责反序列化，就是将 json 或者是 xml 字符串 恢复成对象
        @SneakyThrows
        @Override
        public Book deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException
        {

            Book book = new Book();

            //JsonToken采用顺序方式依次读取 JSON 或 XML 字符串中的每个 token
            //token：一个花括号也叫token，一个符号隔开一个内容就叫token
            JsonToken jsonToken = jsonParser.getCurrentToken();
            //只要这个 Json 或者 xml 字符串没有结束，都应该继续向下读取
            while (!jsonToken.equals(JsonToken.END_OBJECT))
            {
                //这个循环的作用，是去保证要找到代表 Field Name 的 Token
                //如果当前读取的Token 不是字段名
                if (!jsonToken.equals(JsonToken.FIELD_NAME))
                {
                    jsonToken = jsonParser.nextToken();//读取下一个token
                    continue;
                }
                //只要程序进到此处，就一定是读取到 field name 这种字段token
                //从 JSON 或者是 XML 字符串中读取得到的字段名，也就是Book 对象的属性名
                String fieldName = jsonParser.getCurrentName();
                //读取属性名之后，下一个Token就是属性值了
                JsonToken valueToken = jsonParser.nextToken();
                //获取当前token的值
                String value = jsonParser.getText();
                //对于要逻辑处理的属性，可以在这里进行判断处理
                if (fieldName.equals("title"))
                {
                    if (!value.startsWith("《"))
                    {
                        value = "《" + value;
                    }
                    if (!value.endsWith("》"))
                    {
                        value += "》";
                    }
                    //完成了对Book对象的name属性的设置
                    book.setName(value);
                } else if (fieldName.equals("price"))
                {
                    double price = Double.parseDouble(value);
                    //把从json或xml格式的价格数据拿出来，然后打折set进去
                    book.setPrice(price * 0.5);
                } else
                {
                    //对于其他属性，不需要额外处理的话，直接通过反射来调用Book对象的fieldName对应的setter方法
                    BeanUtils.getPropertyDescriptor(Book.class, fieldName)
                            .getWriteMethod()
                            .invoke(book, value);
                }
                //继续向下读取下一个 Token
                jsonToken = jsonParser.nextToken();
            }
            return book;
        }
    }

}

测试：

序列化输出，将对象输出成 json 或者是 xml 字符串
反序列化，就是将 json 或者是 xml 字符串 恢复成对象

前端发送 get 请求，会走序列化方法。
http://localhost:8080/books
（不知道是如何定义访问的方法是走序列化还是反序列化方法）
get 请求是获取对象，序列化方法，把对象序列化成json格式的数据返回
在这里插入图片描述

序列化输出，将对象输出成 json 或者是 xml 字符串
反序列化，就是将 json 或者是 xml 字符串 恢复成对象

用 post 请求，会走反序列化方法，
发送的请求是 json 格式的数据，所以走反序列化方法，将数据恢复成对象
在这里插入图片描述

不太懂如何怎么应用这个自定义的序列化和反序列化器。

完整代码：

Book

在这里插入图片描述

BookController

package cn.ljh.app.controller;


import cn.ljh.app.domain.Book;
import cn.ljh.app.service.BookService;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/*
 *     GET  /books/{id} - （获取数据） 获取指定id的图书
 *     GET  /books?参数  -（获取数据） 获取符合查询参数的图书
 *     GET  /books        -（获取数据） 获取所有图书
 *     POST /books        -（添加数据） 添加图书
 *     PUT  /books/{id}    -（更新数据） 更新指定ID的图书
 *     DELETE /books/{id}    -（删除数据） 删除指定ID的图书
 *     DELETE /books?参数    -（删除数据） 删除符合指定参数的图书
 *
 *  Restful处理方法的返回值通常都应该使用HttpEntity或ResponseEntity。
 *
 */

@RequestMapping("/books")
@RestController
public class BookController
{
    //有参构造器进行依赖注入
    private BookService bookService;

    public BookController(BookService bookService)
    {
        this.bookService = bookService;
    }


    //根据id查看图书
    @GetMapping("/{id}")
    public ResponseEntity<Book> viewBookById(@PathVariable Integer id)
    {
        Book book = bookService.getBookById(id);

        //参数1：响应数据体  参数2：需要添加的响应头，没有就给个null   参数3:响应码 ， OK 代表 200
        return new ResponseEntity<>(book, null, HttpStatus.OK);
    }

    //查看所有图书
    @GetMapping("")
    public ResponseEntity<List<Book>> viewBooks()
    {
        List<Book> allBooks = bookService.getAllBooks();

        return new ResponseEntity<>(allBooks, null, HttpStatus.OK);
    }

    //添加图书
    @PostMapping("")
    public ResponseEntity<Book> addBook(@RequestBody Book book)
    {
        Book b = bookService.addOrUpdateBook(book);
        //HttpStatus.CREATED 代表返回的状态码为 201
        return new ResponseEntity<>(b, null, HttpStatus.CREATED);
    }

    //根据id更新图书信息
    @PutMapping("/{id}")
    public ResponseEntity<Book> updateBookById(@PathVariable Integer id, @RequestBody Book book)
    {
        book.setId(id);
        Book b = bookService.addOrUpdateBook(book);

        return new ResponseEntity<>(b, null, HttpStatus.OK);
    }

    //根据id删除图书
    @DeleteMapping("/{id}")
    public ResponseEntity<Book> deleteBookById(@PathVariable Integer id)
    {
        Book book = bookService.deleteBookById(id);
        return new ResponseEntity<>(book, null, HttpStatus.OK);
    }

}

BookService

package cn.ljh.app.service;

import cn.ljh.app.domain.Book;

import java.util.List;

public interface BookService
{
    //根据id查看图书
    Book getBookById(Integer id);

    //查看所有图书
    List<Book> getAllBooks();

    //添加/修改图书
    Book addOrUpdateBook(Book book);

    //根据id删除图书
    Book deleteBookById(Integer id);

}

BookServiceImpl

package cn.ljh.app.service.impl;

import cn.ljh.app.domain.Book;
import cn.ljh.app.service.BookService;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;


@Service
public class BookServiceImpl implements BookService
{
    //创建一个线程安全的map集合存数据，假设为数据库
    static Map<Integer, Book> bookDB = new ConcurrentHashMap<>();
    static int nextId = 1;

    //初始化数据库的数据
    static
    {
        bookDB.put(nextId, new Book(nextId++, "火影忍者", 120, "岸本"));
        bookDB.put(nextId, new Book(nextId++, "七龙珠", 121, "鸟山明"));
    }


    //根据id查看图书
    @Override
    public Book getBookById(Integer id)
    {
        if (id != null)
        {
            Book book = bookDB.get(id);
            if (book!=null){
                return book;
            }
        }
        throw new RuntimeException("根据id查看图书失败！");
    }

    //查看所有图书
    @Override
    public List<Book> getAllBooks()
    {
        //获取map中的所有数据
        Collection<Book> mapBooks = bookDB.values();
        //强转
        List<Book> books = new ArrayList<>(mapBooks);
        return books;
    }

    //添加/修改图书
    @Override
    public Book addOrUpdateBook(Book book)
    {
        if (book.getId() != null){
            //修改
            //map的key是唯一的，所以map里面有这个key的话，直接把原来的value覆盖掉
            bookDB.put(book.getId(),book);
            return book;
        }else {
            //新增
            //为新增的图书设置id
            book.setId(nextId);
            //book添加完之后，这个id才会自增
            bookDB.put(nextId++,book);
            return book;
        }
    }

    //根据id删除图书
    @Override
    public Book deleteBookById(Integer id)
    {
        Book book = bookDB.remove(id);
        return book;
    }
}

CustomSeDe

package cn.ljh.app.custom;


import cn.ljh.app.domain.Book;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import lombok.SneakyThrows;
import org.springframework.beans.BeanUtils;
import org.springframework.boot.jackson.JsonComponent;

import java.io.IOException;

//内部类就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类,这个 CustomSeDe 就是外部类
//使用 @JsonComponent 修饰包含JsonSerializer/JsonDeserializer内部实现类的外部类，
//这些内部实现类将会由Spring Boot注册为自定义JSON序列化器和反序列化器。
@JsonComponent
public class CustomSeDe
{
    //在该类中可定义自定义的序列化器和反序列化器


    //postman 用get请求时走这个方法
    //自定义序列化器，这个就是内部类
    public static class MySerializer extends JsonSerializer<Book>
    {

        @Override
        public void serialize(Book book, JsonGenerator jsonGenerator,
                              SerializerProvider serializerProvider) throws IOException
        {
            //在该方法中完成自定义的序列化输出，将对象输出成 json 或者是 xml 字符串

            jsonGenerator.writeStartObject(); //输出 {  这个花括号 ， 输出对象用这个括号
            //jsonGenerator.writeStartArray();  //输出 [ 这个中括号  ， 输出数值用这个括号
            jsonGenerator.writeNumberField("id", book.getId());
            //将book对象的name属性，序列化为title 属性
            jsonGenerator.writeStringField("title", book.getName());
            jsonGenerator.writeNumberField("price", book.getPrice());
            jsonGenerator.writeStringField("author", book.getAuthor());
            //jsonGenerator.writeEndArray();   // 输出这个 ] 中括号
            jsonGenerator.writeEndObject();  //输出这个 } 花括号
        }
    }

    //postman 用post的请求访问到这个方法
    //自定义反序列化器，这个就是内部类
    public static class MyDeserializer extends JsonDeserializer<Book>
    {
        //这个方法负责反序列化，就是将 json 或者是 xml 字符串 恢复成对象
        @SneakyThrows
        @Override
        public Book deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException
        {

            Book book = new Book();

            //JsonToken采用顺序方式依次读取 JSON 或 XML 字符串中的每个 token
            //token：一个花括号也叫token，一个符号隔开一个内容就叫token
            JsonToken jsonToken = jsonParser.getCurrentToken();
            //只要这个 Json 或者 xml 字符串没有结束，都应该继续向下读取
            while (!jsonToken.equals(JsonToken.END_OBJECT))
            {
                //这个循环的作用，是去保证要找到代表 Field Name 的 Token
                //如果当前读取的Token 不是字段名
                if (!jsonToken.equals(JsonToken.FIELD_NAME))
                {
                    jsonToken = jsonParser.nextToken();//读取下一个token
                    continue;
                }
                //只要程序进到此处，就一定是读取到 field name 这种字段token
                //从 JSON 或者是 XML 字符串中读取得到的字段名，也就是Book 对象的属性名
                String fieldName = jsonParser.getCurrentName();
                //读取属性名之后，下一个Token就是属性值了
                JsonToken valueToken = jsonParser.nextToken();
                //获取当前token的值
                String value = jsonParser.getText();
                //对于要逻辑处理的属性，可以在这里进行判断处理
                if (fieldName.equals("title"))
                {
                    if (!value.startsWith("《"))
                    {
                        value = "《" + value;
                    }
                    if (!value.endsWith("》"))
                    {
                        value += "》";
                    }
                    //完成了对Book对象的name属性的设置
                    book.setName(value);
                } else if (fieldName.equals("price"))
                {
                    double price = Double.parseDouble(value);
                    //把从json或xml格式的价格数据拿出来，然后打折set进去
                    book.setPrice(price * 0.5);
                } else
                {
                    //对于其他属性，不需要额外处理的话，直接通过反射来调用Book对象的fieldName对应的setter方法
                    BeanUtils.getPropertyDescriptor(Book.class, fieldName)
                            .getWriteMethod()
                            .invoke(book, value);
                }
                //继续向下读取下一个 Token
                jsonToken = jsonParser.nextToken();
            }
            return book;
        }
    }

}

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.5</version>
    </parent>
    <groupId>cn.ljh</groupId>
    <artifactId>CustomSeDe</artifactId>
    <version>1.0.0</version>
    <name>CustomSeDe</name>
    <properties>
        <java.version>11</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- 添加 Jackson format XML , 用于对象与XML之间的转换 -->
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-xml</artifactId>
        </dependency>


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/995993.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

关于µC/OS-III 多任务的基本理解

关于µC/OS-III 多任务的基本理解

关于C/OS-III 多任务的基本理解 任务和任务管理是 RTOS 的核心&#xff0c;且大多数项目使用 RTOS 的目的就是为了使用 RTOS 的多任务管理能力。 C/OS-III作为经典的RTOS&#xff0c;了解并学习其任务管理机制&#xff0c;是非常有必要的。 文章目录 关于C/OS-III 多任务的基本…
阅读更多...
进阶C语言-指针的进阶（中）

进阶C语言-指针的进阶（中）

指针的进阶 &#x1f4d6;5.函数指针&#x1f4d6;6.函数指针数组&#x1f4d6;7.指向函数指针数组的指针&#x1f4d6;8.回调函数 &#x1f4d6;5.函数指针 数组指针 - 指向数组的指针 - 存放的是数组的地址 - &数组名就是数组的地址。 函数指针 - 指向函数的指针 - 存放的…
阅读更多...
【Java】session的工作原理

【Java】session的工作原理

文章目录 一、session的概念及特点session概念session主要有以下的这些特点 二、为什么要使用session三、session的工作原理四、session的生命周期Session何时生效Session何时失效 五、session的性能瓶颈六、session实现登录状态的控制 一、session的概念及特点 session概念 …
阅读更多...
无涯教程-JavaScript - COUPDAYSNC函数

无涯教程-JavaScript - COUPDAYSNC函数

描述 COUPDAYSNC函数返回从结算日期到下一个息票日期的天数。 语法 COUPDAYSNC (settlement, maturity, frequency, [basis])争论 Argument描述Required/OptionalSettlement 证券的结算日期。 证券结算日期是指在发行日期之后将证券交易给买方的日期。 RequiredMaturity 证…
阅读更多...
基于第二代 ChatGLM2-6B P-Tuning v2 微调训练医疗问答任务

基于第二代 ChatGLM2-6B P-Tuning v2 微调训练医疗问答任务

今天是教师节&#xff0c;恭祝全体老师们节日快乐&#xff01;&#x1f60a; 一、ChatGLM2-6B 在本专栏前面文章中实验了使用 ChatYuan-large-v2 Freeze 微调训练医疗问答任务&#xff0c;训练后效果整体还可以&#xff0c;这篇文章继续探索使用最近比较火的 ChatGLM 官方推出…
阅读更多...
docker镜像详解

docker镜像详解

目录 什么是docker镜像镜像相关命令docker pulldocker imagesdocker searchdocker rmi导出 / 导入镜像 镜像分层镜像摘要镜像摘要的作用分发散列值 什么是docker镜像 Docker镜像是Docker容器的基础组件&#xff0c;它包含了运行一个应用程序所需的一切&#xff0c;包括代码、运…
阅读更多...
Sharding-Jdbc（2）：Sharding-Jdbc入门案例

Sharding-Jdbc（2）：Sharding-Jdbc入门案例

1 前置条件 搭建读写分离的数据库环境，搭建方法如下文，目标数据库test Mysql性能优化（5）：主从同步原理与实现_mysql主从配置优化_不死鸟.亚历山大.狼崽子的博客-CSDN博客 2 新建maven项目 3 pom引入依赖 <?xml version="1.0" encoding="UTF-8"…
阅读更多...
《protobuf》基础语法2

《protobuf》基础语法2

文章目录 枚举类型ANY 类型oneof 类型map 类型改进通讯录实例 枚举类型 protobuf里有枚举类型&#xff0c;定义如下 enum PhoneType {string home_addr 0;string work_addr 1; }同message一样&#xff0c;可分为 嵌套定义&#xff0c;文件内定义&#xff0c;文件外定义。不…
阅读更多...
二维码智慧门牌管理系统：智能化地址管理，提升社会治理效率

二维码智慧门牌管理系统：智能化地址管理，提升社会治理效率

文章目录 前言一、地址管理挑战二、二维码智慧门牌管理系统解决方案 前言 随着科技的飞速发展&#xff0c;我们的生活正经历前所未有的变革。尤其是智能化技术&#xff0c;已经深刻影响了我们的日常生活和工作环境。然而&#xff0c;在某些领域&#xff0c;如地址管理和社会治…
阅读更多...
十大免费好用的视频软件推荐，新手小白必备

十大免费好用的视频软件推荐，新手小白必备

很多人都在使用视频软件进行编辑&#xff0c;那么你们知道哪些视频软件是免费的而且还好用&#xff1f; 现在很多小伙伴比较喜欢用手机编辑视频&#xff0c;而这些剪辑软件具有领先的智能化AI技术&#xff0c;让你不用绿幕就能一键挖出图像&#xff0c;不仅可以一键挖出三维人…
阅读更多...
获取板块分类并展示

获取板块分类并展示

板块分类也会变动&#xff0c;偶尔看下&#xff0c;利于总体分析大盘 https:dapanyuntu.com/ 该网站含有板块信息 分析接口 搜素关键字 拷贝curl到curl解析工具&#xff0c;去掉无用的参数&#xff0c;生成requests代码 尝试nginx反代接口 server {listen 443;loca…
阅读更多...
汇率失守7.3关口

汇率失守7.3关口

号外&#xff1a;9.8教链内参《被判入狱1万年》。 拉锯多时的离岸人民币汇率USDCNH失守7.3关口&#xff0c;隔夜冲破7.36的高位。 为什么7.3是一个关键关口&#xff1f;因为这里是2022年10月底、11月初时曾经测试过的支撑位&#xff08;从CNH的角度说&#xff09;。 如果支撑位…
阅读更多...
微信视频号挂公众号文章链接新方法：不限次数，不限号

微信视频号挂公众号文章链接新方法：不限次数，不限号

当看到自己身边的人&#xff0c;通过我分享的方法绑定成功&#xff0c;那是开心到起飞了。 因为我知道&#xff1a;外面不靠谱的人很多&#xff01;分享不靠谱方法的人&#xff0c;可谓是更多。 为什么我要主动分享视频号评论区挂公众号文章链接&#xff1f;总有人伸张正义&a…
阅读更多...
java中log使用总结

java中log使用总结

目录 一、概述1.1. 核心日志框架1.2 门面日志框架 二、最佳实践2.1 核心日志框架API包2.2 门面日志框架依赖2.3 集成使用2.3.1 集成jcl2.3.2 集成slf4j2.3.2.1 slf4j集成单一框架2.3.2.2 slf4j整合混合框架 三、总结3.1 所有相关包3.1.1 核心日志框架包3.1.2 门面日志框架3.1.3…
阅读更多...
Python元类（metaclass）

Python元类（metaclass）

Python 是一种强大的编程语言&#xff0c;一部分得益于其语言设计中独特的元类&#xff08;Metaclass&#xff09;机制。尽管元类的概念在刚开始接触时可能会让人感到困惑&#xff0c;但一旦理解了它们的工作原理和应用方式&#xff0c;我们就可以用它们做出强大且灵活的抽象。…
阅读更多...
无涯教程-JavaScript - COUPDAYS函数

无涯教程-JavaScript - COUPDAYS函数

描述 COUPDAYS函数返回包含结算日期的息票期限内的天数。 语法 COUPDAYS (settlement, maturity, frequency, [basis])争论 Argument描述Required/OptionalSettlement 证券的结算日期。 证券结算日期是指在发行日期之后将证券交易给买方的日期。 RequiredMaturity 证券的到…
阅读更多...
Nginx重写功能

Nginx重写功能

Nginx重写功能 一、Nginx常见模块二、访问路由location2.1location常用正则表达式2.2、location的分类2.3、location常用的匹配规则2.4、location优先级排列说明2.5、location示例2.6、location优先级总结2.7、实例2.7.1、location/{}与location/{}2.7.2、location/index.html{…
阅读更多...
joplin更新后找不到文章

joplin更新后找不到文章

Joplin的数据默认是存储在C:\Users\Username.config\joplin-desktop下的。我修改为了D:\joplinnotes 这样就导致在升级覆盖安装的时候&#xff0c;笔记丢失路径。如果记不起之前笔记保存在哪里&#xff0c;也可以搜索类似文件来回忆之前自己保存笔记的位置 cache\ plugins\ re…
阅读更多...
黑马JVM总结（三）

黑马JVM总结（三）

&#xff08;1&#xff09;栈内存溢出 方法的递归调用&#xff0c;没有设置正确的结束条件&#xff0c;栈会有用完的一天&#xff0c;导致栈内存溢出 可以修改栈的大小&#xff1a; 再次运行&#xff1a;减少了次数 案例二&#xff1a; 两个类的循环应用问题&#xff0c;导致Js…
阅读更多...
注解生效激活（idea）

注解生效激活（idea）

File---------settings-----------Build,Execution,Deployment-----------Compiler------- Annotation Processors
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023