Controller层自定义注解拦截request请求校验

news2025/1/8 5:45:23

一、背景

笔者工作中遇到一个需求，需要开发一个注解，放在controller层的类或者方法上，用以校验请求参数中(不管是url还是body体内，都要检查，有token参数，且符合校验规则就放行)是否传了一个token的参数，并且token符合一定的生成规则，符合就不予拦截，放行请求，否则拦截请求。

用法如下图所示

可以看到 @TokenCheck 注解既可以放在类上，也可以放在方法上 ，放在类上则对该类中的所有的方法进行拦截校验。

注意：是加了注解才会校验是否拦截，不加没有影响。

整个代码都是使用的最新springboot版本开发的，所以servlet相关的类都是使用jakarta

如果你的springboot版本比较老 ，请使用javax

先引入以下依赖(javax不飘红不用引入)

<dependency>

      <groupId>javax.servlet</groupId>

      <artifactId>javax.servlet-api</artifactId>

      <version>4.0.1</version>

      <scope>provided</scope>

</dependency>

 

我用到的第三方依赖

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version>
</dependency>
<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.8.24</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>6.0.11</version>
</dependency>

二、TokenCheck注解

package com.example.demo.interceptorToken;
 
import java.lang.annotation.*;
 
/**
 * 是否有token
 */
@Documented
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface TokenCheck {
}

三、请求包装器RequestWrapper

主要是对request请求包装下，因为拦截器会拦截request，会读取其中的参数流，而流只能读一次，后续再用到流的读取会报错，所以用一个包装器类处理下，把流以字节形式读出来，重写了getInputStream()，后续可以重复使用。

package com.example.demo.interceptorToken;

import jakarta.servlet.ReadListener;
import jakarta.servlet.ServletInputStream;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletRequestWrapper;
import org.apache.commons.lang3.StringUtils;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;

/**
 * @author hulei
 * @date 2024/1/11 19:48
 * @Description 由于 request中getReader()和getInputStream()只能调用一次 导致在Controller @ResponseBody的时候获取不到 null 或 Stream closed
 * 在项目中，可能会出现需要针对接口参数进行校验等问题
 * 构建可重复读取inputStream的request
 */
public class RequestWrapper extends HttpServletRequestWrapper {
    // 将流保存下来
    private final byte[] requestBody;

    public RequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        requestBody = readBytes(request.getReader());
    }

    @Override
    public ServletInputStream getInputStream() {

        final ByteArrayInputStream basic = new ByteArrayInputStream((requestBody != null && requestBody.length >0) ? requestBody : new byte[]{});

        return new ServletInputStream() {

            @Override
            public int read() {
                return basic.read();
            }

            @Override
            public boolean isFinished() {
                return false;
            }

            @Override
            public boolean isReady() {
                return false;
            }

            @Override
            public void setReadListener(ReadListener readListener) {

            }
        };
    }

    @Override
    public BufferedReader getReader() {
        return new BufferedReader(new InputStreamReader(getInputStream()));
    }

    /**
     * 通过BufferedReader和字符编码集转换成byte数组
     */
    private byte[] readBytes(BufferedReader br) throws IOException {
        String str;
        StringBuilder retStr = new StringBuilder();
        while ((str = br.readLine()) != null) {
            retStr.append(str);
        }
        if (StringUtils.isNotBlank(retStr.toString())) {
            return retStr.toString().getBytes(StandardCharsets.UTF_8);
        }
        return null;
    }
}

四、过滤器RequestFilter

自定义请求过滤器，把请求用自定义的包装器RequestWrapper包装下，往调用下文传递，也是为了让request请求的流能多次读取

package com.example.demo.interceptorToken;
import jakarta.servlet.*;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.NonNull;
import org.springframework.core.annotation.Order;
import org.springframework.web.filter.OncePerRequestFilter;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.multipart.support.StandardServletMultipartResolver;
import java.io.IOException;

/**
 * @author hulei
 * @date 2024/1/11 19:48
 * 自定义请求过滤器
 */
//排序优先级,最先执行的过滤器
@Order(0)
public class RequestFilter extends OncePerRequestFilter {

    //spring6.0版本后删除了CommonsMultipartResolver,使用StandardServletMultipartResolver
    //如果是spring6.0版本,此行代码不报错请使用如下
    // private CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
    private final StandardServletMultipartResolver multipartResolver = new StandardServletMultipartResolver();
    /**
     *
     */
    @Override
    protected void doFilterInternal(@NonNull HttpServletRequest request, @NonNull HttpServletResponse response, @NonNull FilterChain filterChain) throws ServletException, IOException {
        //请求参数有form_data的话，防止request.getHeaders()报已使用,单独处理
        if (request.getContentType().contains("multipart/form-data")) {
            MultipartHttpServletRequest multiReq = multipartResolver.resolveMultipart(request);
            filterChain.doFilter(multiReq, response);
        }else{
            ServletRequest requestWrapper;
            requestWrapper = new RequestWrapper(request);
            filterChain.doFilter(requestWrapper, response);
        }
    }

}

五、请求过滤器配置类TokenFilterConfig

这个很好理解，把自定义配置类注入spring容器

package com.example.demo.interceptorToken;

import jakarta.servlet.Filter;
import jakarta.servlet.FilterConfig;
import jakarta.servlet.ServletContext;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.Enumeration;


/**
 * @author hulei
 * @date 2024/1/11 19:48
 * 将过滤器注入spring容器中
 */
@Configuration
public class TokenFilterConfig implements FilterConfig {
    @Bean
    Filter bodyFilter() {
        return new RequestFilter();
    }

    @Bean
    public FilterRegistrationBean<RequestFilter> filters() {
        FilterRegistrationBean<RequestFilter> filterRegistrationBean = new FilterRegistrationBean<>();
        filterRegistrationBean.setFilter((RequestFilter) bodyFilter());
        filterRegistrationBean.addUrlPatterns("/*");
        filterRegistrationBean.setName("requestFilter");
        //多个filter的时候order的数值越小 则优先级越高
        //filterRegistrationBean.setOrder(0);
        return filterRegistrationBean;
    }

    @Override
    public String getFilterName() {
        return null;
    }

    @Override
    public ServletContext getServletContext() {
        return null;
    }

    @Override
    public String getInitParameter(String s) {
        return null;
    }

    @Override
    public Enumeration<String> getInitParameterNames() {
        return null;
    }
}

 六、核心类RequestInterceptor拦截器

注意如果你的springboot版本也是低于3.0，请继承HandlerInterceptorAdapter类，实现其中方法，基本不用改动类中的内容，只需要 把implements HandlerInterceptor 改为extends HandlerInterceptorAdapter即可。

package com.example.demo.interceptorToken;

import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import jakarta.servlet.ServletInputStream;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.NonNull;
import org.apache.commons.lang3.StringUtils;
import org.springframework.util.StreamUtils;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.multipart.support.StandardServletMultipartResolver;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Method;
import java.net.URLDecoder;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * @author hulei
 * @date 2024/1/11 19:48
 * 自定义请求拦截器(spring boot 3.0以下的版本,需要继承HandlerInterceptorAdapter类,de方法)
 */

public class RequestInterceptor implements HandlerInterceptor {

    /**
     * 需要从请求里验证的关键字参数名
     */
    private static final String TOKEN_STR = "token";

    /**
     * 进入拦截的方法前触发
     * 这里主要从打了注解请求中查找有没有token关键字,并且token的值是否符合一定的生成规则,是就放行,不是就拦截
     */
    @Override
    public boolean preHandle(@NonNull HttpServletRequest request,@NonNull HttpServletResponse response,@NonNull Object handler) throws Exception {
        if(handler instanceof HandlerMethod handlerMethod){
            //获取token注解
            TokenCheck tokenCheck = getTokenCheck(handlerMethod);
            //请求参数有form_data的话，防止request.getHeaders()或request.getInputStream()报已使用错误,单独处理
            if( request.getContentType() != null && request.getContentType().contains("multipart/form-data")){
                //判断当前注解是否存在
                if(tokenCheck != null){
                    final StandardServletMultipartResolver multipartResolver = new StandardServletMultipartResolver();
                    MultipartHttpServletRequest multipartHttpServletRequest = multipartResolver.resolveMultipart(request);
                    //获取全部参数,不管是params里的还是form_data里的
                    //Map<String,String[]> bodyParam = multipartHttpServletRequest.getParameterMap();
                    //直接获取token参数
                    String token = multipartHttpServletRequest.getParameter(TOKEN_STR);
                    if(!StringUtils.isEmpty(token)){
                        boolean tokenRuleValidation = tokenRuleValidation(token);
                        if(!tokenRuleValidation){
                            returnJson(response, "token校验失败");
                            return false;
                        }
                        return true;
                    }
                    returnJson(response, "token校验失败");
                    return false;
                }
            }else{
                //判断当前注解是否存在
                if (tokenCheck != null) {
                    // 获取请求方式
                    //String requestMethod = request.getMethod();
                    // 获取请求参数
                    Map<String,String> paramMap;
                    //token关键字,分别是来自url的token或者来自body中的token
                    String tokenFromUrl,tokenFromBody = "";
                    request = new RequestWrapper(request);
                    String bodyParamsStr = this.getPostParam(request);
                    tokenFromBody = getTokenFromBody(bodyParamsStr,tokenFromBody);
                    paramMap = getUrlQueryMap(request);
                    tokenFromUrl = paramMap.get(TOKEN_STR);
                    if(tokenRuleValidation(tokenFromUrl)|| tokenRuleValidation(tokenFromBody)){
                        return true;
                    }else {
                        returnJson(response, "token校验失败");
                        return false;
                    }
                }
            }
            return true;
        }
        return true;
    }

    private static TokenCheck getTokenCheck(HandlerMethod handler) {
        Method method = handler.getMethod();
        //获取方法所属的类,并获取类上的@TokenCheck注解
        Class<?> clazz = method.getDeclaringClass();
        TokenCheck tokenCheck = null;
        if(clazz.isAnnotationPresent(TokenCheck.class)){
            tokenCheck = clazz.getAnnotation(TokenCheck.class);
        }
        //类上没有注解,则从方法上再获取@TokenCheck
        tokenCheck = tokenCheck == null ? method.getAnnotation(TokenCheck.class) : tokenCheck;
        return tokenCheck;
    }

    /**
     * 从请求体获取token参数
     */
    private String getTokenFromBody(String bodyParamsStr,String tokenFromBody){
        //判断是否是json数组
        boolean isJsonArray = JSONUtil.isTypeJSONArray(bodyParamsStr);
        if(!isJsonArray){
            tokenFromBody = JSONUtil.parseObj(bodyParamsStr).getStr(TOKEN_STR);
        }else{
            JSONArray jsonArray = JSONUtil.parseArray(bodyParamsStr);
            Set<String> tokenSet = new HashSet<>();
            for (int i = 0; i < jsonArray.size(); i++) {
                JSONObject jsonObject = jsonArray.getJSONObject(i);
                if(StringUtils.isNotEmpty(jsonObject.getStr(TOKEN_STR))){
                    tokenSet.add(jsonObject.getStr(TOKEN_STR));
                }
            }
            if(!tokenSet.isEmpty()){
                tokenFromBody = tokenSet.stream().filter(this::tokenRuleValidation).findFirst().orElse("");
            }
        }
        return tokenFromBody;
    }

    /**
     * token 规则校验
     * @param token token关键字
     */
    private boolean tokenRuleValidation(String token){
        return "AAABBB".equals(token);

    }

    /**
     * 如果是get请求,则把url中的请求参数获取到,转换为map
     */
    public static Map<String, String> getUrlQueryMap(HttpServletRequest request) throws UnsupportedEncodingException {
        //获取当前请求的编码方式,用于参数value解码
        String encoding = request.getCharacterEncoding();
        String urlQueryString = request.getQueryString();
        Map<String, String> queryMap = new HashMap<>();
        String[] arrSplit;
        if (urlQueryString == null) {
            return queryMap;
        } else {
            //每个键值为一组
            arrSplit = urlQueryString.split("&");
            for (String strSplit : arrSplit) {
                String[] arrSplitEqual = strSplit.split("=");
                //解析出键值
                if (arrSplitEqual.length > 1) {
                    queryMap.put(arrSplitEqual[0],URLDecoder.decode(arrSplitEqual[1], encoding));
                } else {
                    if (!"".equals(arrSplitEqual[0])) {
                        queryMap.put(arrSplitEqual[0], "");
                    }
                }
            }
        }
        return queryMap;
    }

    /**
     * 离开拦截的方法后触发
     */
    @Override
    public void postHandle(@NonNull HttpServletRequest request,@NonNull HttpServletResponse response,@NonNull Object handler, ModelAndView modelAndView) {

    }

    /**
     * 返回
     */
    private void returnJson(HttpServletResponse response, String json) throws IOException {
        response.setCharacterEncoding("UTF-8");
        response.setContentType("text/html; charset=utf-8");
        try (PrintWriter writer = response.getWriter()) {
            writer.print(json);
        }
    }

    private String getPostParam(HttpServletRequest request) throws Exception{
        RequestWrapper readerWrapper = new RequestWrapper(request);
        return StringUtils.isEmpty(getBodyParams(readerWrapper.getInputStream(), request.getCharacterEncoding())) ?
                "{}":getBodyParams(readerWrapper.getInputStream(), request.getCharacterEncoding());
    }

    /**
     * 获取POST、PUT、DELETE请求中Body参数
     *
     */
    private String getBodyParams(ServletInputStream inputStream, String charset) throws Exception {
        String body = StreamUtils.copyToString(inputStream, Charset.forName(charset));
        if (StringUtils.isEmpty(body)) {
            return "";
        }
        return body;
    }
}

七、拦截器注册InterceptorRegister

一个配置类，把自定义的拦截器注入spring

package com.example.demo.interceptorToken;

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;

/**
 * @author hulei
 * @date 2024/1/11 19:48
 * 将拦截注入spring容器
 */
@Configuration
public class InterceptorRegister implements WebMvcConfigurer {

    @Bean
    public RequestInterceptor tokenInterceptor() {
        return new RequestInterceptor();
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(tokenInterceptor());
    }
}

 八、总结

本例主要是自定义注解，完成请求参数的拦截校验，实际中可根据需求进行修改，如记录日志，拦截校验其他参数，修改RequestInterceptor中的拦截前方法和拦截后方法的逻辑即可

gitee地址: Token-Check-Demo: 自定义注解拦截request请求

注: 创作不易，转载请标明原作地址

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

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

相关文章

旧衣回收小程序搭建：降低企业成本，提高回收效率！

旧衣回收小程序搭建：降低企业成本，提高回收效率！

在人们环保意识提升下&#xff0c;旧衣回收行业受到了大众的关注&#xff0c;同时旧衣回收具有门槛低、利润大的优势。在我国&#xff0c;回收行业不仅帮助普通人就业获利&#xff0c;还对环保做出了较大贡献。因此&#xff0c;旧衣回收行业成为了当下的热门商业模式&#xff0…
阅读更多...
C#，入门教程(19)——循环语句（for，while，foreach）的基础知识

C#，入门教程(19)——循环语句（for，while，foreach）的基础知识

上一篇&#xff1a; C#&#xff0c;入门教程(18)——分支语句&#xff08;switch-case&#xff09;的基础知识https://blog.csdn.net/beijinghorn/article/details/124039953 一、for循环 当老师进入教室&#xff0c;从门口开始分别按行、列点名&#xff0c;看看哪位翘课&…
阅读更多...
详细介绍如何使用T5实现文本摘要：微调和构建 Gradio 应用程序-含完整源码

详细介绍如何使用T5实现文本摘要：微调和构建 Gradio 应用程序-含完整源码

对高效文本摘要的需求从未如此迫切。无论您是正在处理冗长研究论文的学生还是浏览新闻文章的专业人士，快速提取关键见解的能力都是非常宝贵的。T5 是一种因多项 NLP 任务而闻名的预训练语言模型，擅长文本摘要。使用 T5 的文本摘要与 Hugging Face API 是无缝的。然而，对 T5 …
阅读更多...
二、基础篇 vue计算属性和侦听器

二、基础篇 vue计算属性和侦听器

计算属性 模板内的表达式非常便利&#xff0c;但是设计它们的初衷是用于简单运算的。在模板中放入太多的逻辑会让模板过重且难以维护。例如&#xff1a; <div id"example">{{ message.split().reverse().join() }} </div> 在这个地方&#xff0c;模板不…
阅读更多...
【松叶漫话】来聊聊ChatGPT 和文心一言吧

【松叶漫话】来聊聊ChatGPT 和文心一言吧

两大AI助手的较量 在当今信息技术飞速发展的时代&#xff0c;人工智能助手成为我们生活中不可或缺的一部分。ChatGPT和文心一言作为两大代表性的AI助手&#xff0c;在智能回复、语言准确性、知识库丰富度等方面各有千秋。本文将就这两位AI助手的特点进行深入比较&#xff0c;为…
阅读更多...
深入解析多目标优化技术：理论、实践与优化

深入解析多目标优化技术：理论、实践与优化

本文深入探讨了多目标优化技术及其在机器学习和深度学习中的应用&#xff0c;特别聚焦于遗传算法的原理和实践应用。我们从多目标优化的基础概念、常见算法、以及面临的挑战入手&#xff0c;进而详细介绍遗传算法的工作原理、Python代码实现&#xff0c;以及如何应用于实际的机…
阅读更多...
Java中常用的加密算法及其实现原理详解

Java中常用的加密算法及其实现原理详解

目录 1、前言 2、对称加密算法 2.1 对称加密算法的工作原理 2.2 DES、AES、RC4算法的原理及其在Java中的实现 2.3 对称加密算法的优缺点 3、非对称加密算法 3.1 非对称加密算法的工作原理 3.2 RSA、DSA算法的原理及其在Java中的实现 3.3 非对称加密算法的优缺点 4、散…
阅读更多...
AI工具推荐：开源TTS（文本生成语音）模型集合

AI工具推荐：开源TTS（文本生成语音）模型集合

XTTS TTS是一个语音生成模型&#xff0c;可以通过一个简短的6秒音频片段将声音克隆到不同的语言。它不需要大量的训练数据&#xff0c;也不需要耗费大量时间。TTS支持17种语言&#xff0c;可以进行声音克隆、情感和风格转移、跨语言声音克隆以及多语言语音生成等功能。XTTS-v2…
阅读更多...
chatgpt实用技巧之二反问式提示

chatgpt实用技巧之二反问式提示

大家好&#xff0c;今天跟大家讲实用gpt的小技巧二、反问式提示 有时候不知道怎么给 GPT 提示词&#xff0c;这时候&#xff0c;就可以反问 GPT 如何更好地给提示词。如图片所示 更详细内容可以看下这篇&#xff1a; 按照 GPT 给出的&#xff1a;故事设定角色故事发展主题结局…
阅读更多...
SSM框架学习笔记04 | SpringMVC

SSM框架学习笔记04 | SpringMVC

文章目录 一、SpringMVC简介二、 请求与响应1. 请求映射路径2. get请求与post请求3. 响应 二、REST风格1.简介 三、 SSM整合四、拦截器1. 定义拦截器2.配置拦截器3.拦截器执行顺序4.拦截器参数5.多个连接器工作流程分析6.拦截器链的运行顺序 一、SpringMVC简介 SpringMVC技术与…
阅读更多...
锐意进取，蓬勃发展｜爱基百客2023全景图

锐意进取，蓬勃发展｜爱基百客2023全景图

岁序更迭&#xff0c;2023年已悄然离去。对我们来说&#xff0c;这是充满挑战与机遇的一年。爱基百客作为一家专注于测序服务的公司&#xff0c;我们在这一年里经历了许多挑战&#xff0c;也取得了令人鼓舞的成绩。前面我们盘点了表观产品和单细胞产品&#xff0c;今天再邀您回…
阅读更多...
判断交叉编译工具是否支持C++20的标准

判断交叉编译工具是否支持C++20的标准

写个任意的测试程序hello_world 执行 arm-linux-gnueabihf-g -stdc14 main.cpp arm-linux-gnueabihf-g -stdc17 main.cpp arm-linux-gnueabihf-g -stdc20 main.cpp没报错则代表支持&#xff0c;报错则不支持.
阅读更多...
ChatGPT写论文最强指令

ChatGPT写论文最强指令

一、我正在寻找与&#xff08;XX主题&#xff09;相关的高质量学术资源&#xff0c;包括期刊文章、会议论文和研究报告。希望能获取这些文献的摘要和关键词&#xff0c;以便快速评估其相关性。同时&#xff0c;请根据文献的相关度或发布日期进行排序&#xff0c;并提供完整的引…
阅读更多...
Unity 编辑器篇|（六）编辑器拓展EditorGUI类 （全面总结 | 建议收藏）

Unity 编辑器篇|（六）编辑器拓展EditorGUI类 （全面总结 | 建议收藏）

目录 1. 前言2. 参数3. 功能3.1 折叠菜单&#xff1a; Foldout3.2 检查 GUI 更改&#xff1a; BeginChangeCheck 、EndChangeCheck 监听值改变3.3 可禁用控件&#xff1a;BeginDisabledGroup 、EndDisabledGroup 是否禁用组中的控件3.4 下拉菜单&#xff1a;DropdownButton3.5 …
阅读更多...
MySQL 查询数据

MySQL 查询数据

今天介绍一下 MySQL 数据库使用 SELECT 语句来查询数据。 语法 首先&#xff0c;介绍一下语法。以下为在 MySQL 数据库中查询数据通用的 SELECT 语法&#xff1a; SELECT column1, column2, ... FROM table_name [WHERE condition] [ORDER BY column_name [ASC | DESC]] [LI…
阅读更多...
图解基础排序算法（冒泡、插入、选择）（山东大学实验二）

图解基础排序算法（冒泡、插入、选择）（山东大学实验二）

目录 ⚽前言&#xff1a; &#x1f3d0; 冒泡排序&#xff1a; 设定&#xff1a; 分类&#xff1a; 起源&#xff1a; 图解冒泡&#xff1a; 图中绿色&#xff1a; 图中橙色&#xff1a; 整体思路&#xff1a; 交换思路&#xff1a; 核心代码&#xff1a; &#x…
阅读更多...
怎么在桌面查看备忘录新的提醒事项?方法教程

怎么在桌面查看备忘录新的提醒事项?方法教程

在这个信息爆炸的时代&#xff0c;我们每天都面临着无数的任务和提醒。作为一名忙碌的职场人&#xff0c;我经常需要依赖备忘录来记录重要的待办事项&#xff0c;以免遗漏。备忘录&#xff0c;就像我生活中的小助手&#xff0c;帮我记下工作会议、生日提醒、购物清单等等&#…
阅读更多...
2.3数据链路层02

2.3数据链路层02

2.3 数据链路层 2.3.5 以太网 1、以太网概念 以太网是一种计算机局域网技术。IEEE&#xff08;电气与电子工程师协会&#xff1a;Institute of Electrical and Electronics Engineers&#xff09;组织的IEEE802.3标准制定了以太网的技术标准&#xff0c;它规定了包括物理层的…
阅读更多...
matlab行操作快？还是列操作快？

matlab行操作快？还是列操作快？

在MATLAB中&#xff0c;通常情况下&#xff0c;对矩阵的列进行操作比对行进行操作更有效率。这是因为MATLAB中内存是按列存储的&#xff0c;因此按列访问数据会更加连续&#xff0c;从而提高访问速度。 一、实例代码 以下是一个简单的测试代码&#xff0c; % 测试矩阵大小 ma…
阅读更多...
RK3566RK3568安卓11隐藏状态栏带接口

RK3566RK3568安卓11隐藏状态栏带接口

文章目录 前言一、创建全局变量二、设置应用添加隐藏导航栏按钮三、添加按钮功能四、动态隐藏还有显示功能五、创建系统导航栏广播接口总结 前言 关于Android系统的状态栏&#xff0c;不同的客户有不同的需求: 有些客户需要永久隐藏状态栏&#xff0c;有些客户需要在设置显示中…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023