https://www.heckjj.com/index.php zh-cn https://www.heckjj.com/post/680/ Heck <@hecks.tk> Mon, 02 Feb 2026 05:14:32 +0000 https://www.heckjj.com/post/680/
如何命名变量（以及其他事物）

我们不用内存地址而使用名称的原因是：名称更容易记忆。更重要的是，它们能提供更多关于变量的信息，以便其他人理解其意义。

找到一个好的名字可能需要一些时间，但这将在未来为你和你的团队节省更多时间。而且我确信大多数读者都遇到过这种情况：几个月后再次访问自己的代码时，很难理解之前做了什么。


如何创建有意义的名字
不要用注释来解释变量的用途。如果一个名字需要注释，那么你应该花时间重命名那个变量，而不是写注释。

差：

var d; // elapsed time in days
我见过这种代码无数次。人们普遍认为应该用注释来隐藏代码的混乱，但这是一种常见的误解。除非有充分理由，否则不要使用 x、y、a 或 b 等字母作为变量名（循环变量除外）。

好：

var elapsedTimeInDays;
var daysSinceCreation;
var daysSinceModification;
这些名称要好得多。它们告诉你被测量的内容以及该测量的单位。



避免错误信息
注意那些有特定含义的词语。除非其类型确实是 List，否则不要将一组账户称为 accountList。这个词有特定的含义，可能会导致错误的结论。

即使类型是列表，accounts 也是一个更简单、更好的名称。

差：

var accountList = [];
好：

var accounts = [];


避免噪音词
噪声词是指那些不提供任何关于变量额外信息的词。它们是冗余的，应该被删除。

一些常见的噪声词有：

The (prefix)

Info

Data

Variable

Object

Manager

如果你的类名是 UserInfo，你只需去掉 Info，直接用 User。将类名用 BookData 代替 Book 是毋庸置疑的，因为类本来就是为了存储数据而存在的。


使用发音友好的名称
如果你不会读一个名字，讨论它时就会显得很愚蠢。

差：

const yyyymmdstr = moment().format("YYYY/MM/DD");
好：

const currentDate = moment().format("YYYY/MM/DD");


使用可搜索的名称
避免在代码中使用魔法数字。选择可搜索的、命名的常量。不要为常量使用单个字母的名称，因为它们可能出现在很多地方，因此不易搜索。

差：

if (student.classes.length < 7) {
   // Do something
}
好：

if (student.classes.length < MAX_CLASSES_PER_STUDENT) {
    // Do something
}
这样更好，因为 MAX_CLASSES_PER_STUDENT 可以在代码的许多地方使用。如果将来需要将其改为 6，我们只需更改常量即可。

糟糕的例子会在读者脑海中产生疑问，比如 7 的重要性是什么？

你也应该使用你语言的常量命名和声明约定，例如 Java 中的 private static final 或 JavaScript 中的 const。


保持一致性
遵循每个概念用一个词的规则。不要在不同的类中对同一操作使用 fetch、retrieve 和 get。选择其中一个并在整个项目中统一使用，这样维护代码库的人员或你的 API 客户可以轻松找到他们正在寻找的方法。



如何编写函数
保持它们简短
函数应该很小，真的很小。它们很少会是 20 行长。一个函数越长，它就越可能做很多事情并产生副作用。



确保它们只做一件事
你的函数应该只做一件事情。如果你遵循这个规则，它们一定会很小。函数所做的一切都应该体现在它的名字中。

有时候很难从函数名来判断它是否做了多件事情。一个很好的检查方法是尝试提取一个具有不同名字的另一个函数。如果你能找到，那就意味着它应该是一个不同的函数。

这可能是本文中最重要的概念，需要一些时间来适应。但一旦你掌握了它，你的代码看起来会更加成熟，而且肯定会更容易重构、理解和测试。



将条件语句封装在函数中
重构条件并将其放入命名函数中是使你的条件语句更易读的好方法。

这是我从学校项目里的一段代码。这段代码负责在 Connect4 游戏的棋盘上插入芯片。

isValidInsertion 方法负责检查列号的有效性，让我们可以专注于插入芯片的逻辑。

public void insertChipAt(int column) throws Exception {
    if (isValidInsertion(column)) {
        insertChip(column);
        boardConfiguration += column;
        currentPlayer = currentPlayer == Chip.RED ? Chip.YELLOW : Chip.RED;
    } else {
        if (!columnExistsAt(column))
            throw new IllegalArgumentException();
        else if (isColumnFull(column - 1) || getWinner() != Chip.NONE)
            throw new RuntimeException();
    }
}
如果你感兴趣，这里是 isValidInsertion 的代码。

  private boolean isValidInsertion(int column) {
    boolean columnIsAvailable = column <= NUM_COLUMNS && column >= 1 && numberOfItemsInColumn[column - 1] < NUM_ROWS;
    boolean gameIsOver = getWinner() != Chip.NONE;
    return columnIsAvailable && !gameIsOver;
}
如果没有方法，if 条件将如下所示：

if (column <= NUM_COLUMNS
&& column >= 1
&& numberOfItemsInColumn[column - 1] < NUM_ROWS
&& getWinner() != Chip.NONE)
恶心，对吧？我同意。



减少参数
函数应该有两个或更少的参数，越少越好。尽量避免有三个或更多参数。

参数使得函数更难阅读和理解。从测试的角度来看，它们甚至更难，因为它们需要为每个参数组合编写测试用例。



不要使用标志参数
标志参数是一个传递给函数的布尔值参数。根据这个参数的值，会采取两种不同的操作。

例如，假设有一个负责预订音乐会门票的函数，并且有两种类型的用户：高级和普通。你可以编写如下代码：

public Booking book (Customer aCustomer, boolean isPremium) {
  if(isPremium)
   // logic for premium book
  else
   // logic for regular booking
}
标志参数天然地违背了单一职责原则。当你看到它们时，应该考虑将函数拆分成两个。



不要有副作用
副作用是你的代码的意外后果。它们可能是改变传递的参数，在按引用传递的情况下，或者可能改变一个全局变量。

关键点在于，它们承诺做另一件事，你需要仔细阅读代码才能注意到副作用。它们可能导致一些棘手的错误。

public class UserValidator {
  private Cryptographer cryptographer;
  public boolean checkPassword(String userName, String password) {
    User user = UserGateway.findByName(userName);
    if (user != User.NULL) {
      String codedPhrase = user.getPhraseEncodedByPassword();
      String phrase = cryptographer.decrypt(codedPhrase, password);
      if ("Valid Password".equals(phrase)) {
        Session.initialize();
        return true;
      }
    }
    return false;
  }
}
你能看到这个函数的副作用吗？

它在检查密码，但当密码有效时，它还会初始化会话，这是一个副作用。

你可以将函数的名称改为类似 checkPasswordAndInitializeSession，以使这种效果显式化。但当你这样做时，你应该注意到你的函数实际上在处理两件事，你不应该在这里初始化会话。



不要重复自己
代码重复可能是软件中所有邪恶的根源。重复的代码意味着在逻辑发生变化时需要在多个地方进行修改，而且非常容易出错。

使用你的 IDE 的重构功能，每当遇到重复的代码片段时，提取一个方法。



其他
不要在代码注释中留下代码
请勿如此。这一点很严重，因为看到代码的其他人会因为不知道它是否有什么用而不敢删除它。那些被注释掉的代码会停留很长时间。然后当变量名或方法名改变时，它变得无关紧要，但仍然没有人删除它。

干脆删除它。即使它很重要，也有版本控制可以找回。



了解你语言的规范
你应该了解你语言在空格、注释和命名方面的规范。许多语言都有可用的风格指南。

例如，你应该在 Java 中使用 camelCase，但在 Python 中使用 snake_case。在 C#中，你应该将开括号放在新行，但在 Java 和 JavaScript 中，你应该将它们放在同一行。

这些事情因语言而异，没有统一的标准。


结论
编写干净代码并非一蹴而就的技能，它是一种需要时刻牢记这些原则并在编写代码时加以应用的习惯。

感谢您抽出时间阅读，希望对您有所帮助。 ]]> https://www.heckjj.com/post/670/ Heck <@hecks.tk> Fri, 20 Dec 2024 03:31:08 +0000 https://www.heckjj.com/post/670/
项目场景：
前端：Vue3 + ts + antdv
后端：springboot


打印的file：
发现file内部还有一个raw属性，我们要上传的是这个raw里面的内容

解决方案：
更改前端代码如下：

const file = uploadFileList.value[i];
    formData2.append('file', toRaw(file.raw));
    formData2.append('parentAdcode', formData.parentAdcode);
    importObjects(formData2).then(res=>{
      this.$message.success('导入成功')
    }) ]]> https://www.heckjj.com/post/668/ Heck <@hecks.tk> Tue, 05 Nov 2024 02:18:56 +0000 https://www.heckjj.com/post/668/         RESTful API 是应用程序接口 (API) 的一种架构风格，它使用 HTTP 请求来访问和使用数据。该数据可用于 GET、PUT、POST 和 DELETE 数据类型，这些数据类型是指有关资源的操作的读取、更新、创建和删除。

        RESTful API（也称为 RESTful Web 服务或 REST API）基于表示状态传输 (REST)，它是一种架构风格和经常用于 Web 服务开发的通信方法。

二、设计原则。
URL即资源，使用名词表示资源
接口应直观、简洁、风格命名保持一致
必须版本化，具有足够的灵活性来支持上层UI
三、RFC3986标准。
        RFC3986标准，简单讲就是规定了如下：除了 数字 + 字母 + -_.~ 不会被转义，其他字符都会被以百分号（%）后跟两位十六进制数 %{hex} 的方式进行转义。

         www 的 post form data 也就是 x-www-form-urlencode 的编码规则：除 -_.（没有 ~） 之外的所有 非字母、非数字 的字符都将被替换成 百分号（%）后跟两位十六进制数 %{hex}，空格（注意）则编码为加号 +。

        RFC3986对 ~ 不做转码，x-www-form-urlencode 对 ~ 做转码 %7E。

        RFC3986对 空格 转为 %20，x-www-form-urlencode 对 空格 转为 +。

        JS的URL编码方式：encodeURIComponent。

// encodeURIComponent
console.log(encodeURIComponent("hello233 ~-_."))
hello233%20~-_.

四、URI、URL和URN


         URI（Uniform Resource Identifier ）：统一资源标识符，就是在某一规则下能把一个资源独一无二地标识出来。

        URL（Uniform Resource Locator）：统一资源定位符。

        URN（Uniform Resource Name）：统一资源名称。

        URI可以分为URL,URN或同时具备locators 和names特性的一个东西。URN作用就好像一个人的名字，URL就像一个人的地址。换句话说：URN确定了东西的身份，URL提供了找到它的方式。

        URL是URI的子集, 除了确定一个资源,还提供一种定位该资源的主要访问机制(如其网络“位置”)。例如： http://或 ftp://.。

        当我们替代web地址的时候，URI和URL那个更准确？
        URI更准确。

        我们经常使用的URI不是严格技术意义上的URL。例如：你需要的文件在files.hp.com. 这是URI，但不是URL--系统可能会对很多协议和端口都做出正确的反应。http://files.hp.com 和ftp://files.hp.com可能得到完全不同的内容。这种情况可能更加普遍，想想不同谷歌域名上的不同服务啊。所以，用URI吧，这样你通常技术上是正确的，URL可不一定。

五、设计规范。
1.版本号
        应该将API的版本号放入URL。 版本号以字符'v'开头，比如：v1

http://demo.com/cuc/sever/v1
2.路径(Endpoint)
        接口路径，也称为端点(Endpoint)，代表一种资源的访问地址。

        ①使用名词表示资源，使用HTTP Method 描述操作
                因为"资源"表示一种实体，所以应该是名词，URL不应该有动词，动词应该放在HTTP协议中，CRUD的操作不要体现在URL中。

                 反面教材：

查询员工 GET     /v1/findEmployee?id=1000  
新增员工 POST    /v1/addEmployee
更新员工 POST    /v1/updateEmployee?id=1000
删除员工 POST    /v1/deleteEmployee?id=1000
                 正确实例：

查询员工 GET     /v1/employee/1000  
新增员工 POST    /v1/employee
更新员工 PUT     /v1/employee/1000
删除员工 DELETE  /v1/employee/1000
        ② 资源既可以是单个，也可以是一个集合，比如：user是单个资源，users是集合资源。 由于英文名词的复数规则众多，为了保持接口命名的一致性，我们建议URL里描述集合资源的名词统一使用单数。
                反面示例：

查询单个员工 GET     /v1/employees/1000
查询一组员工 GET     /v1/employees
                正确示例：

查询单个员工 GET     /v1/employee/1000
查询一组员工 GET     /v1/employee
3.使用小写字母，多个单词用"-"分隔，提高URL的可读性
        RFC3986 定义了URI是大小写敏感的(除了scheme和host部分)，为了避免歧义，接口路径应尽量使用小写字母。

        对于由多个单词构成的路径，推荐使用'-'(hyphen)分隔，避免使用驼峰命名（camelCase）、下划线命名(snake_case)、首字母大写的驼峰命名（PascalCase），以提高可读性。

        例子：

camelCase  :  /v1/customer/1000/shippingAddress  [Bad]
snake_case :  /v1/customer/1000/shipping_address [Bad]
PascalCase :  /v1/customer/1000/ShippingAddress  [Bad]

hyphen     :  /v1/customer/1000/shipping-address [OK]
4.资源嵌套层次避免过深，尽量不超过2层
        定义REST接口时，通常使用资源嵌套（多级路径）来标识资源之间的关系，资源嵌套层次尽量不超过2层，否则很难阅读和使用。

        例子：

GET  /v1/user/1000/company    查询ID等于1000的用户的公司信息
GET  /v1/user/1000/company/10 查询ID等于1000的用户所属公司中ID=10的公司信息，嵌套两层
        反面例子：

GET /v1/company/10/department/20302/employee/10830
GET /v1/zoo/1/area/3/animal/4
六. 筛选(Filtering)、排序(Sorting)、分页(Pagination)、字段选择
  1.筛选（Filtering)
      接口URL尽量保持简短，对于集合资源不同纬度的筛选，可通过组合不同的Query Param来实现。

        反面案例：

GET /v1/externalEmployees
GET /v1/internalEmployees
GET /v1/internalAndSeniorEmployees
        正确案例：

GET /v1/employee?state=internal&title=senior
2.排序(Sorting)
        单个字段排序：

GET /v1/employee?sort=age&order=asc
GET /v1/employee?sort=age&order=desc
        多个字段排序：

        字段名前缀,'+'：表示升序，'-'：降序，多个字段名以逗号分隔

GET /v1/employee?sort=+age,-userName
3.分页(Pagination)
        对于数据量比较大的集合资源，接口实现一定要支持分页。

        常规分页有两个重要的参数：      

pageNo 获取那一页的记录，默认第一页。
pageSize 每页返回多少条数据，推荐默认值25，必须限定此参数的最大值。
        返回的资源列表为：[(pageNo-1)pageSize, pageNopageSize)

        请求示例：

GET /v1/employee?pageNo=8&pageSize=20&sort=age&order=desc
        返回值可以采用以下数据格式：

{  
    "pageSize":20,      // 页尺寸
    "pageNo":8,         // 页码
    "totalCount":182,  // 总记录数
    "pageList":[
                {
                    "id":13483,
                    "name":"Hehe",
                    "title":"senior"
                },
                 {
                    "id":13484,
                    "name":"haha",
                    "title":"junior"
                }
    ]
}

4.字段选择
        调用方可能只需要资源的少量属性，接口提供方可支持客户端通过请求参数fields来选择返回的字段，多个字段以逗号分隔，示例如下：

GET /v1/employee?fields=id,name,age&pageNo=1&pageSize=20&sort=age&order=desc ]]> https://www.heckjj.com/post/665/ Heck <@hecks.tk> Thu, 16 May 2024 14:21:17 +0000 https://www.heckjj.com/post/665/
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.3.RELEASE</version>
</parent>
但这搞砸了我暂时需要保留的某些依赖项。我目前正在使用Selenium依赖项（版本2.53.0；从另一个项目中过渡添加），但是spring-
boot正在获取的依赖项3.9.1。

我想排除3.9.1依赖关系，但exclusion过滤器无法按预期工作。

不能乱<excludes>然后尝试弄清楚您需要再次包含什么（在弄清楚要排除的内容之后）。只需覆盖《Spring
Boot参考指南》中此处解释的版本即可。

假设您将spring-boot-starter- parent用作父项，则只需将a添加<selenium.version>到您的<properties>部分中即可指定所需的版本。

<properties>
  <selenium.version>2.53.0</selenium.version>
</properties>
这将使Spring Boot使用所需的版本。 ]]> https://www.heckjj.com/post/663/ Heck <@hecks.tk> Tue, 02 Jan 2024 06:48:33 +0000 https://www.heckjj.com/post/663/ Error starting ApplicationContext. To display the conditions report re-run your application with 'debug' enabled.
[20240102 14:42:43][main][ERROR][org.springframework.boot.SpringApplication:854] Application run failed
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'serverEndpointExporter' defined in class path resource [com/nine/rivers/bms/system/config/WebSocketConfig.class]: Invocation of init method failed; nested exception is java.lang.IllegalStateException: javax.websocket.server.ServerContainer not available
  at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1804)
  at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:620)
  at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:542)
  at org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:335)
  at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:234)
  at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:333)
  at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:208)
  at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:953)
  at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:918)
  at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:583)
  at org.springframework.boot.SpringApplication.refresh(SpringApplication.java:765)
  at org.springframework.boot.SpringApplication.refreshContext(SpringApplication.java:445)
  at org.springframework.boot.SpringApplication.run(SpringApplication.java:338)
  at org.springframework.boot.test.context.SpringBootContextLoader.loadContext(SpringBootContextLoader.java:121)
  at org.springframework.test.context.cache.DefaultCacheAwareContextLoaderDelegate.loadContextInternal(DefaultCacheAwareContextLoaderDelegate.java:99)
  at org.springframework.test.context.cache.DefaultCacheAwareContextLoaderDelegate.loadContext(DefaultCacheAwareContextLoaderDelegate.java:124)
  at org.springframework.test.context.support.DefaultTestContext.getApplicationContext(DefaultTestContext.java:124)
  at org.springframework.test.context.web.ServletTestExecutionListener.setUpRequestContextIfNecessary(ServletTestExecutionListener.java:190)
  at org.springframework.test.context.web.ServletTestExecutionListener.prepareTestInstance(ServletTestExecutionListener.java:132)
  at org.springframework.test.context.TestContextManager.prepareTestInstance(TestContextManager.java:248)
  at org.springframework.test.context.junit.jupiter.SpringExtension.postProcessTestInstance(SpringExtension.java:138)
  at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.lambda$invokeTestInstancePostProcessors$6(ClassBasedTestDescriptor.java:350)
  at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.executeAndMaskThrowable(ClassBasedTestDescriptor.java:355)
  at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.lambda$invokeTestInstancePostProcessors$7(ClassBasedTestDescriptor.java:350)
  at java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:193)
  at java.util.stream.ReferencePipeline$2$1.accept(ReferencePipeline.java:175)
  at java.util.ArrayList$ArrayListSpliterator.forEachRemaining(ArrayList.java:1384)
  at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:482)
  at java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:472)
  at java.util.stream.StreamSpliterators$WrappingSpliterator.forEachRemaining(StreamSpliterators.java:312)
  at java.util.stream.Streams$ConcatSpliterator.forEachRemaining(Streams.java:743)
  at java.util.stream.Streams$ConcatSpliterator.forEachRemaining(Streams.java:742)
  at java.util.stream.ReferencePipeline$Head.forEach(ReferencePipeline.java:580)
  at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.invokeTestInstancePostProcessors(ClassBasedTestDescriptor.java:349)
  at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.lambda$instantiateAndPostProcessTestInstance$4(ClassBasedTestDescriptor.java:270)
  at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73)
  at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.instantiateAndPostProcessTestInstance(ClassBasedTestDescriptor.java:269)
  at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.lambda$testInstancesProvider$2(ClassBasedTestDescriptor.java:259)
  at java.util.Optional.orElseGet(Optional.java:267)
  at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.lambda$testInstancesProvider$3(ClassBasedTestDescriptor.java:258)
  at org.junit.jupiter.engine.execution.TestInstancesProvider.getTestInstances(TestInstancesProvider.java:31)
  at org.junit.jupiter.engine.descriptor.TestMethodTestDescriptor.lambda$prepare$0(TestMethodTestDescriptor.java:101)
  at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73)
  at org.junit.jupiter.engine.descriptor.TestMethodTestDescriptor.prepare(TestMethodTestDescriptor.java:100)
  at org.junit.jupiter.engine.descriptor.TestMethodTestDescriptor.prepare(TestMethodTestDescriptor.java:65)
  at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$prepare$1(NodeTestTask.java:111)
  at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73)
  at org.junit.platform.engine.support.hierarchical.NodeTestTask.prepare(NodeTestTask.java:111)
  at org.junit.platform.engine.support.hierarchical.NodeTestTask.execute(NodeTestTask.java:79)
  at java.util.ArrayList.forEach(ArrayList.java:1259)

问题分析
通过报错提示可以看出，在创建命名为 ‘serverEndpointExporter’ 的bean时出错，而这个bean是webscoket中的，而webscoket是需要依赖tomcat等容器才能启动的，恰巧运行单元测试不需要依赖tomcat容器，两者互相矛盾这就是出现该问题的原因了。

问题解决
使用tomcat容器运行单元测试，在注解 @SpringbootTest 中追加以下内容即可：
@SpringbootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
]]> https://www.heckjj.com/post/662/ Heck <@hecks.tk> Mon, 25 Dec 2023 06:28:45 +0000 https://www.heckjj.com/post/662/ var ws = new WebSocket("ws://localhost/ws",[token]);
在后面加上[这里是token内容]。这样请求头就会携带：
Sec-WebSocket-Protocol:token value
参数是一个数组。如果数组有多个值，后端也会接受到逗号隔开的值。
后端可以获取这个token进行鉴权。
重点来了！
如果传递了token参数，后端响应的时候，也必须带上这个token响应！否则前端接收不到数据！
我竟然忘记前端传过来的token是加密后的，首先解密后去校验，通过后再把原加密token放在响应头即可， 如果不一致也会导致前端接收不到消息。
如下是java的例子“：
HttpServletResponse response = (HttpServletResponse)servletResponse;
response.setHeader("Sec-WebSocket-Protocol", token); ]]> https://www.heckjj.com/post/660/ Heck <@hecks.tk> Tue, 19 Dec 2023 08:59:06 +0000 https://www.heckjj.com/post/660/
首先打开cmd，win键+r打开运行，输入cmd打开控制台。

在控制台中输入msg / server:IP地址 * "要发送的内容。"   注：(这里的引号要加，且*号左右必须空一格)

例如：我的ipv4地址是192.168.90.1**    注：(用ipconfig命令可查)



这样就可以了，试试吧。

]]> https://www.heckjj.com/post/651/ Heck <@hecks.tk> Mon, 17 Jul 2023 11:53:35 +0000 https://www.heckjj.com/post/651/
具体错误日志(参考)
undertow

java.nio.file.NoSuchFileException: /tmp/undertow.17753558642503713859.8085/undertow7370242804103803588upload

Tomcat

The temporary upload location [/tmp/tomcat.7957874575370093230.8088/work/Tomcat/localhost/ROOT] is not valid

重现方法
找到类 io.undertow.server.handlers.form.MultiPartParserDefinition
定位到如下代码

@Override
public void beginPart(final HeaderMap headers) {
    this.currentFileSize = 0;
    this.headers = headers;
    final String disposition = headers.getFirst(Headers.CONTENT_DISPOSITION);
    if (disposition != null) {
        if (disposition.startsWith("form-data")) {
            currentName = Headers.extractQuotedValueFromHeader(disposition, "name");
            fileName = Headers.extractQuotedValueFromHeaderWithEncoding(disposition, "filename");
            if (fileName != null && fileSizeThreshold == 0) {
                try {
                    if (tempFileLocation != null) {
                        file = Files.createTempFile(tempFileLocation, "undertow", "upload");
                    } else {
                        file = Files.createTempFile("undertow", "upload");
                    }
                    createdFiles.add(file);
                    fileChannel = FileChannel.open(file, StandardOpenOption.READ, StandardOpenOption.WRITE);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

在 createdFiles.add(file); 处打断点，复制file的 path 的值找到该文件并将其删除；放开断点，错误重现；

解决方案
方案1 (推荐)
在 applicaiton.yml(applicaiton.property) 中添加配置 ：spring.servlet.multipart.location
spring.servlet.multipart.location 底层就是 createMultipartConfig 中的 factory.setLocation ，见源码：org.springframework.boot.autoconfigure.web.servlet.MultipartProperties#createMultipartConfig

spring:
  servlet:
    multipart:
      location: /data/tmp

手动指定目录后，必须保证该目录存在，并由读写的权限
创建该目录 mkdir -p /data/tmp

方法二
使用配置类配置, 类似方案1

@Bean
public MultipartConfigElement multipartConfigElement() {
    MultipartConfigFactory factory = new MultipartConfigFactory();
    factory.setLocation(System.getProperty("/data/tmp"));
    return factory.createMultipartConfig();
}

方案三(不推荐)
手动创建临时目录

mkdir -p /tmp/undertow.17753558642503713859.8085/undertow7370242804103803588upload

方案四(不推荐)
修改系统配置，排除该临时目录

vim /usr/lib/tmpfiles.d/tmp.con
# 文件最后添加
x /tmp/undertow* ]]> https://www.heckjj.com/post/650/ Heck <@hecks.tk> Fri, 30 Jun 2023 15:54:14 +0000 https://www.heckjj.com/post/650/ 解决方法百度和测试很多，总结如下：

问题产生：
根据rfc规范，url中不允许有 |，{，}等特殊字符，但在实际生产中还是有些url有可能携带有这些字符，特别是|还是较为常见的。在tomcat升级到7以后，对url字符的检查都变严格了，如果出现这类字符，服务器tomcat将直接返回400状态码。

方法一：降低tomcat的版本
开发人员增加一项设置，允许配置在url可以出现的特殊字符，但也仅限于|，{，}三种，见：http://tomcat.apache.org/tomcat-8.0-doc/config/systemprops.html#Other
该项设置在以下版本的tomcat中有效：

- 8.5.x for 8.5.12 onwards

- 8.0.x for 8.0.42 onwards

- 7.0.x for 7.0.76 onwards
- 这个只是允许出现一些特殊字符，并没有说是全部特殊字符。
好像是tomcat7.9以上的版本,都不支持请求链接上带有特殊字符.否则会报400错误,
tomcat请求中包含特殊字符 [] | {} 发送get请求失败：
原因：
这是因为Tomcat严格按照 RFC 3986规范进行访问解析，而 RFC 3986规范定义了Url中只允许包含英文字母（a-zA-Z）、数字（0-9）、-_.~4个特殊字符以及所有保留字符(RFC3986中指定了以下字符为保留字符：! * ’ ( ) ; : @ & = + $ , / ? # [ ])。传入的参数中有"[]"、""不在RFC3986中的保留字段中，所以会报这个错。

方法二：修改server.xml
<Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" relaxedQueryChars="[]|{}^&#x5c;&#x60;&quot;&lt;&gt;" redirectPort="8443" />
方法三：修改server.xml（推荐方法）
在Host里加入：
<Valve className="org.apache.catalina.valves.ErrorReportValve"  showReport="false" showServerInfo="false" />
方法三 修改后只会显示出HTTP 400 错误，不会打印堆栈和tomcat版本号信息

关于方法三的解释：

HTTP状态代码提供有关请求的HTTP请求成功完成的信息。HTTP响应分为五个类，如下所示：

信息回应
成功的回应
重新导向
客户错误
服务器错误
在这里，我们的目的是使用HTTP响应代码处理HTTP请求时生成的错误/异常。您可以从HTTP状态代码信息中找到有关HTTP状态代码的更多详细信息。

该错误报告阀是一个错误处理程序，其处理错误状态代码与错误状态码或异常和服务器信息的信息错误页上相应地重定向用户。

该错误报告阀用于与Tomcat服务器编写自定义的错误报告处理功能。

在这里，我们将在Catalina（Tomcat）中创建自定义错误报告阀。错误报告阀用于报告错误/异常。因此，如果发生任何错误（例如404,400等），它将处理该错误并为我们提供默认的tomcat页面，如下所示（400错误请求的示例）。

在此上方，它将为您提供状态报告信息（HTTP状态）和服务器信息。因此，您可以在Tomcat服务器的conf 中使用server.xml对其进行配置。

默认的Catalina错误报告阀门和配置：org.apache.catalina.valves.ErrorReportValve

属性                描述
showReport  如果发生错误，用于在错误页面上显示错误信息（状态代码及其信息）的标志。默认值是true
showServerInfo  如果发生任何错误，则用于在错误页面上显示当前服务器信息的标志。默认值是true
现在，添加/更新以下内容以在 中的server.xml中进行配置。

<Valve className="org.apache.catalina.valves.ErrorReportValve" showReport="false" showServerInfo="false" />

现在，使用上述配置，您将发现以下内容。（仅HTTP状态代码）。


注意：同时禁用showServerInfo和showReport只会返回HTTP状态代码，并从默认响应中删除所有CSS。

参考地址：https://aspiresoftware.in/blog/catalinatomcat-custom-error-report-valve-to-handle-errors-exceptions/
]]> https://www.heckjj.com/post/642/ Heck <@hecks.tk> Wed, 22 Feb 2023 02:59:18 +0000 https://www.heckjj.com/post/642/ nginx在配置别名(Alias)的时候忘记加/，则可能实现目录穿越
配置中设置目录别名时/files配置为/home/的别名,那么当我们访问
/files…/时,nginx实际处理的路径时/home/…/,从而实现了穿越目录

location /file{
autoindex on;
alias /home/;
}

所以修复这个漏洞也就是将上面的/file/闭合成这样，就不支持../这些回上一层目录的操作了。 ]]>