Python之Class按照某个元素排序

Python之Class按照某个元素排序

文章目录


下边是一个例子，对Departs列表中的元素（均为Department类型）按照’id’，'name’两个属性排序（优先级依次减弱） 

import operator  # 导入operator 包,pip install operator

Departs = []  # 待排序列表


class Department:  # 自定义的元素
    def __init__(self, id, name, id2):
        self.id = id
        self.name = name
        self.id2 = id2


# 创建元素和加入列表
Departs.append(Department(1, 'cbc', '1'))
Departs.append(Department(2, 'acd', '4'))
Departs.append(Department(3, 'bcd', '1'))
Departs.append(Department(1, 'bcd', '1'))
Departs.append(Department(2, 'acd', '3'))

# 划重点#划重点#划重点----排序操作
cmpfun = operator.attrgetter('id2')  # 参数为排序依据的属性，可以有多个，这里优先id，使用时按需求改换参数即可
Departs.sort(key=cmpfun)  # 使用时改变列表名即可
# 划重点#划重点#划重点----排序操作

# 此时Departs已经变成排好序的状态了，排序按照id优先，其次是name，遍历输出查看结果
for depart in Departs:
    print(str(depart.id) + depart.name + depart.id2)

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

解释都在注释中，输出结果为：

在这里插入图片描述

可以看到

1.列表已经改变；

2.id和name都相同的两个部门的先后顺序未改变，说明该排序算法具有稳定性

一般性方法：

1.首先导入operator包，pip install operator

2.关键操作为定义cmpfun 和使用.sort，即：

cmpfun = operator.attrgetter(‘a’,‘b’) #这里是希望按照a，b两个属性排序，且优先按照a属性，使用时更换参数即可。

list.sort(key=cmpfun)#list为待排序列表

优先按照a属性，使用时更换参数即可。

list.sort(key=cmpfun)#list为待排序列表

《AUTOSAR谱系分解(ETAS工具链)》之总目录

id="article_content" class="article_content clearfix"> id="content_views" class="markdown_views prism-atom-one-dark">

在SpringBoot中实现一个拦截器（HandlerInterceptor），用于获取请求的入参并将其转化为 Java 对象。

方式一：拦截器配合过滤器

1. 设计思路

在 Web 开发中，当 HTTP 请求发送到服务器时，Spring 会通过一个链条处理这个请求，这个链条包括很多组件，比如：拦截器（HandlerInterceptor）、过滤器（Filter）、控制器（Controller）、参数解析器（比如 Spring MVC 的 @RequestParam 或 @RequestBody 等注解）等。

输入流的问题

当客户端通过 POST 请求发送数据时，数据通常是包含在请求体中的（比如表单数据或者 JSON 数据）。Spring 的 HttpServletRequest 提供了 getInputStream() 方法来读取请求体中的数据。

问题： HttpServletRequest.getInputStream() 只能读取一次。也就是说，当你在拦截器中调用了 getInputStream() 读取数据时，流就被消费掉了，后续的组件（例如，Spring 的参数解析器）再调用 getInputStream() 就无法读取到数据了，因为流已经被关闭了。

解决方案

解决这个问题的思路是：在拦截器中读取请求体的数据时，不直接从 HttpServletRequest 中读取，而是通过包装（HttpServletRequestWrapper）的方式，重新实现 getInputStream()，将读取的数据缓存下来，确保后续的处理链依然能够访问到请求体的内容。

2. 如何实现

  1. 创建一个 HttpServletRequestWrapper 类：它将重写 getInputStream() 方法，让流的数据可以多次读取。通过这个类缓存请求体的内容。
  2. 创建一个 Filter：用于包装请求，将 HttpServletRequest 包装成我们自己的 HttpServletRequestWrapper。
  3. 在拦截器中获取请求体：在 HandlerInterceptor 中获取请求体并进行解析。

3. 实现步骤

3.1 创建 HttpServletRequestWrapper

这个类主要作用是缓存请求体内容，并且重写 getInputStream()，让它能够多次读取。

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

public class CachedBodyHttpServletRequestWrapper extends HttpServletRequestWrapper {

    private byte[] requestBody;

    public CachedBodyHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        // 从 InputStream 读取数据，缓存请求体内容
        InputStream inputStream = request.getInputStream();
        this.requestBody = inputStream.readAllBytes();  // 将流中的数据读取到字节数组中
    }

    @Override
    public InputStream getInputStream() throws IOException {
        // 返回缓存的数据
        return new ByteArrayInputStream(requestBody);
    }

    public byte[] getRequestBody() {
        return requestBody;
    }
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
class="hide-preCode-box">
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

3.2 创建 Filter 以包装 HttpServletRequest

这个过滤器的作用是将原始的 HttpServletRequest 替换为我们自定义的 CachedBodyHttpServletRequestWrapper。

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

@WebFilter("/*")  // 这个过滤器会拦截所有请求
public class RequestWrapperFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 初始化操作
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        // 仅对 HttpServletRequest 进行包装
        if (request instanceof HttpServletRequest) {
            CachedBodyHttpServletRequestWrapper wrappedRequest =
                    new CachedBodyHttpServletRequestWrapper((HttpServletRequest) request);
            // 将包装后的请求传递给下一个过滤器
            chain.doFilter(wrappedRequest, response);
        } else {
            // 对非 HttpServletRequest 请求不做任何处理
            chain.doFilter(request, response);
        }
    }

    @Override
    public void destroy() {
        // 销毁操作
    }
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
class="hide-preCode-box">

3.3 创建拦截器 HandlerInterceptor 以处理请求参数

接下来，在 Spring 的拦截器中获取请求体并解析成 Java 对象。这个拦截器将会在请求进入控制器之前进行拦截。

import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class RequestBodyInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws IOException {
        if (request instanceof CachedBodyHttpServletRequestWrapper) {
            // 获取包装后的请求体
            CachedBodyHttpServletRequestWrapper wrappedRequest = (CachedBodyHttpServletRequestWrapper) request;
            String requestBody = new String(wrappedRequest.getRequestBody(), "UTF-8");
            // 打印或处理请求体内容
            System.out.println("Request Body: " + requestBody);

            // 将请求体转换成 Java 对象
            MyRequestObject myRequestObject = new ObjectMapper().readValue(requestBody, MyRequestObject.class);
            System.out.println("Parsed Java Object: " + myRequestObject);
        }

        return true; // 返回 true，表示继续处理请求
    }
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
class="hide-preCode-box">

3.4 注册拦截器和过滤器

import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FilterConfig {

    @Bean
    public FilterRegistrationBean<RequestWrapperFilter> loggingFilter() {
        FilterRegistrationBean<RequestWrapperFilter> registrationBean = new FilterRegistrationBean<>();
        registrationBean.setFilter(new RequestWrapperFilter());
        registrationBean.addUrlPatterns("/api/*");  // 这里根据需要配置拦截的 URL
        return registrationBean;
    }
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    private RequestBodyInterceptor requestBodyInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(requestBodyInterceptor).addPathPatterns("/api/*");  // 根据需要配置路径
    }
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}"> class="hide-preCode-box">

4. 总结

通过以上步骤，你可以实现一个能够多次读取 HttpServletRequest.getInputStream() 数据的机制。基本思路是：

这样，无论在拦截器还是后续的参数解析过程中，都会能够多次访问请求体数据。

方式二：拦截器中使用包装类ContentCachingRequestWrapper

在 HTTP 请求中，HttpServletRequest 的请求体（POST 请求中的 JSON 数据）是一次性的流，读取完一次之后，如果没有特殊处理，就不能再次读取它。

ContentCachingRequestWrapper 是 Spring 框架提供的一个包装类，它的作用是“包装”原始的 HttpServletRequest 对象，使得请求体内容可以被多次读取。

使用ContentCachingRequestWrapper ，省去方法一中创建的 HttpServletRequestWrapper和RequestWrapperFilter。

import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class RequestBodyInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws IOException {
		if (HttpMethod.POST.matches(request.getMethod())) {
 			// 包装请求，使其可以多次读取请求体
            ContentCachingRequestWrapper wrappedRequest = new ContentCachingRequestWrapper(request);

			// 读取请求体，明确指定字符编码为 UTF-8
			String requestBody = new String(wrappedRequest.getContentAsByteArray(), "UTF-8");

            // 打印或处理请求体内容
            System.out.println("Request Body: " + requestBody);

            // 将请求体转换成 Java 对象
            MyRequestObject myRequestObject = new ObjectMapper().readValue(requestBody, MyRequestObject.class);
            System.out.println("Parsed Java Object: " + myRequestObject);
        }

        return true; // 返回 true，表示继续处理请求
    }
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}"> class="hide-preCode-box">

总结

ContentCachingRequestWrapper 是一种非常有用的工具，允许缓存并多次读取请求体内容，尤其需要在拦截器中处理请求体数据时，它非常有效。

data-report-view="{"mod":"1585297308_001","spm":"1001.2101.3001.6548","dest":"https://blog.csdn.net/m0_69893292/article/details/144973960","extend1":"pc","ab":"new"}">>
注：本文转载自blog.csdn.net的PlutoZuo的文章"https://blog.csdn.net/PlutoZuo/article/details/134259279"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！