Heck's Blog

管理是平衡的艺术，也是实践的艺术。

一家公司想要做大事，就必须有一套非常高效的协作机制。

一个组织，成员们能够召之即来、来之能战、战则必胜，其背后必然存在一条核心管理执行原则：

凡事有交代，件件有着落，事事有回音。

组织成员中，每个人都扛着自己的责任往前走，并愿意把后背交给彼此。

那么，作为一个管理者，要如何做到，让团队成员践行这一条核心原则呢?　

一定要理解，并达成共识。

也许你比对手有更多的用户，更好的技术，更多的资本，但是，如果你没有一支有效协作的团队，所有优势都无法发挥作用。

一切都无从谈起。

---

凡事有交代

什么叫“凡事有交代”？

有次和办公室的同学们开会。

我讲完后说：

你们的责任，就是让我从这一秒钟开始，把这件事给完全忘了。

这就是我对你们的要求。

什么意思？

责任，不是我们一起计划10件事情，然后你去做。这不叫责任。

因为再聪明，想得再全面，也一定至少有20件事，是我们没想到的。

这样的话，我就要时时想，我们忘了什么没有？我们忘了什么没有？

这时，你没有承担起责任。

责任到底是什么？

责任，不是对那些想到的事负责。

责任，是对那些“没想到的事”负责。

一个人最大的能力，就是让人放心。　　

不需要你有多大的能力，你需要让我知道，你的能力边界和行动进度。

让老板信任，公司重用，投资人放心的一个最基本品质，是可靠。

你的手机一定要能找到你，切忌不接不回。

你的行为一定要基本稳定，切忌变化多端。

你的承诺一定要次次兑现，切忌大话无为。

可靠是一种“钝品质”，要如鼎一样稳重，需要“看得见，摸得着，信得起”。

任何一件事情，只要被提出来，就永远不能消失。

这件事情的结束方式只能有两种，第一种是被完成，第二种是被发起者取消。

如果一件事情交代下去，没有人问就渐渐消失了，那么组织的协作机制就是失效的。

凡事有交代的本质，就是给任何事情扣上闭环，有开始就必须有结束，避免石沉大海。

你需要理解，生命中的一切事情，本质上都是一个项目。

而项目管理中，第一个关键要素，就是：

循环。

既然是有头有尾的事情，就要：“用循环解决问题”。

循环过程分为5个步骤：

启动、计划、执行、控制、收尾。

1）何谓启动？

这事儿值不值得干？我们要不要干？需要哪些人？需要多少钱？

2）何谓计划？

这事怎么干？投入多少时间？谁负责什么事？什么时间节点完成什么结果？资金怎么分配？资源怎么调配？时间怎么分配？任务怎么分配？

3）何谓执行？

既然分配了，那就按照公司战略完善高效执行下去，不要眼高手低。

4）何谓控制？

谁在负责这件事情？做的进展如何？达成目标了吗？按照进度跟进了吗？

5）何谓收尾？

无论成败与否，我们来复盘一下有什么经验？什么教训？

这5个步骤，构成完整循环，且缺一不可。

凡事有交代的背后，是一组严密执行的步骤。

---

件件有着落

我们在工作中夸奖一个人，常常会说：

这人靠谱。办事能落地。

人狠话不多，招招见血，刺中项目管理的要害。

什么叫能落地？

在工作中，你会发现有的人聊起事情来，口若悬河，特别有激情，但就是上不了手，纸上谈兵。

做事毫无章法，没有丝毫策略意识。

嘴上挥师百万，实际战场逃兵。

从外部看一件事，和真正上手做一件事，体感是完全不同的。

如果一个创业者不停的说“我”，我想怎么样，我计划怎么样，我打算怎么样，我认为怎么样，我要怎么着，眼里只有“我”的视角，其实非常危险。

因为“想象世界”和“真实用户世界”往往相差千万里。

很多事情你没有干过，只是坐在那评论的时候，你觉得别人这有问题，那有问题，应该这么干，那么干。

但是当你亲自上手的时候，会发现，你在外边观察这个事时，只看到10个点，而实际做起来，可能面临的是100个点。

剩下90个。

你，根本就没有想到过。

对于别人的工作，对于别的行业，不要随意评判对错，随意给批评。

认为我随便做做，都比你做的好。

随便换一个人，都能快速碾压你的业绩。

你要知道，每个看似愚蠢的决定背后，都是无数复杂的妥协和平衡。

每个行业里，真正专业的力量，是外行无法理解的。

在校运会上卖过零食的，总觉得自己洞察零售。

有一两个拿手菜的，总觉得自己可以开餐厅。

看到别人做自媒体，觉得写字，这谁不会？

对于没有亲自俯身经营的事情，要时刻保持谦卑，时刻保持敬畏。

哪怕是一份特别简单的工作，也需要常怀敬畏之心。

因为，实际做起来，永远都会有我们从来没有想到过的情况发生。

那么，在执行目标的时候发现有困难怎么办？

你应该及早意识到这些困难，然后主动去找资源，想办法解决。

这就需要你快速从100个点里，分辨出哪些点是最重要的，我应该从哪个入手，我应该运用哪些资源，我应该如何去做，然后马上做起来。

在组织前进的过程中，有目标，就一定有通往目标路上的障碍。

遇到障碍后，焦虑，是正常的。

但是一个成熟的人，能快速走出焦虑，专注于解决问题的方法。

目标常常是两难的。既要，又要。

这就需要迅速从焦虑中走出来，不是往后退，不是恐惧变化。

而是必须把全部的心思，放在搬走石头，解决问题上。

一件事，在没有做之前，谁也不知道能不能成。

碰到一个新事物或者不懂的问题，怎么办？

先去试。

遇到问题，解决问题。

尝试失败了怎么办？

即使失败了，也尽了最大努力，把所有可以尝试的方法穷尽了一遍。

这就叫做：

件件有着落。

---

事事有回音　

什么叫事事有回音？

我举个例子。

将军派一个团在凌晨3点前必须攻下某个山头。

在凌晨3点前攻下某个山头，这就是将军给这个团的团长定下的目标。

那你说，对于团长来说，在凌晨3点攻下还是在凌晨5点攻下，有区别吗？

如果是在凌晨5点攻下，那不也算完成了任务吗？反正我把山头攻下来了对吧？

听上去好像没什么毛病。

但是，团长可能不知道的是，将军让他在凌晨3点前攻下，是因为凌晨3点半大部队要通过这个山头。

如果他凌晨3点前攻不下，那大部队就无法通过。

所以，如果团长私自改了目标，凌晨5点才攻下山头，那将军的整个计划就被打乱了。

对于一个组织来说，所有的目标，都是为了更高层面的协作。

一个大目标，是无数个小目标聚合起来的。

而定目标，就是为了形成一个分布式协作网络。

定目标，意味着团队成员把后背交给了彼此。

所以，给每一个人定下目标，这是一个组织能够协作的前提。

如果一个管理者，在布置执行任务的时候，需要时刻来问：

有没有遇见问题？

怎么回事，这么长时间都没给我消息？

现在进度怎么样了？

这时，你没有做到事事有回音。

---

最后的话

管理是平衡的艺术，也是实践的艺术。

凡事有交代，件件有着落，事事有回音。

每个组织成员都深刻理解、并愿意认真践行这条原则。

团队才会形成一个高效的协作网络。

每个人都扛着自己的责任往前走，并把后背交给彼此。

真正做到召之即来、来之能战、战则必胜

在使用Vue3、TypeScript和ElementUIPlus构建前端时，遇到上传表单数据为[objectObject]且后端SpringBoot报错的情况。通过排查发现前端代码中的`file`对象需要将`raw`属性值作为上传内容，解决了`MissingServletRequestPartException`。

项目场景：
前端：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('导入成功')
    })

配置证书
打开CMD输入命令：

keytool -genkey -alias heck -keyalg RSA -keysize 2048 -storetype PKCS12 -keystore heck-ssl-key.p12 -validity 3650

证书会下载到当前目录下：
server:
  port: 443
  ssl:
    # 证书的路径，可用绝对路径，如果放到项目资源文件路径需要添加 classpath:
    key-store: classpath:heck-ssl-key.p12
    key-store-password: 123456
    key-store-type: PKCS12


可能还会报异常DerInputStream.getLength(): lengthTag=111, too big.  
Could not load key store 'classpath:heck-ssl-key.p12'：


可以pom.xml 把这个文件加入编译，

<plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>3.2.0</version>
                <configuration>
                    <nonFilteredFileExtensions>
                        <!--<nonFilteredFileExtension>p12</nonFilteredFileExtension>-->
                        <nonFilteredFileExtension>jks</nonFilteredFileExtension>
                    </nonFilteredFileExtensions>
                </configuration>
            </plugin>
        </plugins>

刷新 Maven，clean 后重新 compile。

一、简介
        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~-_.

Linxu开机出现 Generating "/run/initramfs/rdsosreport.txt"解决方案


解决：
一、找这个-root结尾的文件也不一样。

大家可以用ls /dev/mapper查看到自己装的镜像对应的以-root结尾的文件是哪个。


二、所以我们运行的是：xfs_repair /dev/mapper/cl-root

还是报错的话需要

需要卸载掉 （会丢数据，没办法，总比重做系统方便吧）

提示如下，无法正常激活：

我们无法在此设备上激活Windows，因为无法连接到你的组织的激活服务器。请确保已连接到你的组织的网络，然后重试。
如果仍存在激活问题，请联系组织的支持人员。
错误代码:0x8007007B


解决方法：
1、左下角搜索 cmd ，以管理员身份运行：



2、 输入以下命令，回车

slmgr /skms kms.03k.org


3、再输入以下命令，回车，再去激活一般就没有问题了

slmgr /ato

注意：如果笔记本遇到这种插了网线网络正常，但是显示没网的情况，要连下WiFi，否则可能激活不成功

我正在使用旧版Spring应用程序，并且想要迁移到Spring Boot。我的意图是使用spring-boot-starter-data- jpa。因此，我在pom.xml（管理所有spring-boot-dependencies）中添加了以下部分：

<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使用所需的版本。

IDEA的Service窗口误删服务(也就是点到了Hide Configuration选项)后如何恢复

看下到底是做了什么操作导致的服务被隐藏  (赶时间直接到最后看解决方案就行)
正常情况下, 在开启窗口的情况下, 会显示我们所有的微服务启动类, 如下图



idea在service窗口中显示多个服务如下：在这里插入图片描述
.idea > workspace.xml 中找到 RunDashboard 替换成如下


  <component name="RunDashboard">
    <option name="configurationTypes">
      <set>
        <option value="SpringBootApplicationConfigurationType" />
      </set>
    </option>
    <option name="ruleStates">
      <list>
        <RuleState>
          <option name="name" value="ConfigurationTypeDashboardGroupingRule" />
        </RuleState>
        <RuleState>
          <option name="name" value="StatusDashboardGroupingRule" />
        </RuleState>
      </list>
    </option>
  </component>

在SpringBoot中使用单元测试时，出现以下报错，意思是创建名为‘serverEndpointExporter’的bean时出错。
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)

前后端通过websocket通信，但是需要鉴权，可以利用websocket的子协议来传输token，代码如下：
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);