前言

又是无聊的一天，逛GitHub的时候发现一个给女朋友做了一个互动微信小程序，据说女朋友更爱自己了，所以当晚。。。。给自己做了丰盛的晚餐，我当即点开立马开发粘贴复制起来，想到做的小程序可以和未来的女朋友增进感觉，越加猩粪。。。

回到正题，这个库有1.1k的star，推荐新人入坑原生小程序的可以学习

项目地址：github.com/UxxHans/Rai…

云开发情侣互动小程序（做任务，攒积分，换商品）

这是使用云开发能力构建的情侣互动小程序，可以跟女朋友互动哦，其中使用了云开发基础能力的使用：

• 数据库：对文档型数据库进行读写和管理


• 云函数：在云端运行的代码，开发者只需编写业务逻辑代码

使用逻辑

打个比方:

• 女朋友发布任务->女朋友来做任务->做完后由你来确认完成->女朋友收到积分


• 你发布商品(洗碗券)->女朋友使用积分购买->商品进入到女朋友的库存->女朋友拿着洗碗券叫你洗碗->你洗碗->女朋友将物品(洗碗券)标记为已使用(不可逆)


• 这样做的原因是 不想给任何一方能自说自话 增加自己或者对方积分的能力[点击完成任务的人不能是获得积分的人也不能是自己]

版本新增

• 将所有非云函数的云逻辑封装为云函数


• 新增了仓库系统，购买了的商品会存入仓库，然后再被使用


• 新增了搜索框，可以搜索物品和任务


• 新增了滑动窗，可以自动播放显示多张图片


• 新增了商品和任务预设，添加商品或任务可以使用预设，非常迅速


• 将新增按钮变为可拖拽的页面悬浮按钮


• 购买，上架，新建任务的时间都会被记录并显示


• 取消了点击左边圆圈来完成或者购买，统一改为左滑菜单


• 左滑菜单统一用图标显示，更加精简


• 使用特效升级了详细信息页面与添加页面的美观度


• 添加任务或物品界面积分文本框改为滑块


• 在商城添加了顶栏显示积分，更直观


• 使用表情符号简单的增加了美感

效果图与动画

部署方式

• 在这里注册小程序开发者: mp.weixin.qq.com/cgi-bin/wx


• 在这里登录开发者账号: mp.weixin.qq.com/

• 登录之后先在主页完成小程序信息和类目


• 然后可以在管理中的版本管理与成员管理中发布小程序体验版并邀请对象使用

• 随后可以在开发中的开发工具里下载微信开发者工具


• 打开微信开发工具->登录->导入我的文件夹-进入工具


• 在左上角五个选项中选择云开发->按照提示开通云开发(这里可以选择免费的，不过限量，我开发用的多，6块够用了)

• 进入后点击数据库->在集合名称添加四个集合：MarketList, MissionList, StorageList, UserList


• 之前使用过上一个版本的，需要清空所有数据，因为字段结构不一样

• 在UserList中添加两个默认记录, 在两个记录中分别添加两个字段:

字段 = _openid | 类型 = string | 值 = 先不填

字段 = credit | 类型 = number | 值 = 0

• 打开云开发的控制台的概览选项->复制环境ID


• 打开 miniprogram/envList.js 将内容全部替换成如下，注意替换环境ID

module.exports = {

  envList: [{

    envId:'上述步骤中你获得的环境ID (保留单引号)'

  }]

}

• 右键点击 cloudfunctions 中的每个文件夹并选择云函数云端安装依赖上传 (有点麻烦但是这是一定要做的)

• 如果云开发里面的云函数页面是这样的就是成功了

• 没有安装npm或者NodeJs, 需要先在这里安装: nodejs.org/dist/v16.15…


• 安装好的，就直接运行cloudfunctions/Install-WX-Server-SDK.bat


• 不成功的话可以在命令行输入 npm install --save wx-server-sdk@latest


• 然后创建体验版小程序->通过开发者账号分享到女朋友手机上(要先登录小程序开发者账号)


• 在两个手机上运行小程序->分别在两个手机上的小程序里新建任务


• 然后回到云开发控制台的missionlist数据库集合->找自己和女朋友的_openid变量并记录


• 把这两个记录下来的_openid拷贝到云开发控制台UserList数据集合里刚刚没填的_openid变量中


• 把这两个记录下来的_openid拷贝到miniprogram/app.js里的_openidA和_openidB的值里(A是卡比，B是瓦豆)


• 在miniprogram/app.js里把userA和userB改成自己和女朋友的名字


• 然后再试试看是不是成功了! (别忘了任务和物品左滑可以完成和购买)


• 消息提醒功能：


• 参考blog.csdn.net/hell_orld/a…allsobaiduend~default-2-110675777-null-null.142^v87^insert_down28v1,239^v2^insert_chatgpt&utm_term=%E5%BE%AE%E4%BF%A1%E5%B0%8F%E7%A8%8B%E5%BA%8F%E9%80%9A%E7%9F%A5%E4%BA%91%E5%BC%80%E5%8F%91&spm=1018.2226.3001.4187配置自己想要的模板\


• 在miniprogram/pages/MainPage/index.js和miniprogram/pages/MissionAdd/index.js里把模板号换成自己想要的模板号


• 在cloudfunctions/information/index.js里把UserA和UserB的openid值进行修改就能使用消息提醒功能了

• 别忘了最后点击右上角上传->然后在开发者账号上设置小程序为体验版->不用去发布去审核

• 最后如果有兴趣可以继续深入开发, 开发文档: developers.weixin.qq.com/miniprogram…

旧版效果图

一、背景

笔者前段时间开发了一款非常有意思的项目，已知在同一个局域网下有两款App分别运行在不同的设备上，业务上两款App分别具有不同的功能，同时两款App需要支持互相通信。后面我们称两款设备上的两款App一个为Server，一个为Client。

基于此我们需要考虑以下几点

• 如何发现对方


• 两款App如何通信


• 通信协议如何选择

二、发现对方

在局域网中查找识别我们可以基于DNS-SD协议。

1、DNS-SD协议介绍

DNS-SD（Domain Name System - Service Discovery）是一种用于在局域网（Local Area Network，LAN）中发现服务的协议。它使用DNS协议扩展了域名系统（Domain Name System，DNS）的功能，使得客户端能够在局域网中查找特定类型的服务，并获取有关该服务的信息。

在Android 中也有对应的Api可以使用：NsdManager。
NsdManager主要实现三个功能：

• 注册


• 发现


• 解析

其中一台设备作为服务端（即上面的Server App）通过NsdManager注册服务，提供自己的IP地址与端口号，同时可以提供用于标识自己的信息，例如设备ID。当一个局域网中有多台服务时，客户端在发现服务后，可以基于标识信息确认是否为自己需要找到的服务端。

另一台设备作为客户端（即上面的Client App），通过NsdManager的发现接口去发现服务。发现服务之后，再调用解析接口，获取到对应的信息，如服务端的IP地址、端口号、设备标识信息等。

详细的官方介绍地址：developer.android.com/reference/a…

2、注册

作为服务端的Server App，通过NsdManager注册。

NsdManager nsdManager = (NsdManager) context.getSystemService(Context.NSD_SERVICE);

NsdServiceInfo serviceInfo = new NsdServiceInfo();

serviceInfo.setServiceName(ServiceName);

serviceInfo.setServiceType(ServiceType);

int localPort = getLocalPort();

serviceInfo.setPort(localPort);

serviceInfo.setAttribute(Attribute_UUID, UuidManager.INSTANCE.getUUID());

String ipAddress = LocalIpUtils.getIPAddress();

serviceInfo.setAttribute(Attribute_IP, ipAddress);

nsdManager.registerService(serviceInfo, NsdManager.PROTOCOL_DNS_SD, new NsdManager.RegistrationListener() {

    @Override

    public void onRegistrationFailed(NsdServiceInfo nsdServiceInfo, int i) {

        //异常上报

    }



    @Override

    public void onUnregistrationFailed(NsdServiceInfo nsdServiceInfo, int i) {}



    @Override

    public void onServiceRegistered(NsdServiceInfo nsdServiceInfo) {

        //注册成功

    }



    @Override

    public void onServiceUnregistered(NsdServiceInfo nsdServiceInfo) {}

});

3、发现

Client App，调用NsdManager#discoverServices()接口去发现服务。

NsdManager nsdManager = (NsdManager) context.getSystemService(Context.NSD_SERVICE);

discoveryListener = new NsdManager.DiscoveryListener() {

    @Override

    public void onStartDiscoveryFailed(String s, int i) {}



    @Override

    public void onStopDiscoveryFailed(String s, int i) {}



    @Override

    public void onDiscoveryStarted(String s) {}



    @Override

    public void onDiscoveryStopped(String s) {}



    @Override

    public void onServiceFound(NsdServiceInfo nsdServiceInfo) {}



    @Override

    public void onServiceLost(NsdServiceInfo nsdServiceInfo) {}

};

nsdManager.discoverServices(NsdServer.ServiceType, NsdManager.PROTOCOL_DNS_SD, discoveryListener);

4、解析

Client App 收到onServcieFound回调之后，就可以调用解析接口解析数据了

nsdManager.resolveService(nsdServiceInfo, new NsdManager.ResolveListener() {

    @Override

    public void onServiceResolved(NsdServiceInfo nsdServiceInfo) {

        Map<String, byte[]> attributes = nsdServiceInfo.getAttributes();

    }



    @Override

    public void onResolveFailed(NsdServiceInfo nsdServiceInfo, int i) {}

});

二、TCP通信

发现设备之后，我们要考虑两台设备要如何通信。此时我们可以有两套方案，分别是HTTP以及TCP。

HTTP

使用HTTP的话，就是在Server App上启动一个HTTP服务，我们可以预定义一些接口用于和Client来通信。
优点是比较简单，缺点是Server App没有办法主动通知Client App。

TCP

直接使用TCP协议的话，我们可以考虑选择一个支持TCP通信的框架，自定义一个简易的通信协议。优点是客户端与服务端可以互相通信，满足我们的需求。缺点是相对复杂一些。

在我们的项目中，我们有两台设备交互通信的需求，所以选择了TCP协议。

1、TCP通信库的选择

在我们的项目中使用了Netty作为TCP通信框架。关于Netty其大名鼎鼎，网络上的分析文章一大把，这里就不详细介绍了。Netty在国内有一位步道的大神名为李林峰（在华为工作），有兴趣的同学可以去看看大神的书。

2、简易的TCP协议设计

由于业务比较简单，所以这里我们将TCP通信协议进行简化。整体协议大致如下：[Int][String]。

其中Int用于指定后面String字符串长度，我们可以基于这个Int来处理拆包、粘包的问题，这个逻辑后面详细介绍。String可以是JSON结构，可以依据业务来定义JSON中字段。

3、TCP服务端

使用Netty实现TCP服务端大致代码

bossGr0up = new NioEventLoopGr0up();

workerGr0up = new NioEventLoopGr0up();

//构建引导程序

mBootstrap = new ServerBootstrap();

//设置EventGr0up

mBootstrap.group(bossGr0up, workerGr0up);

//设置Channel

mBootstrap.channel(NioServerSocketChannel.class);

mBootstrap.option(ChannelOption.SO_BACKLOG, 128);

//设置的好处是禁用Nagle算法。表示不延迟立即发送

//这个算法试图减少TCP包的数量和结构性开销，将多个较小的包组合较大的包进行发送。

//这个算法收TCP延迟确认影响，会导致相继两次向链接发送请求包。

mBootstrap.option(ChannelOption.TCP_NODELAY, false);

mBootstrap.option(ChannelOption.SO_KEEPALIVE, true);

mBootstrap.childHandler(new CustomChannelInitializer());

channelFuture = mBootstrap.bind(inetPort).sync();

以上TCP服务就启动了。

4、TCP客户端

使用Netty实现TCP客户端大致代码：

初始化

//构建线程池

mGr0up = new NioEventLoopGr0up();

//构建引导程序

mBootstrap = new Bootstrap();

//设置EventGr0up

mBootstrap.group(mGr0up);

//设置Channel

mBootstrap.channel(NioSocketChannel.class);

//设置的好处是禁用Nagle算法。表示不延迟立即发送

//这个算法试图减少TCP包的数量和结构性开销，将多个较小的包组合较大的包进行发送。

//这个算法收TCP延迟确认影响，会导致相继两次向链接发送请求包。

mBootstrap.option(ChannelOption.TCP_NODELAY, false);

mBootstrap.option(ChannelOption.SO_KEEPALIVE, true);

mBootstrap.remoteAddress(ip.getIp(), ip.getPort());

mBootstrap.handler(new CustomChannelInitializer());

建立连接

ChannelFuture channelFuture = mBootstrap.connect();

channelFuture.addListener(new FutureListener() {

    @Override

    public void operationComplete(Future future) {

        final boolean isSuccess = future.isSuccess();

        writeLog("operation complete future.isSuccess: " + isSuccess);

    }

});

断开连接

public void disConnect(boolean onPurpose) {

    try {

        if (mGr0up != null) {

            mGr0up.shutdownGracefully();

        }

    } catch (Exception e) {

        e.printStackTrace();

    }

    try {

        if (mChannel != null) {

            mChannel.close();

        }

    } catch (Exception e) {

        e.printStackTrace();

    }

    try {

        if (mChannelHandlerContext != null) {

            mChannelHandlerContext.close();

        }

    } catch (Exception e) {

        e.printStackTrace();

    }

}

我们可以在operationComplete()方法中，确认建立连接成功。

ChannelInitializer

为了让更多协议和其他各种方式处理数据，Netty有了Handler组件。Handler就是为了处理Netty里面的置顶事件或一组事件。 ChannelInitializer 的作用就是将Handler 添加到ChannelPipeline中。当你发送或收到消息的时候，这些Handler就决定怎么处理你的数据。

public class CustomChannelInitializer extends ChannelInitializer<SocketChannel> {



    @Override

    protected void initChannel(SocketChannel socketChannel) {

        ChannelPipeline pipeline = socketChannel.pipeline();

        mCustomDecoder = new CustomDecoder();

        mCustomEncoder = new CustomEncoder();

        mCustomHandler = new CustomHandler();

        

        pipeline.addLast(mCustomDecoder);

        pipeline.addLast(mCustomEncoder);

        pipeline.addLast(mCustomHandler);

    }



    @Override

    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {

        super.handlerAdded(ctx);

    }



    @Override

    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {

        super.exceptionCaught(ctx, cause);

    }

}

ChannelPipeline 是一个管道，Handler就是里面一层一层要对数据进行处理的事件。所有的Handler都一个顶层接口ChannelHandler。ChannelHandler有两个子接口：

• ChannelInboundHandler


• ChannelOutboundHandler

Netty中数据流有2个方向：

• 数据进（应用收到消息）的时候与ChannelInboundHandler有关。


• 数据出（应用发出数据）的时候与ChannelOutboundHandler有关。

为了将数据从一端发送到另一端，一般都会有一个或多个ChannelHandler用各种方式对数据进行操作。 决定这些Handler以一种特定的顺序处理数据的是ChannelPipeline。

ChannelInboundHandler与ChannelOutboundHandler可以混在同一个ChannelPipeline里面。当应用收到数据时，首先从ChannelPipeline的头部进入到一个ChannelInboundHandler 。第一个ChannelInboundHandler处理后传给下一个ChannelInboundHandler。 然后ChannelPipeline中没有其他的ChannelInboundHandler 了数据就会到达ChannelPipeline的尾部，也就是应用对数据的处理已经完成了。

数据流出的过程是返过来的，首先从ChannelPipeline的尾部开始进入到最后一个ChannelOutboundHandler，最后一个ChannelOutboundHandler处理后，传给前面一个ChannelOutboundHandler。 和进不同的，进是从前到后，而出是从后到前。没有多余的ChannelOutboundHandler的时候，数据进入实际网络中传输，触发一些IO操作。

一旦一个ChannelHandler被添加到ChannelPipeline中，它就会获得一个ChannelHandlerContext。一般情况下，获得这个对象并持有它是安全的， 不过在数据包协议的时候不一样安全，例如UDP协议。 在Netty中有两种发送数据的方式。你可以写到Channel中或者使用ChannelhandlerContext对象。他们的主要区别是，直接写到Channel，则数据会从ChannelPipeline头部传到尾部。 每一个ChannelHandler都会处理数据，而使用ChannelHandlerContext则是将数据传送到下一个ChannelHandler。

一个 Channel 包含了一个 ChannelPipeline, 而 ChannelPipeline 中又维护了一个由 ChannelHandlerContext 组成的双向链表, 并且每个 ChannelHandlerContext 中又关联着一个 ChannelHandler。 入站事件和出站事件在一个双向链表中，入站事件会从链表head往后传递到最后一个入站的handler，出站事件会从链表tail往前传递到最前一个出站的handler，两种类型的handler互不干扰。

我们在 CustomChannelInitializer#initChannel()方法中添加编码、解码器。其中 CustomHandler 继承自SimpleChannelInboundHandler用来接收消息。

三、编解码

当你用Netty接收或发送消息，必须将其从一种格式转成另一种格式。比如收消息，你需要从字节转为Java对象。发消息就是将Java对象转成字节发出去。

Netty中有各种各样的编码器和解码器基类。

• ByteToMessageDecoder


• MessageToByteEncoder


• ProtobufEncoder


• ProtobufDecoder


• StringDecoder


• StringEncode

这里，编码器都是继承自ChannelInboundHandlerAdapter或者实现了ChannelInboundHandler。当读到数据时，会调用ChannelRead方法。重写此方法，然后就会调用decode 方法进行解码。并且会执行ChannelHandlerContext，fireChannelRead方法，将解码后的消息传给下一个Channelhandler。 当发送消息的时候，也执行类似的过程，编码器将消息转为字节，然后传给下一个ChannelOutboundHandler。

在我们的项目中，由于自定义了协议所以使用了ByteToMessageDecoder、MessageToByteEncoder。

1、编码

编码器比较简单，我们可以自定义类继承 MessageToByteEncoder 来实现解码。
需要注意的是，按照我们定义的协议顺序向 ByteBuf 中写入数据就好了。示例代码：

public class CustomEncoder extends MessageToByteEncoder<CustomMessage> {



    @Override

    protected void encode(ChannelHandlerContext channelHandlerContext, CustomMessage message, ByteBuf byteBuf) {

        //byteBuf.writeInt();

        //byteBuf.writeByte();

    }



}

2、解码

解码我们要解决TCP拆包、粘包的问题。

一般TCP中应对拆包、粘包基本有以下几种方案：

• 消息定长，这但比较好理解，由于定长了，我们可以直接判断ByteBuffer中数组长度。不过在实践过程中，一般我们不会使用这个方案，因为扩展性太差了。


• 使用特殊字符作为结尾。


• 自定义协议。

前面我们有提到我们的通信协议为[Int][String]实际上就是一个非常简易的自定义协议（由于业务简单，所以这里没有设计的非常复杂）。我们使用Int来标记后面的String长度，这样两端收到消息后，按照这个格式解析实际上就知道消息的长度了。

在Netty中，我们可以自定义类继承自 ByteToMessageDecoder，来处理解码。Netty中 ByteBuf 来处理数据。具体的步骤是：

• 先标记已读位置：byteBuf.markReaderIndex();


• 判断 ByteBuf 可读是否达到4个字节长度，如果不足直接返回，重置已读位置。


• 读取前4个字节，转为Int。


• 如果字符长度 > 0，那么接下来继续读 length 长度的字符，转为String。


• 这样整个协议就解码完成了。

这里需要注意的是：客户端要与服务端约定好是大端字节序还是小端字节序。

以上在局域网中，两款App进行TCP通信就已经搭建好了，我们有了协议上层业务就可以基于此来封装业务需要的逻辑了。实际上很多IM 通信SDK，基本上都是自定义通信协议，只是协议会比本篇中举例的协议要复杂的多。

四、优化点

项目上线一段时间后，用户反馈偶现存在两台设备无法通信的问题。后面经过调研发现是服务端进程一直存在（即Server App 并没有挂），只是TCP服务挂了。

我们在客户端有处理断线重连逻辑，但是在服务端没有做任何监控重启逻辑。

如何优化

经过调研，我们在服务端Server App中，另外启动一个客户端来与TCP服务端建立连接（相当于是我监控我自己了），如果建立失败，就重启TCP服务。

• 建立一个TCP客户端，启动轮询逻辑


• 如果该客户端没有与服务端建立连接，那么尝试建立连接。


• 如果连续三次都无法建立成功连接，那么认为此时TCP服务存在异常，重启TCP服务。


• 如果可以正常与TCP服务建立连接，那么开始向TCP服务发送心跳包


• 如果连续三次TCP服务没有回复心跳回包，那么也认为TCP服务存在异常，重启TCP服务。
  以上，就是我们针对TCP服务端的优化，上面逻辑上线后，无法建立连接的反馈就没有了。

五、总结

本篇主要是介绍如何在局域网中，两个APP使用Dns-SD协议来发现对方。自定义协议进行TCP通信，使用Netty作为TCP通信框架。

引言

最近公司整改，招了个安全测试，安全测试的同事搞了个危险的文件，悄咪咪加了个.png的后缀，就丢到我们的生产服务器上面去了，这么勇，你敢信？

不管你信不信，事实他就是发生了，就问你怕不怕。

好了，这里也就暴露了一个很大的问题，我们的开发同事判断文件类型，是使用文件后缀来判断的，所以被直接跳过。咱来看看更加科学的识别方式。

一、认识魔数

魔数：也被称为签名或文件签名，是一种用于识别文件类型和格式的短序列字节。它们通常位于文件的开头，并被设计为易于识别，以便软件可以快速确定文件是否是它所支持的格式。

魔数是一种简单的识别机制，它由一系列字节组成，这些字节在特定的文件格式中是唯一的。当一个程序打开一个文件时，它会检查文件的开始处是否包含这些特定的字节。如果找到，程序就认为文件是该格式的，并按照相应的规则进行解析和处理。

二、文件类型检测的原理

文件类型检测通常基于文件的“魔数”（magic number），也称为签名或文件签名。魔数是文件开头的字节序列，用于标识文件格式。以下是文件类型检测的原理和步骤：

2.1 文件头的读取方法

打开文件：首先，需要以二进制模式打开文件，以便能够读取文件的原始字节。

读取字节：接着，读取文件开头的一定数量的字节（通常是前几个字节）。

关闭文件：读取完成后，关闭文件以释放资源。

2.2 如何通过文件头识别文件类型

比较魔数：将读取的字节与已知的文件类型魔数进行比较。

匹配类型：如果字节序列与某个文件类型的魔数匹配，则可以确定文件类型。

处理异常：如果字节序列与任何已知魔数都不匹配，可能需要进一步的分析或返回未知文件类型。

三、Java实现文件类型检测

当需要通过文件头（魔数头）判断文件类型时，可以按照以下文字描述的流程进行实现：

graph LR

F[打开文件] --> B[读取文件头]

B --> C[判断文件类型]

C --> D[比较文件头]

D --> E[输出文件类型]



style B fill:#FFC0CB,stroke:#FFC0CB,stroke-width:2px

style C fill:#FFA07A,stroke:#FFA07A,stroke-width:2px

style D fill:#FFFFE0,stroke:#FFFFE0,stroke-width:2px

style E fill:#98FB98,stroke:#98FB98,stroke-width:2px

style F fill:#B2FFFF,stroke:#B2FFFF,stroke-width:2px

3.1 具体实现方法

3.1.1 定义枚举类

/**

 * 文件类型魔数枚举

 * 使用场景：用于判断文件类型

 * 使用方法：FileUtils.isFileType(new FileInputStream(file), FileTypeEnum.XLSX)

 *

 * @author bamboo panda

 * @version 1.0

 * @date 2024/5/23 19:37

 */

public enum FileTypeEnum {

    /**

     * JPEG

     */

    JPEG("JPEG", "FFD8FF"),



    /**

     * PNG

     */

    PNG("PNG", "89504E47"),



    /**

     * GIF

     */

    GIF("GIF", "47494638"),



    /**

     * TIFF

     */

    TIFF("TIFF", "49492A00"),



    /**

     * Windows bitmap

     */

    BMP("BMP", "424D"),



    /**

     * CAD

     */

    DWG("DWG", "41433130"),



    /**

     * Adobe photoshop

     */

    PSD("PSD", "38425053"),



    /**

     * Rich Text Format

     */

    RTF("RTF", "7B5C727466"),



    /**

     * XML

     */

    XML("XML", "3C3F786D6C"),



    /**

     * HTML

     */

    HTML("HTML", "68746D6C3E"),



    /**

     * Outlook Express

     */

    DBX("DBX", "CFAD12FEC5FD746F "),



    /**

     * Outlook

     */

    PST("PST", "2142444E"),



    /**

     * doc;xls;dot;ppt;xla;ppa;pps;pot;msi;sdw;db

     */

    OLE2("OLE2", "0xD0CF11E0A1B11AE1"),



    /**

     * Microsoft Word/Excel

     */

    XLS_DOC("XLS_DOC", "D0CF11E0"),



    /**

     * Microsoft Access

     */

    MDB("MDB", "5374616E64617264204A"),



    /**

     * Word Perfect

     */

    WPB("WPB", "FF575043"),



    /**

     * Postscript

     */

    EPS_PS("EPS_PS", "252150532D41646F6265"),



    /**

     * Adobe Acrobat

     */

    PDF("PDF", "255044462D312E"),



    /**

     * Windows Password

     */

    PWL("PWL", "E3828596"),



    /**

     * ZIP Archive

     */

    ZIP("ZIP", "504B0304"),



    /**

     * ARAR Archive

     */

    RAR("RAR", "52617221"),



    /**

     * WAVE

     */

    WAV("WAV", "57415645"),



    /**

     * AVI

     */

    AVI("AVI", "41564920"),



    /**

     * Real Audio

     */

    RAM("RAM", "2E7261FD"),



    /**

     * Real Media

     */

    RM("RM", "2E524D46"),



    /**

     * Quicktime

     */

    MOV("MOV", "6D6F6F76"),



    /**

     * Windows Media

     */

    ASF("ASF", "3026B2758E66CF11"),



    /**

     * MIDI

     */

    MID("MID", "4D546864"),

    /**

     * xlsx

     */

    XLSX("XLSX", "504B0304"),

    /**

     * xls

     */

    XLS("XLS", "D0CF11E0A1B11AE1");



    private String key;

    private String value;



    FileTypeEnum(String key, String value) {

        this.key = key;

        this.value = value;

    }



    public String getValue() {

        return value;

    }



    public String getKey() {

        return key;

    }

}

3.1.2 文件类型判断工具类

import java.io.IOException;

import java.io.InputStream;



/**

 * 文件类型判断工具类

 *

 * @author bamboo panda

 * @version 1.0

 * @date 2024/5/23 19:38

 */

public class FileTypeUtils {



    /**

     * 获取文件头

     *

     * @param inputStream 输入流

     * @return 16 进制的文件投信息

     * @throws IOException io异常

     */

    private static String getFileHeader(InputStream inputStream) throws IOException {

        byte[] b = new byte[28];

        inputStream.read(b, 0, 28);

        inputStream.close();

        return bytes2hex(b);

    }



    /**

     * 将字节数组转换成16进制字符串

     *

     * @param src 文件字节数组

     * @return 16进制字符串

     */

    private static String bytes2hex(byte[] src) {

        StringBuilder stringBuilder = new StringBuilder("");

        if (src == null || src.length <= 0) {

            return null;

        }

        for (byte b : src) {

            int v = b & 0xFF;

            String hv = Integer.toHexString(v);

            if (hv.length() < 2) {

                stringBuilder.append(0);

            }

            stringBuilder.append(hv);

        }

        return stringBuilder.toString();

    }



    /**

     * 判断指定输入流是否是指定文件格式

     *

     * @param inputStream  输入流

     * @param fileTypeEnum 文件格式枚举

     * @return true 是； false 否

     * @throws IOException io异常

     */

    public static boolean isFileType(InputStream inputStream, FileTypeEnum fileTypeEnum) throws IOException {

        if (null == inputStream) {

            return false;

        }

        String fileHeader = getFileHeader(inputStream);

        return fileHeader.toUpperCase().startsWith(fileTypeEnum.getValue());

    }



}

3.1.3 测试方法

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;



/**

 * 测试：判断文件是否是excel

 *

 * @author bamboo panda

 * @version 1.0

 * @date 2024/5/23 19:33

 */

public class Test {



    public static void main(String[] args) {

        File file = new File("C:\Users\Admin\Desktop\temp\Import file.xlsx");

        try (FileInputStream fileInputStream = new FileInputStream(file)) {

            if (!FileTypeUtils.isFileType(fileInputStream, FileTypeEnum.XLSX) || !FileTypeUtils.isFileType(fileInputStream, FileTypeEnum.XLS)) {

                System.out.println(true);

            } else {

                System.out.println(false);

            }

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        } catch (IOException e) {

            e.printStackTrace();

        }

    }



}

四、其它注意事项

在处理文件类型检测和数据保护时，安全性和隐私是两个非常重要的考虑因素。以下是一些相关的安全性问题和最佳实践：

4.1 魔数检测的安全性问题

graph LR

F(文件类型判断)

B(魔数检测的安全性问题)

C(误报和漏报)

D(恶意文件伪装)

E(更新和维护)



F ---> B

B ---> C

B ---> D

B ---> E



style B fill:#FFC0CB,stroke:#FFC0CB,stroke-width:2px

style C fill:#FFA07A,stroke:#FFA07A,stroke-width:2px

style D fill:#FFFFE0,stroke:#FFFFE0,stroke-width:2px

style E fill:#98FB98,stroke:#98FB98,stroke-width:2px

style F fill:#B2FFFF,stroke:#B2FFFF,stroke-width:2px

4.2 数据保护和隐私的最佳实践

graph LR

I(文件类型判断)



A(数据保护和隐私的最佳实践)



G(最小权限原则)

B(数据加密)

C(安全的数据传输)

D(访问控制)

E(定期审计和测试)

F(数据最小化)



I ---> A

A ---> B

A ---> C

A ---> D

A ---> E

A ---> F

A ---> G



style B fill:#FFC0CB,stroke:#FFC0CB,stroke-width:2px

style C fill:#FFA07A,stroke:#FFA07A,stroke-width:2px

style D fill:#FFFFE0,stroke:#FFFFE0,stroke-width:2px

style E fill:#98FB98,stroke:#98FB98,stroke-width:2px

style F fill:#B2FFFF,stroke:#B2FFFF,stroke-width:2px

style G fill:#ADD8E6,stroke:#ADD8E6,stroke-width:2px

style A fill:#E6E6FA,stroke:#E6E6FA,stroke-width:2px

style I fill:#EEDD82,stroke:#EEDD82,stroke-width:2px

4.3 魔数的局限性和风险

魔数判断文件类型是一种常用的方法，但也存在一些局限性和风险，包括以下几点：

graph LR

I(文件类型判断)



A(魔数的局限性和风险)



B(可伪造性)

C(文件类型扩展性)

D(文件损坏或篡改)

E(多重文件类型)

F(文件类型模糊性)



I ---> A

A ---> B

A ---> C

A ---> D

A ---> E

A ---> F



style B fill:#FFC0CB,stroke:#FFC0CB,stroke-width:2px

style C fill:#FFA07A,stroke:#FFA07A,stroke-width:2px

style D fill:#FFFFE0,stroke:#FFFFE0,stroke-width:2px

style E fill:#98FB98,stroke:#98FB98,stroke-width:2px

style F fill:#B2FFFF,stroke:#B2FFFF,stroke-width:2px

style A fill:#E6E6FA,stroke:#E6E6FA,stroke-width:2px

style I fill:#EEDD82,stroke:#EEDD82,stroke-width:2px

五、总结

好了，到这里魔数怎么用的就说明白了。

魔数的广泛的应用在在文件类型检测中。魔数是文件开头的特定字节序列，帮助软件快速识别文件格式。

然而，魔数检测存在安全性问题，如误报、恶意伪装等，需定期更新魔数库。此外，应用魔数检测时要考虑文件损坏、多重类型等局限性，结合实际情况采取综合措施，如数据加密、访问控制等，确保安全性和准确性。

希望本文对您有所帮助。如果有任何错误或建议，请随时指正和提出。

同时，如果您觉得这篇文章有价值，请考虑点赞和收藏。这将激励我进一步改进和创作更多有用的内容。

感谢您的支持和理解！

大家好呀，我是summo，JDK版本升级的非常快，现在已经到JDK20了。JDK版本虽多，但应用最广泛的还得是JDK8，正所谓“他发任他发，我用Java8”。

其实我也不太想升级JDK版本，感觉投入高，收益小，不过有一次我看到了一些使用JDK17新语法写的代码，让我改变了对升级JDK的看法，因为这些新语法我确实想用！

废话不多说，上代码！

一、JDK17语法新特性

1. 文本块

这个更新非常实用。在没有这个特性之前，编写长文本非常痛苦。虽然IDEA等集成开发工具可以自动处理，但最终效果仍然丑陋，充满拼接符号。现在，通过字符串块，我们可以轻松编写JSON、HTML、SQL等内容，效果更清爽。这个新特性值得五颗星评价，因为它让我们只需关注字符串本身，而无需关心拼接操作。

原来的写法

/**

 * 使用JDK8返回HTML文本

 *

 * @return 返回HTML文本

 */

public static final String getHtmlJDK8() {

    return "<html>\n" +

        " <body>\n" +

        " <p>Hello, world</p>\n" +

        " </body>\n" +

        "</html>";

}

新的写法

/**

 * 使用JDK17返回HTML文本

 *

 * @return 返回HTML文本

 */

public static final String getHtmlJDK17() {

    return """

        <html>

            <body>

                <p>Hello, world</p>

            </body>

        </html>

        """;

}

推荐指数：⭐️⭐️⭐️⭐️⭐️

2. NullPointerException增强

这一功能非常强大且实用，相信每位Java开发者都期待已久。空指针异常（NPE）一直是Java程序员的痛点，因为报错信息无法直观地指出哪个对象为空，只抛出一个NullPointerException和一堆堆栈信息，定位问题耗时且麻烦。尤其在遇到喜欢级联调用的代码时，逐行排查更是令人头疼。如果在测试环境中，可能还需通过远程调试查明空对象，费时费力。为此，阿里的编码规范甚至不允许级联调用，但这并不能彻底解决问题。Java17终于在这方面取得了突破，提供了更详细的空指针异常信息，帮助开发者迅速定位问题源头。

public static void main(String[] args) {

    try {

        //简单的空指针

        String str = null;

        str.length();

    } catch (Exception e) {

        e.printStackTrace();

    }

    try {

        //复杂一点的空指针

        var arr = List.of(null);

        String str = (String)arr.get(0);

        str.length();

    } catch (Exception e) {

        e.printStackTrace();

    }

}

运行结果

推荐指数：⭐️⭐️⭐️⭐️⭐️

3. Records

在Java中，POJO对象（如DO、PO、VO、DTO等）通常包含成员变量及相应的Getter和Setter方法。尽管可以通过工具或IDE生成这些代码，但修改和维护仍然麻烦。Lombok插件为此出现，能够在编译期间自动生成Getter、Setter、hashcode、equals和构造函数等代码，使用起来方便，但对团队有依赖要求。
为此，Java引入了标准解决方案：Records。它通过简洁的语法定义数据类，大大简化了POJO类的编写，如下所示。虽然hashcode和equals方法仍需手动编写，但IDE能够自动生成。这一特性有效解决了模板代码问题，提升了代码整洁度和可维护性。

package com.summo.jdk17;



/**

 * 3星

 *

 * @param stuId     学生ID

 * @param stuName   学生名称

 * @param stuAge    学生年龄

 * @param stuGender 学生性别

 * @param stuEmail  学生邮箱

 */

public record StudentRecord(Long stuId,

                            String stuName,

                            int stuAge,

                            String stuGender,

                            String stuEmail) {

    public StudentRecord {

        System.out.println("构造函数");

    }



    public static void main(String[] args) {

        StudentRecord record = new StudentRecord(1L, "张三", 16, "男", "xxx@qq.com");

        System.out.println(record);

    }

}

推荐指数：⭐️⭐️⭐️⭐️

4. 全新的switch表达式

有人可能问了，Java语言不早已支持switch了嘛，有什么好提的？讲真，这次的提升还真有必要好好地来聊一聊了。在Java12的时候就引入了switch表达式，注意这里是表达式，而不是语句，原来的switch是语句。如果不清楚两者的区别的话，最好先去了解一下。主要的差别就是就是表达式有返回值，而语句则没有。再配合模式匹配，以及yield和“->”符号的加入，全新的switch用起来爽到飞起来。

package com.summo.jdk17;



public class SwitchDemo {

    /**

     * 在JDK8中获取switch返回值方式

     *

     * @param week

     * @return

     */

    public int getByJDK8(Week week) {

        int i = 0;

        switch (week) {

            case MONDAY, TUESDAY:

                i = 1;

                break;

            case WEDNESDAY:

                i = 3;

                break;

            case THURSDAY:

                i = 4;

                break;

            case FRIDAY:

                i = 5;

                break;

            case SATURDAY:

                i = 6;

                break;

            case SUNDAY:

                i = 7;

                break;

            default:

                i = 0;

                break;

        }



        return i;

    }



    /**

     * 在JDK17中获取switch返回值

     *

     * @param week

     * @return

     */

    public int getByJDK17(Week week) {

        // 1, 现在的switch变成了表达式，可以返回值了，而且支持yield和->符号来返回值

        // 2, 再也不用担心漏写了break，而导致出问题了

        // 3, case后面支持写多个条件

        return switch (week) {

            case null -> -1;

            case MONDAY -> 1;

            case TUESDAY -> 2;

            case WEDNESDAY -> 3;

            case THURSDAY -> {yield 4;}

            case FRIDAY -> 5;

            case SATURDAY, SUNDAY -> 6;

            default -> 0;

        };

    }



    private enum Week {

        MONDAY,

        TUESDAY,

        WEDNESDAY,

        THURSDAY,

        FRIDAY,

        SATURDAY,

        SUNDAY

    }

}

推荐指数：⭐️⭐️⭐️⭐️

5. 私有接口方法

从Java8开始，允许在interface里面添加默认方法，其实当时就有些小困惑，如果一个default方法体很大怎么办，拆到另外的类去写吗？实在有些不太合理，所以在Java17里面，如果一个default方法体很大，那么可以通过新增接口私有方法来进行一个合理的拆分了，为这个小改进点个赞。

public interface PrivateInterfaceMethod {

    /**

     * 接口默认方法

     */

    default void defaultMethod() {

        privateMethod();

    }



    // 接口私有方法，在Java8里面是不被允许的，不信你试试

    private void privateMethod() {

    }

}

推荐指数：⭐️⭐️⭐️

6. 模式匹配

在JDK 17中，模式匹配主要用于instanceof表达式。模式匹配增强了instanceof的语法和功能，使类型检查和类型转换更加简洁和高效。在传统的Java版本中，我们通常使用instanceof结合类型转换来判断对象类型并进行处理，这往往会导致冗长的代码。

原来的写法

/**

 * 旧式写法

 *

 * @param value

 */

public void matchByJDK8(Object value) {

    if (value instanceof String) {

        String v = (String)value;

        System.out.println("遇到一个String类型" + v.toUpperCase());

    } else if (value instanceof Integer) {

        Integer v = (Integer)value;

    System.out.println("遇到一个整型类型" + v.longValue());

    }

}

新的写法

/**

 * 转换并申请了一个新的变量，极大地方便了代码的编写

 *

 * @param value

 */

public void matchByJDK17(Object value) {

    if (value instanceof String v) {

        System.out.println("遇到一个String类型" + v.toUpperCase());

    } else if (value instanceof Integer v) {

        System.out.println("遇到一个整型类型" + v.longValue());

    }

}

推荐指数：⭐️⭐️⭐️⭐️

7. 集合类的工厂方法

在Java8的年代，即便创建一个很小的集合，或者固定元素的集合都是比较麻烦的，为了简洁一些，有时我甚至会引入一些依赖。

原来的写法

Set<String> set = new HashSet<>();

set.add("a");

set.add("b");

set.add("c"

新的写法

Set<String> set = Set.of("a", "b", "c");

推荐指数：⭐️⭐️⭐️⭐️⭐️

二、其他的新特性

1. 新的String方法

• repeat：重复生成字符串


• isBlank：不用在引入第三方库就可以实现字符串判空了


• strip：去除字符串两边的空格，支持全角和半角，之前的trim只支持半角


• lines：能根据一段字符串中的终止符提取出行为单位的流


• indent：给字符串做缩进，接受一个int型的输入


• transform：接受一个转换函数，实现字符串的转换

2. Stream API的增强

增加takeWhile, dropWhile, ofNullable, iterate以及toList的API，越来越像一些函数式语言了。用法举例如下。

// takeWhile 顺序返回符合条件的值，直到条件不符合时即终止继续判断，

// 此外toList方法的加入，也大大减少了节省了代码量，免去了调用collect(Collectors::toList)方法了

List<Integer> list = Stream.of(2,2,3,4,5,6,7,8,9,10)

        .takeWhile(i->(i%2==0)).toList(); // 返回2, 2



// dropWhile 顺序去掉符合条件的值，直到条件不符合时即终止继续判断

List<Integer> list1 = Stream.of(2,2,3,4,5,6,7,8,9,10)

        .dropWhile(i->(i%2==0)).toList(); //返回3, 4, 5, 6, 7, 8, 9, 10



// ofNullable，支持传入空流，若没有这个且传入一个空流，那么将会抛NPE

var nullStreamCount = Stream.ofNullable(null).count(); //返回0



// 以下两行都将输出0到9

Stream.iterate(0, n -> n < 10, n -> n + 1).forEach(x -> System.out.println(x));

Stream.iterate(0, n -> n + 1).limit(10).forEach(x -> System.out.println(x));

3. 全新的HttpClient

这个API首次出现在9之中，不过当时并非是一个稳定版本，在Java11中正式得到发布，所以在Java17里面可以放心地进行使用。原来的JDK自带的Http客户端真的非常难用，这也就给了很多像okhttp、restTemplate、Apache的HttpClient和feign这样的第三方库极大的发挥空间，几乎就没有人愿意去用原生的Http客户端的。但现在不一样了，感觉像是新时代的API了。FluentAPI风格，处处充满了现代风格，用起来也非常地方便，再也不用去依赖第三方的包了，就两个字，清爽。

// 同步请求

HttpClient client = HttpClient.newBuilder()

        .version(Version.HTTP_1_1)

        .followRedirects(Redirect.NORMAL)

        .connectTimeout(Duration.ofSeconds(20))

        .proxy(ProxySelector.of(new InetSocketAddress("proxy.example.com", 80)))

        .authenticator(Authenticator.getDefault())

        .build();

   HttpResponse<String> response = client.send(request, BodyHandlers.ofString());

   System.out.println(response.statusCode());

   System.out.println(response.body()); 

// 异步请求

HttpRequest request = HttpRequest.newBuilder()

        .uri(URI.create("https://foo.com/"))

        .timeout(Duration.ofMinutes(2))

        .header("Content-Type", "application/json")

        .POST(BodyPublishers.ofFile(Paths.get("file.json")))

        .build();

   client.sendAsync(request, BodyHandlers.ofString())

        .thenApply(HttpResponse::body)

        .thenAccept(System.out::println);

 

4. jshell

在新的JDK版本中，支持直接在命令行下执行java程序，类似于python的交互式REPL。简而言之，使用 JShell，你可以输入代码片段并马上看到运行结果，然后就可以根据需要作出调整，这样在验证一些简单的代码的时候，就可以通过jshell得到快速地验证，非常方便。

5. java命令直接执行java文件

在现在可以直接通过执行“java xxx.java”，即可运行该java文件，无须先执行javac，然后再执行java，是不是又简单了一步。

6. ZGC

在ParallelOldGC、CMS和G1之后，JDK 11引入了全新的ZGC（Z Garbage Collector）。这个名字本身就显得很牛。官方宣称ZGC的垃圾回收停顿时间不超过10ms，能支持高达16TB的堆空间，并且停顿时间不会随着堆的增大而增加。那么，ZGC到底解决了什么问题？Oracle官方介绍它是一个可伸缩的低延迟垃圾回收器，旨在降低停顿时间，尽管这可能会导致吞吐量的降低。不过，通过横向扩展服务器可以解决吞吐量问题。官方已建议ZGC可用于生产环境，这无疑将成为未来的主流垃圾回收器。要了解更多，请参阅官方文档。

三、小结一下

作为程序员，持续学习和充电非常重要。随着Java8即将停止免费官方支持，越来越多的项目将转向Java17，包括大名鼎鼎的Spring Boot 3.0，它在2022年1月20日发布的第一个里程碑版本（M1）正是基于Java17构建的。该项目依赖的所有组件也将快速升级，未来如果想利用某些新特性，在Java8下将无法通过编译.，到这时候再换就真的晚了... ...

个人项目：社交支付项目（小老板）

作者：三哥，j3code.cn

文档系统：admire.j3code.cn/note

社交支付类的项目，怎么能没有图片上传功能呢！

涉及到文件存储我第一时间就想到了 OSS 对象存储服务（腾讯叫 COS），但是接着我又想到了”OSS 被刷 150 T 的流量，1.5 W 瞬间就没了？“。

本来想着是自己搭建一套 MinIO ，但后来一想服务器的开销又要大了，还是作罢了。就在此时，我脑袋突然灵光了一下，既然对象存储的流量是由于资源 url 泄漏导致的外界不停的访问 url 使公网流量剧增从而引起巨额消费，那我能不能不泄露这个 url 呢！

理论上是可以不直接给用户云存储的 url ，那用户如何访问资源？

转换，当用户上传图片时，将云存储的 url 保存入库，而返回用户一个本系统的资源访问接口。当用户访问该接口时，系统从库中获取真实 url 进行资源访问，并返回资源给用户，完成一次转换。

虽然可以解决 url 泄漏问题，但是也是有性能消耗（从直接访问，变为间接访问，而且系统挂了，资源就不可用）。

方案，虽然曲折了点，但为了 money ，牺牲一点是值得的（后来思考了一下，觉得还是有些问题，文章最后会说）。而且即使有人通过刷系统的接口访问资源，也没事，系统有很强的限流和黑名单处理，不会产生过多的公网流量费用的。

那下面我们就先开通相关功能，然后再编码实现。

1、腾讯云对象存储创建

地址：console.cloud.tencent.com/cos

开通对象存储的步骤还是非常简单的，具体步骤如下：

1）开通功能

2）配置存储桶

下一步

下一步

3）创建访问的密钥

腾讯的所有 API 接口都需要这个访问密钥，如果以前创建过就可以直接拿来使用

下一步

基本的功能我们已经开通了，而且以后我们只需向这个存储桶中上传图片即可。

2、SpringBoot 对接对象存储

既然准备工作都已经完成了，那就开始编写上传文件的代码吧！当然，这里我们还是要借助官方文档，便于我们开发，地址如下：

cloud.tencent.com/document/pr…

2.1 配置准备

先来思考一下，对于腾讯 COS 文件上传需要那些配置：

ok，大致就这些，那咱们就先来写个配置文件：application-cos.yml

tx.cos:

  # 云 API 的 SecretId

  secret-id: ENC(X7Uu6Y0QD6aCeUmNhyqv1jcr8fSN+fqM/FSP/rqhM+6pkbte2LW5gR3wntsm24n3NAg6sIwBC3pqm1lSNWwElc3iuGe3lE4L/k3zih+EstM=)

  # 云 API 的 SecretKey

  secret-key: ENC(ui3jqYJpyTRtPAizYdtll2Zc1EVzUjK28vjTyD+t3AIydQO6I+JQOVacc5+NJVybsbFptELswKhY55OQLW+BKfujNTOYEM/zb4CMi+AK80w=)

  # 域名访问

  domain: ENC(oRsaRjwRCVLEYfcNB0CjPGyqSMxGM5uzWnSpSifauLF7c5YMt5hZFi7xAthJI4CjmOLVA810Jbgy8lnkKrXUH0g1ee14cr67xSdtPRy1ZaJOXQOMlBgCKNO2wDBg2YW2)

  # 文件上传的桶名称

  bucket-name: ENC(TUsQfDEFx6KSAOpRwG7UYOJbGwnFT0Z9tjS4h+/HeenAE3XbhKsCwn3TTo80n5tUUP9Dzrnu+Ck84FNSYQk5fw==)



spring:

  servlet:

    multipart:

      # 限制文件上传大小

      max-request-size: 5MB

      max-file-size: 5MB

注：这里，我的配置值是加密的，所以你们需要配置自己的值

再根据这个配置文件，写一个对应的配置类：

地址：cn.j3code.common.config

@Slf4j

@Data

@Configuration

@ConfigurationProperties(prefix = "tx.cos")

public class TxCosConfig {

    /**

     * 访问域名

     */

    private String domain;



    /**

     * 桶名称

     */

    private String bucketName;



    /**

     * api密钥中的secretId

     */

    private String secretId;



    /**

     * api密钥中的应用密钥

     */

    private String secretKey;

}

2.2 上传文件代码

这里，我们先实现单个文件的上传，那来思考一下，上传文件应该需要那些步骤：

对应此步骤的流程图，如下：

1）controller 编写

位置：cn.j3code.other.api.v1.controller

@Slf4j

@AllArgsConstructor

@ResponseResult

@RestController

@RequestMapping(UrlPrefixConstants.WEB_V1 + "/image/upload")

public class ImageUploadController {



    private final FileService fileService;





    /**

     * 图片上传

     * @param file 文件

     * @return 返回文件 url

     */

    @PostMapping("")

    public String upload(@RequestParam("file") MultipartFile file){

        return fileService.imageUpload(file);

    }

}

2）service 编写

位置：cn.j3code.other.service

public interface FileService {

    String imageUpload(MultipartFile file);

}



@Slf4j

@AllArgsConstructor

@Service

public class FileServiceImpl implements FileService {



    /**

     * 允许上传的图片类型

     */

    public static final Set<String> IMG_TYPE = Set.of("jpg", "jpeg", "png", "gif");



    /**

     * 腾讯 cos 配置

     */

    private final TxCosConfig txCosConfig;

    private final UrlKeyService urlKeyService;



    /**

     * 图片上传

     *

     * @param file

     * @return

     */

    @Override

    public String imageUpload(MultipartFile file) {

        // 文件名称

        String newFileName = getNewFileName(file);



        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

        String format = formatter.format(LocalDate.now());

        // key = /用户id/年月日/文件

        String key = SecurityUtil.getUserId() + "/" + format + "/" + newFileName;



        String prefix = newFileName.substring(0, newFileName.lastIndexOf(".") - 1);

        String suffix = newFileName.substring(newFileName.lastIndexOf(".") + 1);

        File tempFile = null;

        File rename = null;

        try {

            // 生成临时文件

            tempFile = File.createTempFile(prefix, "." + suffix);

            file.transferTo(tempFile);

            // 重命名文件

            rename = FileUtil.rename(tempFile, newFileName, true, true);

            // 上传

            upload(new FileInputStream(rename), key);

        } catch (Exception e) {

            log.error("imageUpload-error:", e);

        } finally {

            if (Objects.nonNull(tempFile)) {

                FileUtil.del(tempFile);

            }

            if (Objects.nonNull(rename)) {

                FileUtil.del(rename);

            }

        }

        // 返回访问链接

        return initUrl(key);

    }



    /**

     * 初始化图片文件访问 url（本地url和第三方url）

     *

     * @param key 路径

     * @return

     */

    private String initUrl(String key) {

        // 组装第三方 url

        String imageUrl = txCosConfig.getDomain() + "/" + key;



        // 保存 url 到 数据库

        UrlKey urlKey = new UrlKey()

            .setUrl(imageUrl)

            .setKey(RandomUtil.randomString(16) + RandomUtil.randomString(16) + RandomUtil.randomString(16))

            .setUserId(SecurityUtil.getUserId());



        // 保存成功，返回本地中转的 url 出去

        boolean save = Boolean.FALSE;

        try {

            save = urlKeyService.save(urlKey);

        } catch (Exception e) {

        }



        if (save) {

            return CallbackUrlConstants.IMAGE_OPEN_URL + urlKey.getKey();

        }

        // 保存失败，直接把第三方 url 返回给用户

        return imageUrl;

    }



    /**

     * 文件上传到第三方

     *

     * @param fileStream 文件流

     * @param path       路径

     */

    private void upload(InputStream fileStream, String path) {

        PutObjectResult putObjectResult = COSClientUtil.getCosClient(txCosConfig)

            .putObject(new PutObjectRequest(txCosConfig.getBucketName(), path, fileStream, null));

        log.info("upload-result:{}", JSON.toJSONString(putObjectResult));

    }



    /**

     * 生成一个新文件名称

     * 会校验文件名称和类型

     *

     * @param file 文件

     * @return

     */

    private String getNewFileName(MultipartFile file) {

        String originalFilename = file.getOriginalFilename();

        if (StringUtil.isEmpty(originalFilename)) {

            throw new SysException("文件名称获取失败！");

        }

        String suffix = originalFilename.substring(originalFilename.lastIndexOf("."));



        if (!IMG_TYPE.contains(suffix.substring(1))) {

            throw new SysException(String.format("仅允许上传这些类型图片：%s", JSON.toJSONString(IMG_TYPE)));

        }



        return RandomUtil.randomString(8) + SnowFlakeUtil.getId() + suffix;

    }

}

代码写的很详细了，应该能看懂，但，有两点我没有提，就是：COSClientUtil 和 UrlKeyService，下面就来结介绍。

2.2.1 cos 客户端配置提取

系统中肯定有很多的文件上传，难道是每上传一次，就配置一次 cos 客户端吗？显然不是，这个 cos 客户端肯定是要抽出来的，全局系统中我们只配置一次。也即只有第一次过来是创建 cos 客户端，后续过来的文件上传请求直接返回创建好的 cos 客户端就行。

COSClientUtil 类就是我抽的公共 cos 客户获取类，具体实现如下：

位置：cn.j3code.other.util

public class COSClientUtil {



    /**

     * 统一 cos 上传客户端

     */

    private static COSClient cosClient;



    public static COSClient getCosClient(TxCosConfig txCosConfig) {

        if (Objects.isNull(cosClient)) {

            synchronized (COSClient.class) {

                if (Objects.isNull(cosClient)) {

                    // 1 初始化身份

                    COSCredentials cred = new BasicCOSCredentials(txCosConfig.getSecretId(), txCosConfig.getSecretKey());

                    // 2 创建配置，及设置地域

                    ClientConfig clientConfig = new ClientConfig(new Region("ap-guangzhou"));

                    // 3 生成 cos 客户端。

                    cosClient = new COSClient(cred, clientConfig);

                }

            }

        }

        return cosClient;

    }

}

私有构造器，且之对外提供 getCosClient 方法获取 COSClient 对象，保证全局只有一个 cos 客户端配置。

2.2.2 隐藏云存储 URL 处理

还记得 FileServiceImpl 类中有个 UrlKeyService 属性嘛，这个类就是做 云存储 URL 隐藏及中转功能的。

具体做法如图：

文件上传部分我们已经写好了，不过有点超前的意思了，不过没关系，看整体就行。

从上面我们要开始抓住一个细节了，就是映射关系，即 key 和 url 的映射。这里我用的是 MySQL 保存，也即用表来存，并没有用 Redis。这里我的考虑是，后续可以把表中的数据定时刷到 Redis 中，接着访问的顺序是从 Redis 中找映射，没有再去 MySQL 中找。

不过，我们首先还是把数据先存表再说，先来看看映射表结构字段：

id

user_id

key

url

create_time

update_time

ok，就这些字段，把用户 id 加上是为了好回溯看看是谁上传了图片。

SQL 如下：

CREATE TABLE `sb_url_key` (

  `id` bigint(20) NOT NULL AUTO_INCREMENT,

  `key` varchar(64) COLLATE utf8_unicode_ci NOT NULL COMMENT 'key',

  `url` varchar(200) COLLATE utf8_unicode_ci NOT NULL COMMENT '资源url',

  `user_id` bigint(20) DEFAULT NULL COMMENT '上传用户',

  `create_time` datetime DEFAULT NULL COMMENT '创建时间',

  `update_time` datetime DEFAULT NULL COMMENT '修改时间',

  PRIMARY KEY (`id`),

  KEY `key` (`key`)

) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci

紧接着就是通过 MyBatisX 插件生成对应的实体、service、mapper 代码了，不过多赘述。那，现在就来开发用户访问图片资源，咱们如何去请求第三方，然后返回用户图片 byte[] 资源数组吧！

1）controller 编写

位置：cn.j3code.other.api.v1.controller

@Slf4j

@AllArgsConstructor

@RestController

@RequestMapping(UrlPrefixConstants.OPEN + "/resource/image")

public class ImageResourceController {



    private final UrlKeyService urlKeyService;



    /**

     * 获取图片 base64

     *

     * @param key

     * @return

     * @throws Exception

     */

    @GetMapping("/base64/{key}")

    public String imageBase64(@PathVariable("key") String key) throws Exception {

        UrlKey urlKey = urlKeyService.oneByKey(key);

        return "data:image/jpg;base64," + Base64Encoder.encode(IoUtil.readBytes(new URL(urlKey.getUrl()).openStream()));

    }





    /**

     * 获取图片 byte 数组

     *

     * @param key

     * @return

     * @throws Exception

     */

    @GetMapping(value = "/io/{key}", produces = MediaType.IMAGE_JPEG_VALUE)

    public byte[] imageIo(@PathVariable("key") String key) throws Exception {

        UrlKey urlKey = urlKeyService.oneByKey(key);



        return IoUtil.readBytes(new URL(urlKey.getUrl()).openStream());

    }

}

注意：这里写了两个方法，目的是返回两种不同形式的图片资源：base64 和 byte[]。且，这种资源访问的接口，我们系统的相关拦截器请放行，如：认证，ip 记录等拦截器。

2）service 编写

位置：cn.j3code.other.service

public interface UrlKeyService extends IService<UrlKey> {

    UrlKey oneByKey(String key);

}

@Service

public class UrlKeyServiceImpl extends ServiceImpl<UrlKeyMapper, UrlKey>

    implements UrlKeyService {



    @Override

    public UrlKey oneByKey(String key) {

        UrlKey urlKey = lambdaQuery().eq(UrlKey::getKey, key).one();

        if (Objects.isNull(urlKey)) {

            throw new SysException(SysExceptionEnum.NOT_DATA_ERROR);

        }

        return urlKey;

    }

}

ok，这样咱们就处理好了，但是仔细想想这种中转的方法有什么问题。

2.3 思考

2.2 节我们已经实现了文件上传和防止 cos 访问 url 泄露的操作，但是我留了个问题，就是思考这种方式有什么问题。

下面是我的思考：

好吧，其实上面总结就两个问题，即：性能 和 可用性。

这里的解决方法是，如果资金充裕而且 COS 做了黑白名单等之类的防御措施可以直接把 COS 的原始 url 返回出去，没必要把图片资源压力给我我们本系统。如果你不是这种情况，那么就给图片访问接口增加部署资源，即升级服务器增加内存和带款，提高资源访问效率及系统性能。

以上就是本节内容，如果文章的中转方法有啥不足或者您有什么意见，欢迎一起讨论研究。

为了节省dalaos时间先说结论：确实是个问题，issue链接：github.com/mybatis/myb…

下面就是源码分析环节，及处理过程，感兴趣的可以看看。

bug，任何时候都要解决！不解决不行，你们想想，你早上刚到公司，打开电脑，写着需求听着歌，突然就被ding了……所以没有bug的日子才是好日子！

日志

上了服务器一看，Mybatis报错，接口还是个相当频繁的接口，一想，完了，绩效大概率不保。

2023-08-08 09:52:05,386|aaaaaaaaa|XXXXXXXXXXXXXX|unknown exception occurred

org.mybatis.spring.MyBatisSystemException: nested exception is org.apache.ibatis.builder.BuilderException: Error evaluating expression 'projects != null and projects.size() > 0 '. Cause: org.apache.ibatis.ognl.MethodFailedException: Method "size" failed for object [aaa,bbb,ccc] [java.lang.IllegalAccessException: Class org.apache.ibatis.ognl.OgnlRuntime can not access a member of class java.util.Arrays$ArrayList with modifiers "public"]

        at org.mybatis.spring.MyBatisExceptionTranslator.translateExceptionIfPossible(MyBatisExceptionTranslator.java:75) ~[mybatis-spring-1.2.2.jar:1.2.2]

        at org.mybatis.spring.SqlSessionTemplate$SqlSessionInterceptor.invoke(SqlSessionTemplate.java:371) ~[mybatis-spring-1.2.2.jar:1.2.2]

        at com.sun.proxy.$Proxy57.selectList(Unknown Source) ~[na:na]

        at org.mybatis.spring.SqlSessionTemplate.selectList(SqlSessionTemplate.java:198) ~[mybatis-spring-1.2.2.jar:1.2.2]

        at org.apache.ibatis.binding.MapperMethod.executeForMany(MapperMethod.java:119) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.binding.MapperMethod.execute(MapperMethod.java:63) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.binding.MapperProxy.invoke(MapperProxy.java:52) ~[mybatis-3.2.8.jar:3.2.8]

        at com.sun.proxy.$Proxy102.queryExperienceCardOrder(Unknown Source) ~[na:na]

      // 业务相关堆栈，保险起见不贴了

        at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204) ~[spring-core-4.3.6.RELEASE.jar:4.3.6.RELEASE]

        at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:652) ~[spring-aop-4.3.6.RELEASE.jar:4.3.6.RELEASE]

        at com.xxxxxxxxxxxxxxxxxxxxxx$$EnhancerBySpringCGLIB$$b85a94bd.queryHasExperienceCardNew(<generated>) ~[zuhao-user-service-1.0.0.jar:na]

        at sun.reflect.GeneratedMethodAccessor564.invoke(Unknown Source) ~[na:na]

        at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:1.8.0_131]

        at java.lang.reflect.Method.invoke(Method.java:498) ~[na:1.8.0_131]

        at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:333) ~[spring-aop-4.3.6.RELEASE.jar:4.3.6.RELEASE]

        at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:190) [spring-aop-4.3.6.RELEASE.jar:4.3.6.RELEASE]

        at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157) [spring-aop-4.3.6.RELEASE.jar:4.3.6.RELEASE]

        at xxxxxxxxxxxxx.common.interceptor.ApiInterceptor.invoke(ApiInterceptor.java:79) ~[common-0.0.9-20211228.052440-12.jar:na]

        at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) [spring-aop-4.3.6.RELEASE.jar:4.3.6.RELEASE]

        at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:213) [spring-aop-4.3.6.RELEASE.jar:4.3.6.RELEASE]

        at com.sun.proxy.$Proxy185.queryHasExperienceCardNew(Unknown Source) [na:na]

        at com.alibaba.dubbo.common.bytecode.Wrapper36.invokeMethod(Wrapper36.java) [na:2.5.3]

        at com.alibaba.dubbo.rpc.proxy.javassist.JavassistProxyFactory$1.doInvoke(JavassistProxyFactory.java:46) [dubbo-2.5.3.jar:2.5.3]

        at com.alibaba.dubbo.rpc.proxy.AbstractProxyInvoker.invoke(AbstractProxyInvoker.java:72) [dubbo-2.5.3.jar:2.5.3]

        at com.alibaba.dubbo.rpc.protocol.InvokerWrapper.invoke(InvokerWrapper.java:53) [dubbo-2.5.3.jar:2.5.3]

        at com.alibaba.dubbo.rpc.filter.ExceptionFilter.invoke(ExceptionFilter.java:64) [dubbo-2.5.3.jar:2.5.3]

        at com.alibaba.dubbo.rpc.protocol.ProtocolFilterWrapper$1.invoke(ProtocolFilterWrapper.java:91) [dubbo-2.5.3.jar:2.5.3]

        at com.alibaba.dubbo.monitor.support.MonitorFilter.invoke$original$LFhJaVNd(MonitorFilter.java:65) [dubbo-2.5.3.jar:2.5.3]

        at com.alibaba.dubbo.monitor.support.MonitorFilter.invoke$original$LFhJaVNd$accessor$urPnHrIw(MonitorFilter.java) [dubbo-2.5.3.jar:2.5.3]

        at com.alibaba.dubbo.monitor.support.MonitorFilter$auxiliary$RJHyKBeq.call(Unknown Source) [dubbo-2.5.3.jar:2.5.3]

        at org.apache.skywalking.apm.agent.core.plugin.interceptor.enhance.InstMethodsInter.intercept(InstMethodsInter.java:86) [skywalking-agent.jar:8.16.0]

        at com.alibaba.dubbo.monitor.support.MonitorFilter.invoke(MonitorFilter.java) [dubbo-2.5.3.jar:2.5.3]

        at com.alibaba.dubbo.rpc.protocol.ProtocolFilterWrapper$1.invoke(ProtocolFilterWrapper.java:91) [dubbo-2.5.3.jar:2.5.3]

        at com.alibaba.dubbo.rpc.filter.TimeoutFilter.invoke(TimeoutFilter.java:42) [dubbo-2.5.3.jar:2.5.3]

        at com.alibaba.dubbo.rpc.protocol.ProtocolFilterWrapper$1.invoke(ProtocolFilterWrapper.java:91) [dubbo-2.5.3.jar:2.5.3]

        at com.alibaba.dubbo.rpc.protocol.dubbo.filter.TraceFilter.invoke(TraceFilter.java:78) [dubbo-2.5.3.jar:2.5.3]

        at com.alibaba.dubbo.rpc.protocol.ProtocolFilterWrapper$1.invoke(ProtocolFilterWrapper.java:91) [dubbo-2.5.3.jar:2.5.3]

        at com.alibaba.dubbo.rpc.filter.ContextFilter.invoke(ContextFilter.java:60) [dubbo-2.5.3.jar:2.5.3]

        at com.alibaba.dubbo.rpc.protocol.ProtocolFilterWrapper$1.invoke(ProtocolFilterWrapper.java:91) [dubbo-2.5.3.jar:2.5.3]

        at com.alibaba.dubbo.rpc.filter.GenericFilter.invoke(GenericFilter.java:112) [dubbo-2.5.3.jar:2.5.3]

        at com.alibaba.dubbo.rpc.protocol.ProtocolFilterWrapper$1.invoke(ProtocolFilterWrapper.java:91) [dubbo-2.5.3.jar:2.5.3]

        at com.alibaba.dubbo.rpc.filter.ClassLoaderFilter.invoke(ClassLoaderFilter.java:38) [dubbo-2.5.3.jar:2.5.3]

        at com.alibaba.dubbo.rpc.protocol.ProtocolFilterWrapper$1.invoke(ProtocolFilterWrapper.java:91) [dubbo-2.5.3.jar:2.5.3]

        at com.alibaba.dubbo.rpc.filter.EchoFilter.invoke(EchoFilter.java:38) [dubbo-2.5.3.jar:2.5.3]

        at com.alibaba.dubbo.rpc.protocol.ProtocolFilterWrapper$1.invoke(ProtocolFilterWrapper.java:91) [dubbo-2.5.3.jar:2.5.3]

        at com.alibaba.dubbo.rpc.protocol.dubbo.DubboProtocol$1.reply(DubboProtocol.java:108) [dubbo-2.5.3.jar:2.5.3]

        at com.alibaba.dubbo.remoting.exchange.support.header.HeaderExchangeHandler.handleRequest(HeaderExchangeHandler.java:84) [dubbo-2.5.3.jar:2.5.3]

        at com.alibaba.dubbo.remoting.exchange.support.header.HeaderExchangeHandler.received(HeaderExchangeHandler.java:170) [dubbo-2.5.3.jar:2.5.3]

        at com.alibaba.dubbo.remoting.transport.DecodeHandler.received(DecodeHandler.java:52) [dubbo-2.5.3.jar:2.5.3]

        at com.alibaba.dubbo.remoting.transport.dispatcher.ChannelEventRunnable.run(ChannelEventRunnable.java:82) [dubbo-2.5.3.jar:2.5.3]

        at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142) [na:1.8.0_131]

        at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617) [na:1.8.0_131]

        at java.lang.Thread.run(Thread.java:748) [na:1.8.0_131]

Caused by: org.apache.ibatis.builder.BuilderException: Error evaluating expression 'projects != null and projects.size() > 0 '. Cause: org.apache.ibatis.ognl.MethodFailedException: Method "size" failed for object [u号租, 租号牛, 租号酷] [java.lang.IllegalAccessException: Class org.apache.ibatis.ognl.OgnlRuntime can not access a member of class java.util.Arrays$ArrayList with modifiers "public"]

        at org.apache.ibatis.scripting.xmltags.OgnlCache.getValue(OgnlCache.java:47) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.scripting.xmltags.ExpressionEvaluator.evaluateBoolean(ExpressionEvaluator.java:32) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.scripting.xmltags.IfSqlNode.apply(IfSqlNode.java:33) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.scripting.xmltags.MixedSqlNode.apply(MixedSqlNode.java:32) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.scripting.xmltags.TrimSqlNode.apply(TrimSqlNode.java:54) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.scripting.xmltags.MixedSqlNode.apply(MixedSqlNode.java:32) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.scripting.xmltags.TrimSqlNode.apply(TrimSqlNode.java:54) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.scripting.xmltags.MixedSqlNode.apply(MixedSqlNode.java:32) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.scripting.xmltags.DynamicSqlSource.getBoundSql(DynamicSqlSource.java:40) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.mapping.MappedStatement.getBoundSql(MappedStatement.java:278) ~[mybatis-3.2.8.jar:3.2.8]

        at com.github.pagehelper.PageInterceptor.intercept(PageInterceptor.java:83) ~[pagehelper-5.1.4.jar:na]

        at org.apache.ibatis.plugin.Plugin.invoke(Plugin.java:60) ~[mybatis-3.2.8.jar:3.2.8]

        at com.sun.proxy.$Proxy234.query(Unknown Source) ~[na:na]

        at org.apache.ibatis.session.defaults.DefaultSqlSession.selectList(DefaultSqlSession.java:108) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.session.defaults.DefaultSqlSession.selectList(DefaultSqlSession.java:102) ~[mybatis-3.2.8.jar:3.2.8]

        at sun.reflect.GeneratedMethodAccessor347.invoke(Unknown Source) ~[na:na]

        at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:1.8.0_131]

        at java.lang.reflect.Method.invoke(Method.java:498) ~[na:1.8.0_131]

        at org.mybatis.spring.SqlSessionTemplate$SqlSessionInterceptor.invoke(SqlSessionTemplate.java:358) ~[mybatis-spring-1.2.2.jar:1.2.2]

        ... 54 common frames omitted

Caused by: org.apache.ibatis.ognl.MethodFailedException: Method "size" failed for object [aaa,bbb,ccc]

        at org.apache.ibatis.ognl.OgnlRuntime.callAppropriateMethod(OgnlRuntime.java:837) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.ognl.ObjectMethodAccessor.callMethod(ObjectMethodAccessor.java:61) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.ognl.OgnlRuntime.callMethod(OgnlRuntime.java:860) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.ognl.ASTMethod.getValueBody(ASTMethod.java:73) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.ognl.SimpleNode.evaluateGetValueBody(SimpleNode.java:170) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.ognl.SimpleNode.getValue(SimpleNode.java:210) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.ognl.ASTChain.getValueBody(ASTChain.java:109) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.ognl.SimpleNode.evaluateGetValueBody(SimpleNode.java:170) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.ognl.SimpleNode.getValue(SimpleNode.java:210) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.ognl.ASTGreater.getValueBody(ASTGreater.java:49) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.ognl.SimpleNode.evaluateGetValueBody(SimpleNode.java:170) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.ognl.SimpleNode.getValue(SimpleNode.java:210) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.ognl.ASTAnd.getValueBody(ASTAnd.java:56) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.ognl.SimpleNode.evaluateGetValueBody(SimpleNode.java:170) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.ognl.SimpleNode.getValue(SimpleNode.java:210) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.ognl.Ognl.getValue(Ognl.java:333) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.ognl.Ognl.getValue(Ognl.java:310) ~[mybatis-3.2.8.jar:3.2.8]

        at org.apache.ibatis.scripting.xmltags.OgnlCache.getValue(OgnlCache.java:45) ~[mybatis-3.2.8.jar:3.2.8]

        ... 72 common frames omitted

赶紧查了下这个接口的调用情况，大部分没问题，偶尔冒了这么个错（还好还好）

根据堆栈反查错误位置，有点想不通，这里会有问题？那就只能翻源码了

源码分析

经过排查，ognl表达式中用到的方法，会通过反射，获取method，并缓存至静态变量中，所以，存在多线程状态中，产生并发问题，往下看

这里是缓存方法的逻辑，org.apache.ibatis.ognl.OgnlRuntime#getMethods(java.lang.Class, boolean)感兴趣的可以自己看

这里就是bug点，如果调用一旦多，存在A线程修改成true，还没调用方法，B线程就修改成false，此时调用失败，这不是个坑吗

mybatis中一搜果然有这个issue：github.com/mybatis/myb…

作者给的方案呢是升级mybatis。

你以为就这样结束了？

升级是不可能升级的，这辈子都不可能升级的，代码这么稳定，行行都像诗句[狗头]

开个玩笑，看看如何避免

原因呢就是Arrays.asList返回的是内部类，是private。所以导致了(!Modifier.isPublic(method.getModifiers()) || !Modifier.isPublic(method.getDeclaringClass().getModifiers()))这个条件为true，进入了设置
accessible的逻辑，后面又给设置回原样

总结

• 问题：如果需要ognl的对象的方法和类不是public，那么会存在并发问题


• 解决1：针对并发问题，升级Mybatis


• 解决2：Lists.newArrayList或者其他写法代替，反正看下，内部类是不是private

有问题希望留言指出哈

特色： 当前模板将自定义样式配置通过css变量的方式提取了出来，直接通过可视化去配置成你喜欢的样式效果，在下面预览地址中可以体验。

• 预览地址 可视化配置面版不够好看的话，可以把地址上的vue-admin改为vue-admin-el


• 项目地址

描述

无UI框架依赖的后台管理模板

当前项目是基于vue.js去实现的一套后台管理模板，早在2019年就已经在持续迭代，目前已经是较新的vue3.x版本；

因为在中后台项目中，大多数核心功能只有页面框架样式和侧边菜单栏功能，所以除了底层 js 框架vue+vue-router以外，所有样式、功能都采用自行实现方式；之所以不使用第三方UI库的理由是：

• 不受UI框架的约束，可以使用任何一款自己喜欢的第三方库；


• 轻量化，因为用到的依赖极少，所以体积非常轻量，同时保证了常用到的大部分功能保留；所有的工程化配置根据自身需求去加入即可，当前模板只做代码减法；


• 兼容性、拓展性高，模板中每个部分都是可以独立抽离和替换的，并无上手成本；当在引用某一款UI库使用时，直接引入依赖并使用即可，无需修改模板已有功能组件；


• 别人写的模板代码太多了，都不好改！

当前模板项目的 package.json 做到了极致的精简

{

  "dependencies": {

    "nprogress": "0.2.0",

    "vue": "3.4.21",

    "vue-router": "4.3.0"

  },

  "devDependencies": {

    "@types/node": "20.11.28",

    "@types/nprogress": "0.2.0",

    "@vitejs/plugin-vue": "5.0.4",

    "@vitejs/plugin-vue-jsx": "3.1.0",

    "sass": "~1.71.0",

    "typescript": "~5.4.0",

    "vite": "5.2.8",

    "vue-tsc": "~1.8.0"

  }

}

功能目录清单

• vue-router 权限路由功能、路由记录初始进入路径功能


• layout 部分：可视化配置样式功能、顶部伸缩布局 + 多级侧边菜单栏、路由面包屑、路由历史记录标签栏、整体自适应窗口大小布局、滚动条（类似）


• utils 只保留使用频率极高的：日期格式化、复制、类型判断、网络请求、和一些核心功能函数


• UI控件 + 通用组件：消息提示条、对话框、高度自适应折叠组件、dialog 组件

layout 核心布局整体

大多数情况开发者在选用开源模板时，只是为了侧边菜单栏和顶部的布局不同而选择对应的模板，所以当前项目直接将两种布局写成可以动态切换，并且加入可视化的样式配置操作，这样连css代码都不需要去看了：

侧边菜单栏为什么没有整一个折叠缩略的功能？理由是我觉得这个操作逻辑不是那么的理想，缩小后，我需要鼠标一层一层的放上去找到需要的子菜单，这一点都不方便；而且缩小菜单的目的是为了获得更大内容可视区域，所以缩小后的菜单依然还占用了一部分空间，同时使用功能变得繁琐，那干脆在收起菜单时，将她整个推出屏幕区域，这样就能使可视区域最大化。

路由权限设置

完全继承了vue-router的数据结构，只在meta对象中加入auth作为路由数组过滤操作去实现权限控制；另外根部对象的name字段则作为路由缓存的唯一值。

import { RouteRecordRaw } from "vue-router";



export interface RouteMeta {

  /** 侧边栏菜单名、document.title */

  title: string

  /** 外链地址，优先级会比`path`高 */

  link?: string

  /** `svg`名 */

  icon?: string

  /** 是否在侧边菜单栏不显示该路由 */

  hidden?: boolean

  /**

   * 路由是否需要缓存

   * - 当设置该值为`true`时，路由必须要设置`name`，页面组件中的`name`也是，不然路由缓存不生效

   */

  keepAlive?: boolean

  /**

   * 可以访问该权限的用户类型数组，与`userInfo.type`对应；

   * 传空数组或者不写该字段代表可以全部用户访问

   * 

   * | number | 用户类型 |

   * | --- | --- |

   * | 0 | 超级管理员 |

   * | 1 | 普通用户 |

   */

  auth?: Array<number>

}



/** 自定义的路由类型-继承`RouteRecordRaw` */

export type RouteItem = {

  /**

   * 路由名，类似唯一`key`

   * - 路由第一层必须要设置，因为动态路由删除时需要用到，且唯一

   * - 当设置`meta.keepAlive`为`true`时，该值必填，且唯一，另外组件中的`name`也需要对应的同步设置，不然路由缓存不生效

   */

  name?: string

  /** 子级路由 */

  children?: Array<RouteItem>

  /** 标头 */

  meta: RouteMeta

} & RouteRecordRaw

状态管理

Vue3之后不需要Vuex了（虽然我在Vue2中也没用），而是采用另外一种更简单的方式：参考 你不需要vuex。

在ts的项目中，因为可以用Readonly去声明状态对象，所以这套程序设计会发挥得最好，具体示例可以在src/store/README.md中查看

网络请求

这里我使用的是根据个人习惯用原生写的ajax（代码地址）

理由是:

• 代码少，功能足以覆盖常用的大部分场景


• 在ts中可以更友好的声明接口返回类型

文件：api.ts request中的泛型不是必须的，不传下面 .vue 文件中res.data中的类型则是any

export interface TableItem {

  id: number

  type: "load" | "update"

  time: string

}



/**

 * @param params

 */

export function getData(params: PageInfo) {

  return request<Api.List<TableItem>>("GET", "/getList", params)

}

文件：demo.vue 建议直接在vscode中用鼠标去看提示，那样会更加的直观

<script lang="ts" steup>

import { ref } from "vue";

import { type TableItem, getData } from "@/api.ts";



const tableData = ref<Array<TableItem>>([]);



async function getTableData() {

  const res = await getData({

    pageSize: 10,

    currentPage: 1

  })

  if (res.code === 1) {

    tableData.value = res.data.list; // 这里的 .list 就是接口 传入的类型 TableItem

    // do some...

  }

}

script>

强力建议请求函数的封装时，都始终执行 Promise.resolve 去作为正确和错误的响应。接口获取后始终以res.code === 1为判断成功，无需在内部用 try + catch 去包一层

更多使用示例请在src/api/README.md中查看

另外可根据自己喜好可以扩展 axios 这类型第三方库。

SVG 图标组件

使用方式：到阿里云图标库中下载想要的图标，然后下载svg文件，最后放到src/icons/svg目录下即可

也是自己写的一个加载器，代码十分简单：

import { readFileSync, readdirSync } from "fs";



// svg-sprite-loader 这个貌似在 vite 中用不了

// 该文件只能作为`vite.config.ts`导入使用

// 其他地方导入会报错，因为浏览器环境不支持`fs`模块



/** `id`前缀 */

let idPerfix = "";



const svgTitle = /+].*?)>/;



const clearHeightWidth = /(width|height)="([^>+].*?)"/g;



const hasViewBox = /(viewBox="[^>+].*?")/g;



const clearReturn = /(\r)|(\n)/g;



/**

 * 查找`svg`文件

 * @param dir 文件目录

 */

function findSvgFile(dir: string): Array<string> {

  const svgRes: Array<string> = []

  const dirents = readdirSync(dir, {

    withFileTypes: true

  });

  dirents.forEach(function(dirent) {

    if (dirent.isDirectory()) {

      svgRes.push(...findSvgFile(dir + dirent.name + "/"));

    } else {

      const svg = readFileSync(dir + dirent.name).toString().replace(clearReturn, "").replace(svgTitle, function(_, group) {

        // console.log(++i)

        // console.log(dirent.name)

        let width = 0;

        let height = 0;

        let content = group.replace(clearHeightWidth, function(val1: string, val2: string, val3: number) {

          if (val2 === "width") {

            width = val3;

          } else if (val2 === "height") {

            height = val3;

          }

          return "";

        });

        if (!hasViewBox.test(group)) {

          content += `viewBox="0 0 ${width} ${height}"`;

        }

        return `${idPerfix}-${dirent.name.replace(".svg", "")}" ${content}>`;

      }).replace("", "");

      svgRes.push(svg);

    }

  });

  return svgRes;

}



/**

 * `svg`打包器

 * @param path 资源路径

 * @param perfix 后缀名（标签`id`前缀）

 */

export function svgBuilder(path: string, perfix = "icon") {

  if (path.trim() === "") return;

  idPerfix = perfix;

  const res = findSvgFile(path);

  // console.log(res.length)

  return {

    name: "svg-transform",

    transformIndexHtml(html: string) {

      return html.replace("",

      `

      

      ${res.join("")}

      `)

    }

  }

}

我第一份实习是在一家咨询公司，我以为我们能够给我们的客户提供极具商业价值的战略指导，但其实开始干活了之后，发现我们就是PPT和调研报告的搬运工。后来我去了一家互联网大厂，我以为我的身边全都是逻辑超强的技术和产品大佬，直到我们的产品带着一堆的bug上线了......

大四秋招的时候，我跟一个应届生一起面试，他简历上写了精通数据分析，还有很多获奖。我当时很羡慕他的能力，直到一起入职之后发现他只会用Excel......

刚从学生变成打工人的时候，我觉得每一家公司都是一个严丝合缝，非常精密的巨大的仪器，我要达到某一个水平或者有某种资质，我才能够去做一些工作，或者达到一些成就。但后来随着工作久了，我就想明白了一件事情，让我觉得之前的班真是白上了。

其实一个公司它的运营机制，并不是有很多个有远见的领导把规划都想明白，然后再有很多个能力强的下属把这些规划全部落地，这种太理想化了。电影里都没有这么演的。公司的运营机制就是面多了就加水，水多就加面，所有的公司都是大的草台班子。这里边绝大多数的工作，它的粗糙程度都远超过我们的想象。我们根本不用陷入所谓的入场券陷阱，觉得别人都很厉害，别人都是科班出身的，我得像别人一样厉害，一样有资质了，我才能够去做，这只不过是我给我自己设的一个假想敌。

想明白这一点之后，我的焦虑和内耗就好多了。既然大家都很水，那在职场这个大的草台班子上，我如果不去争取机会，那就被还不如我的人抢走了。勇敢的人先享受生活，同样勇敢的打工人也会先当上生活中的主演。

在争取机会的过程中，难免你就会用到一些职场作弊小技巧，就是自我包装。身边就有几个这样的人，敢于勇敢地表现自己，让别人觉得他能够创造很多价值。包装造势在掠夺职场资源的竞争力是非常有效的。

包装的方式分为职业和爱好。在职场上一定不要沉迷那些琐碎的工作中无法自拔，不要显得自己每天都很忙，加班都很晚，效率低下偷懒的人才要加班，不要不满现状，导致不想思考，不要未经选择直接就开始低效率的行动，所以要适当的停下来，寻找自我包装的发力点。

就像我们公司今年越来越重视数据分析，所以我就利用下班的时间多学习了数据分析。包装它肯定不只是一句空话，不然用不了多久就露馅了，所以要找到快速高效的学习方法。

如果你的职业发展方向也是产品运营，市场数据分析类似的岗位，那就要尽早的培养起你的数据分析能力，用好SQL，Python，统计学还有Excel，这些都会帮助你去提取处理和分析数据，再结合上你所在行业的专业知识，技能buff叠加在职场中会非常的加分。

职场里其实并没有那么多很厉害的人，大家都是在现学现卖，反正都是在草台班上演戏，不妨大胆一点去探索新的东西，去尝试你想尝试的，去找到能够把自己包装好的那个点，然后去大大方方的展示和表现自己。

在 Android 开发的过程中，我们经常使用 addView ，removeView等实现在 java 代码中动态添加和删除 View 的能力

但是在鸿蒙中，组件是相对于静态的结构，而且鸿蒙也没有提供类似于 addView ，removeView的方法，那我们怎么来实现动态化增删组件的能力呢

1. 使用 ForEach 实现动态化增删组件

1.1. ForEach 的入参

翻阅了鸿蒙的官方文档，终于看到了一种方法来解决这个问题，那就是使用 ForEach这个组件

这个组件的官方定义如下

ForEach(

  arr: Array,

  itemGenerator: (item: any, index: number) => void,

  keyGenerator?: (item: any, index: number) => string

)

• arr ：
  
  

  arr 有多少个元素，ForEach 就会渲染多少个组件



• itemGenerator：
  
  

  将 arr 中的元素转换为对应的组件样式

  
  

  决定了组件长什么样子



• keyGenerator：
  
  

  生成唯一的 key

1.2. ForEach 的渲染

在ForEach循环渲染过程中，系统会为每个数组元素生成一个唯一且持久的键值，用于标识对应的组件。当这个键值变化时，ArkUI框架将视为该数组元素已被替换或修改，并会基于新的键值创建一个新的组件。

ForEach 的渲染分为两种：

• 首次渲染

在ForEach首次渲染时，会根据前述键值生成规则为数据源的每个数组项生成唯一键值，并创建相应的组件。

• 非首次渲染：

在ForEach组件进行非首次渲染时，它会检查新生成的键值是否在上次渲染中已经存在。如果键值不存在，则会创建一个新的组件；如果键值存在，则不会创建新的组件，而是直接渲染该键值所对应的组件。

2. ForEach 的简单 demo

@Entry

@Component

export struct MyPage {

  @State items: Item[] = [

    { text: "1" },

    { text: "2" },

    { text: "3" },

  ]



  build() {

    Column() {

      ForEach(

        this.items,

        (item: Item, index: number) => {

          Text(item.text)

            .width(40)

            .height(40)

        }

      )



      Button("add item ")

        .onClick(

          ()=>{

            this.items.push(

              { text: "11" },

            )

          }

        )

    }

    .height('100%')

    .width('100%')

  }

}





interface Item {

  text: string,

}

运行后的状态为这样：每次点击按钮，都会新增一个

3. ForEach 的注意事项

3.1. 数组中元素子属性发生变化时的处理

数组中元素子属性发生变化时，鸿蒙默认是不会触发渲染的

解决办法是：使用@Observed和@ObjectLink

3.2. 最好自定义 key，key 中不含index

鸿蒙的默认 key

鸿蒙 Foreach 的默认key 为

(item: T, index: number) => {

  //👇 这里带着 index

  return index + '__' + JSON.stringify(item); 

}

默认的 key 里面带着 index，如果我们在对数组进行操作的过程中，将元素的 index改变了，就会导致 index 改变的元素对应的组件被重绘

鸿蒙 ForEach 的渲染

鸿蒙通过 key 来判断组件是新组件还是现有组件

index 改变，key 就改变了，鸿蒙就会执行两个操作

就会导致原来的组件中的所有状态全部没有了比如说我们正在执行动画，但是 key 被改变了，动画就会中断，重新创建的组件没有动画执行的状态，如果我们想继续执行动画，那么必须保存动画的状态，这样成本太大了，

而我们只需要自定义 key，让 index 不在 key 里面，就解决这个问题了

为什么 index 会改变？

比如说中间的元素被删除了，后面的元素 index 就会改变

而且我们不可能在执行时，一定保证移除的是最后一个元素，添加的一定在最后面

而如果我们自定义key 里面没有 index，那么我们可以随意的增删数组中的元素

自定义 key 的优点

• 可以让我们任意对数组进行操作，


• 优化性能

比如说我们只是删除了数组中间的一个元素，后面的元素没有任何的改变

如果我们使用鸿蒙默认的 key，后面的元素 index 改变，key 改变，全部会重绘

如果我们自定义 key，后面的元素就不会重绘了，节省性能

自定义 key 的注意事项

如果是变量，保证组件生命周期内不会变化

或者如果生命周期发生变化，是自己预期内的

引言

HashMap相信所有学Java的都一定不会感到陌生，作为一个非常重用且非常实用的Java提供的容器，它在我们的代码里面随处可见。因此遍历操作也是我们经常会使用到的。HashMap的遍历方式现如今有非常多种：

以上遍历方式的孰优孰劣，在《阿里巴巴开发手册》中写道：

这里推荐使用的是entrySet进行遍历，在Java8中推荐使用Map.forEach()。给出的理由是遍历次数上的不同。

其中keySet遍历了两次，一次是转为Iterator对象，另一次是从hashMap中取出key所对应的value。

其中后面一段话很好理解，但是前面这句话却有点绕，为什么转换成了Iterator遍历了一次？

我查阅了各个平台对HashMap的遍历，其中都没有或者原封不动的照搬上句话。（当然也可能是我没有查阅到靠谱的文章，欢迎指正）

keySet如何遍历了两次

我们首先写一段代码，使用keySet遍历Map。

public class Test {





    public static void main(String[] args) {

        Map<String, String> map = new HashMap<>();

        map.put("k1", "v1");

        map.put("k2", "v2");

        map.put("k3", "v3");

        for (String key : map.keySet()) {

            String value = map.get(key);

            System.out.println(key + ":" + value);

        }

    }



}

运行结果显而易见的是

k1:v1

k2:v2

k3:v3

两次遍历，第一次遍历所描述的是转为Iterator对象我们好像没有从代码中看见，我们看到的后面所描述的遍历，也就是遍历map,keySet()所返回的Set集合中的key，然后去HashMap中拿取value的。

Iterator对象呢？如何遍历转换为Iterator对象的呢？

首先我们这种遍历方式大家都应该知道是叫：增强for循环，for-each

这是一种Java的语法糖~。可以看上篇文章了解~

我们可以通过反编译，或者直接通过Idea在class文件中查看对应的Class文件

public class Test {

    public Test() {

    }



    public static void main(String[] args) {

        Map<String, String> map = new HashMap();

        map.put("k1", "v1");

        map.put("k2", "v2");

        map.put("k3", "v3");

        Iterator var2 = map.keySet().iterator();



        while(var2.hasNext()) {

            String key = (String)var2.next();

            String value = (String)map.get(key);

            System.out.println(key + ":" + value);

        }



    }

}

和我们编写的是存在差异的，其中我们可以看到其中通过map.keySet().iterator()获取到了我们所需要看见的Iterator对象。

那么它又是怎么转换成的呢？为什么需要遍历呢？我们查看iterator()方法

iterator()

发现是Set定义的一个接口。返回此集合中元素的迭代器

HashMap.KeySet#iterator()

我们查看HashMap中keySet类对该方法的实现。

    final class KeySet extends AbstractSet<K> {

        public final int size()                 { return size; }

        public final void clear()               { HashMap.this.clear(); }

        public final Iterator<K> iterator()     { return new KeyIterator(); }

        public final boolean contains(Object o) { return containsKey(o); }

        public final boolean remove(Object key) {

            return removeNode(hash(key), key, null, false, true) != null;

        }

        public final Spliterator<K> spliterator() {

            return new KeySpliterator<>(HashMap.this, 0, -1, 0, 0);

        }

        public final void forEach(Consumer<? super K> action) {

            Node<K,V>[] tab;

            if (action == null)

                throw new NullPointerException();

            if (size > 0 && (tab = table) != null) {

                int mc = modCount;

                for (int i = 0; i < tab.length; ++i) {

                    for (Node<K,V> e = tab[i]; e != null; e = e.next)

                        action.accept(e.key);

                }

                if (modCount != mc)

                    throw new ConcurrentModificationException();

            }

        }

    }

其中的iterator()方法返回的是一个KeyIterator对象，那么究竟是在哪里进行了遍历呢？我们接着往下看去。

HashMap.KeyIterator

    final class KeyIterator extends HashIterator

        implements Iterator<K> {

        public final K next() { return nextNode().key; }

    }

这个类也很简单：

还是没有看见哪里进行了遍历，那么我们继续查看HashIterator类

HashMap.HashIterator

    abstract class HashIterator {

        Node<K,V> next;        // next entry to return

        Node<K,V> current;     // current entry

        int expectedModCount;  // for fast-fail

        int index;             // current slot



        HashIterator() {

            expectedModCount = modCount;

            Node<K,V>[] t = table;

            current = next = null;

            index = 0;

            if (t != null && size > 0) { // advance to first entry

                do {} while (index < t.length && (next = t[index++]) == null);

            }

        }



        public final boolean hasNext() {

            return next != null;

        }



        final Node<K,V> nextNode() {

            Node<K,V>[] t;

            Node<K,V> e = next;

            if (modCount != expectedModCount)

                throw new ConcurrentModificationException();

            if (e == null)

                throw new NoSuchElementException();

            if ((next = (current = e).next) == null && (t = table) != null) {

                do {} while (index < t.length && (next = t[index++]) == null);

            }

            return e;

        }



        public final void remove() {

            Node<K,V> p = current;

            if (p == null)

                throw new IllegalStateException();

            if (modCount != expectedModCount)

                throw new ConcurrentModificationException();

            current = null;

            K key = p.key;

            removeNode(hash(key), key, null, false, false);

            expectedModCount = modCount;

        }

    }

我们可以发现这个构造器中存在了一个do-while循环操作，目的是找到一个第一个不为空的entry。

        HashIterator() {

            expectedModCount = modCount;

            Node<K,V>[] t = table;

            current = next = null;

            index = 0;

            if (t != null && size > 0) { // advance to first entry

                do {} while (index < t.length && (next = t[index++]) == null);

            }

        }

而KeyIterator是extendHashIterator对象的。这里涉及到了继承的相关概念，大家忘记的可以找相关的文章看看，或者我也可以写一篇~~dog。

例如两个类

public class Father {



    public Father(){

        System.out.println("father");

    }

}

public class Son extends Father{



    public static void main(String[] args) {

        Son son = new Son();

    }

}

创建Son对象的同时，会执行Father构造器。也就会打印出father这句话。

那么这个循环操作就是我们要找的循环操作了。

总结

keySet->iterator()->KeyIterator->HashIterator

大家想更清楚了解这个entry是什么？可以看我的HashMap文章~。文章如果存在错误，欢迎大家评论区指正~~

前言

Hi 你好，我是东东拿铁，一个正在探索个人IP的后端程序员。

最近半年发的文章中，我开头总是说，我是一个正在探索个人IP&副业的后端程序员。

今天开始，我准备把副业两个字去掉了，因为我在最近的半年的时间里，都没有理解副业和赚钱的关系。

副业可以分为两种：

一般来说第二类朋友们居多，我自己也是属于第二种，副业的目的，就是解决主业的风险问题，保证自己的现金流，目的就是赚钱。

但是，副业!=赚钱

想要赚钱，不如我们先试着了解一下，赚钱，到底是怎么样的一件事情，话不多说，我们开始吧。

赚钱的本质是什么

赚钱的本质，是交易，是买卖。

我们谈到所谓赚钱，其实核心思想是，交易，只有交易才能给你带来金钱，只有交易才能产生价值。

那么什么是交易，不是只有卖货是交易，你在职场获取⼀份offer，也是⼀种交易，公司买到了你的时间。

首先，建立⼀个认知基础，赚钱的本质，是交易。

那买卖的产品是什么

万物皆产品，只要能满足需求。

一套话术，一段文案，一个眼神，一个电话，一篇文章，一个课程，一个商品，一个咨询，一个关心，一套方法论，一本书，一次交谈，一个回答，一个社群，一本日历，一套方案等等。

以上皆是产品，只要能解决对方的问题。

比如，假设我把自己定位职场问题专家，那么这个问题可以拆分成几类

所以说，目光所及之处，皆为产品可以售卖。

你能卖什么产品

打造一个产品前，哪些地方需要我们去考虑

我第一点列的是自我优势，所以重点聊一下个人优势这块。

每个人的特质不同，每个人都是独一无二的存在。按照盖洛普对于人4个领域的分类，有以下四种

那么，每个人擅长的领域不同，就诞生了不同的细分岗位，比如有人适合做内容型产品，写文章、写专栏。有人适合做工具型产品，开发小程序、APP等。有人适合做运营，比如搞线上线下活动。岗位太多，就不一一列举了。

任何一个小的领域，都有人能赚到大钱，但是我们去做不一定能成功。

所以，你能卖什么产品，要结合自己的兴趣、优势、能力、资源来考虑，有前景固然重要，但是自己能掌控住，更重要。

比如微商曾经也是风口，我在过去一段时间，也一直在懊悔怎么没抓住微商的这个机会，但对于我这种偏内向，朋友圈一年都发不了几条的人来说，微商自然是不适合。

所以，风口和机会，都是建立在个人优势、爱好、行业积累上的。

别人为什么要从你这买？

信息不对称，不知道哪里可以买。
最早学习JVM的时候，我翻看了网上的很多资料，每看一篇文章，我都觉着，这个作者好厉害。
后来我知道，周志明老师写了一本，《深入了解JVM虚拟机》，然后很多网上的资料，不过是这本书的学习笔记。

这就是信息不对称，利用信息差可以赚到钱。

交付不便利，不方便从其他人那里买。
举个简单的例子，比如楼下小商店卖的东西，大部分超市也都可以买到，网购还更实惠，但是很多东西你必须要去买，比如你渴了。

信用不传递，信任这个事情，挺玄学的。
比如我很喜欢的博主半佛仙人，他文章里推荐过很多东西，便宜一点的如洗地机，贵一点的比如宝珀，如果我需要，我一定优先选择他推荐过的。

赚钱和圈层有什么关系

什么是圈层？

我们的生活质量提升后，社会就开始分层了。以车友圈为例，如果你是奥迪车友，奥迪的车友圈可能除了分成不同车系的车友圈，还分成了RS群、瓦罐群。

那么对于程序员呢？分成了前后端、客户端、算法等圈子。

那么还有不同地域、不同收入、兴趣的人，也构成了一个又一个小圈子，不同身份比如学生、宝妈、备婚、备孕同理。

职场中呢也同理，有躺平的，奋斗努力的和核心的，高职级的就是比普通员工有着更多的信息差。

所以你看，社会越发达，从消费层面可选择的越多，领域的细分分类也越多。

所以，上面提到的信息差，就差在圈层这里，圈层越多，差值越多，信息差的获利就越容易。

怎么利用圈层

浸泡的圈层越多，你越能发现不同圈层的需求，进行搬运，因为一个圈层能做成的事情，在另一个圈层里也能做成。

教人赚钱、做副业这个事情，是最近才有的吗，已经存在很久了。在你7、8年前朋友圈里面的微商，就在发朋友圈试图这样做了。

但是在程序员这个圈子里，副业成为了一个热门词汇，很多程序员在探索做副业。

主要原因还是裁员潮、35岁危机等原因，让大家焦虑了，所以诞生了副业的诉求，那么谁更早的发现这部分诉求，谁就能赚到钱。

怎么赚到更多钱

卖的多

从量级阶段，想要卖的更多，有几个要素

• 流量


• 转化率


• 毛利率


• 复购率


• 转介绍率