和往年一样，又到了年底复盘的时候啦，但有点不同的是：我今年选择是农历的辞旧迎新之际写年终总结。

原因有几个，一个是回归我们传统的节日性跨年，另一个是整个2025年我其实有点茫然。

要赶在2026年元旦前更新文章，我还真有点来不及，因为我发现我有点 内容枯竭，不光其他平台断更，公众号上面也就写了8篇文章，创历史最低位。

影响这个的，我觉得和AI有很大关系，这个我后面再慢慢细讲，虽然断更这么久，但好歹是一年时间，做过的事情，收获的东西，遇到的问题也还是有，所以下面就开始罗列了。

二、事件

2025年的完成表和2024年年终文的计划还是有出入的，计划八大纲，完成度只能是算一半一半吧，除了弹幕小玩法没上架和小型单机游戏没做外，其他基本也都实现了。

1.小丑先生IP衍生的表情包上架，下载789个，转发2178次，打赏2个。

2.公众号《ZERO开发》发文8篇，视频号《北桥苏》视频更新4个，AI应用相关文章2篇。

3.小丑先生IP衍生的微信红包封面发布，累计拆红包数20307个，曝光数138196。

4.微信问一问《ZERO开发》创作分成开通，总发布数116条，曝光量16w，收获关注数410个。

5.个人资源（源码、资料、教程）整理完毕，免费分享，已完成频道建立。

6.个人微信服务号《51轻创》完成注册，发布小绿书9篇，暂停重新定位中。

三、收获

事情看上去好像并不多，而且数据也不好看，但是真实，也正应我今年的主题 “回归过程”，结果虽然重要，但是AI正在让过程变得更稀缺。

因为AI本质是一个黑盒的计算函数，没有人能理解他整个的计算过程，但却能在非常短的时间内给出计算结果。他让我们以前写解答式的技术文章变得毫无意义，这也是让我茫然并断更的主要原因。

我开通公众号到现在已经有十年了，早期的目的就是用于记录我平时在写代码时踩过的坑，既方便自己以后重新查找，也能让其他网友避免踩坑。

大家都知道计算机这一行有一个非常大的问题，就是迭代太快，必须要保持时刻学习并终生学习的态度。

为什么会这样呢？计算机科学是建立在确定物理学之上的假设，就是人为编造的，编程根本没有无法修改的东西，信息能记录和模拟万物，谁制定了规则，抢占了市场，那他就是要重新学习的东西。

而这种基于规则的东西，在AI看来就是洒洒水的事，你写再多再好的代码，写再多的技术性文章都没用。

同样也是断更的那段时间，偶然我发现微信问一问改版了，以前那种很AI味的回答完全没有流量了，更多的是大家生活中记录的真实感受和照片占据首页。

AI是“掌管信息的神”，他能取代我们，但我们也不一定非得自己写代码，我们就不能指挥他写吗？我们再把怎么指挥他的整个过程记录下来不是也挺好，今年主打收获一个心态！

四、计划

今年的收获和计划不是工业式的List，全是铺屏的文字，这样才有温度嘛，但是要提取成关键点就要拆分咯！

其实我一点也不怕AI能彻底结算我们这行，因为我们是人，世界那么大，需求也不是一成不变的，就像我们的爱好一样，也是随着时间一直在变。

就算强大的AI没有出现，我也会对基础物理感兴趣，就像知道了前后端，就会好奇Web的整个运行原理，知道了整个软件又会好奇硬件，后面又会涉及到电子信息和材料相关的学科。

有时候我也会抽空去逛华强北，了解什么叫实际需求的消费电子，也对整个PCB工艺有初步的概念，于是对PCB设计有了很大兴趣，可能后面会折腾一下电子DIY，当然画板，焊盘，写程序也在更进中。

当然关于信息类的程序，比如纯Web应用、游戏、编曲等也会支线进行，也会把折腾过程记录并分享出来。

五、结语

只能说一年的时间过得真快，世界变得很快，不管上一年计划要做的事完成的怎么样，我们还是要往前看。

停更的日子里，也非常感谢有小伙伴催更，说实话小伙伴越多，写文章和更视频都有点不好意思做得太水，以前就当个笔记自己看看，现在还是要多考虑内容到底对大家有没有帮助，不说要有多深刻，提供点情绪价值也可以。

最后要说得就是：AI真的很强，他是人类史上资金投入最多的一个重大工程了，未来我们不必和AI直接竞争，保持身体健康，回归过程，多记录多思考新时代的新机会，一起迎接AI革命后的科技果实。

为了在本地查看java程序运行后的线程，除了使用cmd命令、还可用到wmic、PowerShell，同时也为了怕被忘记，我就记录一下了。

二、命令介绍

1.cmd

命令提示符是Windows早期版本中的命令行界面，用于执行基本的系统管理任务和文件操作，对于老旧版本的Windows系统，cmd仍然是主要的命令行工具。

2.wmic

wmic 是一个用于管理和查询系统资源的命令行工具，基于WMI（Windows Management Instrumentation），可以获取和设置系统硬件、软件、操作系统等的详细信息。

常用命令包括 wmic process list brief（列出进程）、wmic cpu get loadpercentage（获取CPU负载）、wmic logicaldisk get size,freespace（获取磁盘空间信息）等。

使用方法是直接在cmd框中输入wmic指令即可。

3.PowerShell

PowerShell 是一个功能强大的脚本语言环境，用于管理和自动化系统任务；支持脚本编写、对象操作和高级的系统管理功能；内置了丰富的命令和模块，可以执行几乎所有的系统管理任务。

功能非常强大，支持复杂的脚本编写和高级的对象操作，提供了大量的内置命令和模块，可以执行几乎所有的系统管理任务。内置在所有较新的Windows版本中（Windows 7 及更高版本），并且在Windows 10和Windows 11中得到了进一步的增强。

通过win+X，或者右击win图标，选择Windows PowerShell，弹出一个蓝色的框。

三、命令使用

下面以程序名开头，获取进程ID，再根据进程ID查询详情（包括状态、线程数等），最后再根据进程ID，查询下面的所有线程并列出线程信息。

1.根据程序名获取进程

1

tasklist | findstr "java"

2.根据进程ID查看进程信息

1

tasklist /FI "PID eq 1234" /V

3.根据进程ID获取详细信息，线程总数

这里有有一个需要注意的点是，像Java程序运行后，JVM除了主线程外，还会开启多个子线程用于垃圾回收等操作。所以就算在程序中只开启了一个线程，加上自带的都会有十几个子线程。

而通过任务管理器，在详细信息中找到的进程，然后右键 “分析等待链”，列出的线程也就展示前两个的线程ID，而通过PowerShell可列出所有线程。

1

wmic process where processid=1234 get processid,threadcount

4.根据进程ID列出所有线程

1

Get-Process -Id 1234 | Select-Object -ExpandProperty Threads

5.直接根据程序名列出所有线程

1

Get-Process -Name notepad | Select-Object -ExpandProperty Threads

四、写在后面

在计算机科学中，进程、线程和协程是用于管理和调度任务的基本概念。而进程是操作系统进行资源分配和调度的基本单位。每个进程都有自己的独立地址空间，包括代码、数据和堆栈；进程可以包含一个或多个线程，并且每个进程由操作系统独立管理。

线程是进程中的执行单元，是操作系统进行调度的基本单位，线程共享进程的资源，如内存空间、文件句柄等，但每个线程有自己的堆栈、程序计数器和局部变量。

协程是一种用户态轻量级线程，可以暂停和恢复执行，而不像线程那样需要操作系统支持。协程可以理解为在单个线程中交叉执行的函数，作用还是提升单线程的利用率，减少资源占用。

而且他虽然不是由操作系统调度，但是也不是自己的业务程序分配哪个先哪个后，而是由支持协程的扩展或编程语言的运行时，里面封装调度器进行管理，比如执行到业务中定义的一个有IO操作的协程就会马上切到下一个协程，等上一个IO接触就返回给回调函数。

游戏被称为人类史上第九大艺术，它融合了文学、雕塑、电影、音乐等前八者造诣之和。所以在游戏创作中，如果是独立开发，在解决了编码、美术外，音乐音效也是一个亟需处理的一环。

而个人要对音效进行处理就不得不用到Audition了，比如你自己采集的声音，要进行降噪，音量增益等等操作。

由于我自己用过Adobe的其他产品，对Auditon就是拿来直接上手，折腾过后，为了防止忘记，就整理了一些常用而又比较难找的功能设置方法，那第一个就从音频降速开始。

二、操作流程

1.创建多轨

打开Audition CC后，默认情况下，点击左侧栏中的 “多轨”，填写工程名，模板，采样率，位深度就可以创建多轨项目了。

2.导入资源

点击文件栏目中的“文件夹图标”，也可以直接双击，弹出选择资源的框，选中音频文件就能作为资源，然后拖动音频文件到 “多轨编辑器”中就完成导入了。

3.操作音频

在编辑器中选中导入的音频文件，可以用菜单里的工具进行简单操作，比如切割，滑动，圈选等，最常用的就是切割，像剪辑视频一样操作。

4.拉伸模式

为了好看效果，我切割了一小段移到了第二个轨道，鼠标悬浮到音频片段的边缘一个“小三角形”，淡出淡出按钮旁边，放上去出现一个 “计时表图标”和“伸缩”文字。

如果没有这些图标，可以点击音频片段右键，找到“伸缩”->“伸缩模式”，选择 “实时”，最后再重复前面操作。

5.降速操作

鼠标悬浮出现“伸缩”时，鼠标向右拖动（大于100%），音频片段就会降速，将相当于对音频片段进行慢放，反之向左（小于100%），音频就会升速，播放时就相当于快进了。

这个操作常用于对音频的速度对齐，比如唱歌的干音快了几个拍子，就可以通过这种方式能匹配伴奏了，当然音效处理也可以。

三、写在后面

虽然标题是对音频的降速操作，但是这篇文章把基本的项目创建到基本操作也简单介绍了一遍，伸缩操作比较隐蔽所以就单独整理了一篇文章，如果要对音频添加效果，比如降噪、电音效果和混音，我后面再单独更新，要等待一下。

对于游戏开发的动画，可能大部分是采用第三方的制作工具单独完成，然后导入Unity3D 2020.3中。但是有些组件动画，比如像进度条这种，因为要完成色块移动控制，所以在Unity3D中实现更好。

二、操作流程

1.搭建基本结构

结构主要是先一个空对象，对象下添加Image对象作为进度条背景，与背景同级创建一个带Animation组件的对象，最后在带Animation组件对象下添加两个Image对象。

2.添加需要组件

Background添加Image组件；ObjAnima添加Rect Mask 2D组件和Animation组件；Animation01和Animation02添加Image组件。

3.创建Animation文件

在Assets资源管理中右键->Create->Animation，然后双击该文件打开Animation编辑器，点击Create保存到指定位置，文件后缀.anim。

4.Animation编辑

进入编辑框内，点击“Add Property”，出现弹出小框，会出现当前有Animation下的子级，点击下拉会显示子级的属性，像上下移动就选择Anchored Position就可以。

5.添加关键帧

为了实现无缝滚动，原理就是遮罩上一个图形往下移动，在视图中的图形往遮罩下面移动。也就只需对图形的Y轴进行操作。

6.匀速动画设置

设置时间轴默认情况是有缓入缓出的效果，播放的时候就没有无缝滚动的效果，这时候就需要在Curves下设置匀速。
按 “shift”选中两个关键帧，右键的时候不要离开关键帧的点，然后选择“Both Tangents‘，再点击 ”Linear“，看到线条变成直线就表示匀速播放了。

四、写在后面

通过上面操作就完成了一个简单的无缝上下滚动的进度条动画效果，并且没有通过脚本控制。还有一个容易忘记的点是，在打开anim文件时，一定要点击挂在该动画的对象上，不然是无法预览动画。

有时候在Unity3D中，要实现一些组件的圆角效果，比如进度条，不像普通按钮是静态不动的，可以直接将图片做成圆角。但是进度条是有那种色块流动的效果，如果不做处理，里面的色块会溢出四个角落。

二、实现前提

1.须使用Image的UI元素。

2.父层Image元素须遮罩组件。

3.父层Image元素图片须有圆角png图。

三、操作过程

1.在场景中创建一个Image的UI元素，图片是黑色有圆角的png图片。

2.在该Image中添加Mask组件（遮罩）。

3.在该Image下添加一个新的Image元素，Source Image选择一个其他颜色图。

4.对子级Image的Transform进行上下拖动，填充住父的遮罩就可以看到子级的元素也有圆角。

四、写在后面

以上的操作都是在Unity3D 2020.3中实现，除了用遮罩的方式实现圆角效果外，还可以用Shader，在效果上还没有锯齿，弧度更丝滑。后面有时间我再更新，以及如何在Unity3D中实现无缝循环的帧动画效果。

上次在本地简单部署了一个SSM框架的项目，由于非常繁琐的配置，我这次就试一下现在市面上非常火的SpringBoot。该框架基于Spring框架，由于在很多配置上采用了默认方式，所以在java应用程序构建上非常快速敏捷。

并且它还内嵌了tomcat、Jetty等服务器，使得它能作为一个独立的Jar文件运行，在生产环境上只需要用Nginx用反向代理指向该程序进度。

二、项目配置

通过前文关于maven的介绍，这里就跳过了，只按运行流程运行和部署项目。

1.导入项目

通过Open导入项目后，IDEA会立刻下载依赖，这时候你也可以去修改pom.xml然后再在Maven中，点击刷新按钮重新下载。

还有一个要注意的是可以给项目指定JDK版本，点击File->Project Structure->Project Settings->Project，找到Project SDK，然后可以根据框架版本切换JDK版本。

2.Artifacts设置

还是上面的Project Structure中，Artifacts中添加一个Web Application: Archive，主要用于项目打包输出。

3.直接运行

SpringBoot有内置的服务，所以一般打开项目后，在启动下拉里会自动有一个 “MainApplication”，如果没有出现，点击 “Edit Configurations”然后添加一个 “Spring Boot”,最后在Configuration进行设置即可。

4.运行访问

点击运行按钮 “run MainApplication”，就可以启动自身的web服务，然后浏览器通过启动面板里输出的地址进行访问了，URL在源码的controller里对应的控制器名/方法名。

三、打包部署

1.打包操作

打开IDEA的Maven，先点击 “Lifecycle” 的 “clean”，然后点击 “package”。等待执行完毕后，项目根目录就会新增 “target”，最外层也会新增一个jar包，这个就是项目的包了。

2.运行部署

SpringBoot 默认打包方式jar，如果需要在tomcat容器中，可以在pom.xml的packaging修改为war，以及添加对应的依赖包。而对于生产环境部署，执行指令和Nginx可以参考下面配置：

1

java -jar jesper_seckill.jar

1
2
3
4
5
6
7
8
9
10
11
12

server {
    listen 80;
    server_name yourdomain.com;

    location / {
        proxy_pass http://127.0.0.1:8080;  
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

四、Tomcat虚拟主机多项目部署

这里以SSM项目为例，那么先打开Tomcat下conf的server.xml，然后添加一个Host。

1
2
3

<Host name="www.ssmts.com" appBase="webapps" unpackWARs="true" autoDeploy="true" xmlValidation="false" xmlNamespaceAware="false">
<Context docBase="SSM" path="" reloadable="true" />
  </Host>

前提有三个，在host中创建了上面name的域名，docBase中的项目名，在webapps中一定有这个项目，第三个是要注意端口号，也就是Connector里指定的port。

最后在浏览器中直接输入”http://域名:端口/“, 就能直接访问项目了，如果是80端口可以不用指定，还一个是如果把打包的war直接放入webapps中，启动tomcat会直接解压到当前目录中。

五、其他问题

1.Tomcat输出中文乱码

找到Tomcat的conf下logging.properties，将java.util.logging.ConsoleHandler.encoding修改为GBK

1

java.util.logging.ConsoleHandler.encoding = GBK

2.IDEA编辑窗口关闭快捷键

打开settings->Keymap，直接搜索 “close”，选择Editor Tabs下的Close，然后右键清理快捷键，新增快捷键，我习惯 “Ctrl+W”，只需要按这两个键就可以，最后OK完成。

3.Tomcat项目访问

将编译后的项目复制到webapps中，启动tomcat，通过localhost:端口/项目名，可以直接访问对应项目。

五、写在后面

如果要让SpringBoot打包后的war在tomcat中使用，不光要移除自带的tomcat和添加依赖外，启动文件也需要做部分修改，不然放入tomcat容器内也无法启动。

上次简单介绍了一下 MCP，以及如何在 TRAR 中通过 MCP 实现一些 AI 功能，同时我也说过，以后的那些大型工具软件一定会加上自然语言驱动创作模块。

比如各种 Adobe、Autodask 等等系列软件，但是今天我要讲的一个开源轻量的 3D 建模软件 ——Blender，关于实现一个智能体，完成通过自然语言来控制 Blender 建模、贴图等基本操作。

二、环境清单

TRAE 0.5.7

Blender 4.0

Blender MCP

Python 3.10

三、BlenderMCP 介绍

要想用自然对话的方式在 Blender 中建模，就不得不提到 BlenderMCP 了，全称为 Blender Model Context Protocol，是一个旨在将 Blender 与 AI 模型无缝集成的工具。

它通过模型上下文协议（MCP）实现 Blender 与 AI 之间的双向通信，让用户能够利用自然语言指令来控制 Blender，从而极大地简化了 3D 建模和场景操作的流程，它主要由两个部分组成：Blender 插件和 MCP 服务器。

1. Blender 插件（addon.py）：该插件运行在 Blender 内部，负责创建 socket 服务器。它接收来自外部的命令，并在 Blender 中执行这些命令。例如，创建对象、修改材质等。插件还会将 Blender 的场景信息或操作结果反馈给外部服务器，实现双向通信。
2. MCP 服务器（server.py）：这是一个独立的 Python 服务器，实现了模型上下文协议（MCP）。它与 Blender 插件基于 TCP sockets 进行通信，接收用户通过 Claude AI 发出的指令，并将这些指令转换为 Blender 能够理解的命令。服务器还会处理 Blender 返回的结果，将其反馈给 Claude AI，形成一个完整的指令处理流程。

提示：下载整个项目后，只需要复制根目录下 addon.py (Blender 插件)，用于在 Blender 中插件安装，另一个 Server.py 也可以下载单独部署（最好直接用 TRAE 中 MCP 插件市场的）。

四、工具的交互流程

1. 启动 Blender TCP 服务

用户在 Blender 中启用 MCP 插件，插件自动创建基于 TCP Socket 的本地服务器（默认端口 5000），用于接收外部指令。

2. 智能体连接 TCP 服务

第三方智能体（如 Claude、自定义 Agent）通过 TCP/IP 协议 连接到 Blender 的 MCP 服务器，建立双向通信通道。

3. 自然语言指令输入与解析

用户向智能体输入自然语言指令（如 “创建一把椅子模型并导入 Blender”），智能体通过 NLP 模型解析意图，判断是否需要调用 Hyper3D Rodin。

4. MCP 协议转换与指令分发

智能体将自然语言转换为 JSON 的 MCP 指令，包含操作类型（如 generate_model）、参数（如 text_prompt: “一把椅子”）和目标工具。

5. 调用 Hyper3D Rodin API

Blender MCP 接收到指令后，通过 HTTP/RPC 接口 调用 Hyper3D Rodin 的模型生成服务，传递文本描述或参考图像参数。

6. 模型生成与数据返回

Rodin 的 AI 模型生成带 PBR 材质的 3D 资产，将结果以 .glb 或 .obj 格式 返回至 Blender MCP 的临时存储路径。

7. 模型导入 Blender 场景

Blender MCP 自动执行 bpy.ops.import_scene 等 Python API 命令，将生成的模型导入当前场景，并调整材质、灯光等参数。

五、开始操作

1. 安装 Blender 插件

打开 Blender，点击插件安装，找到前面 BlenderMCP 里复制出来的 addon.py，安装后并启用。

2. 添加 BlenderMCP 服务

打开 TRAE 编辑器，在 MCP 市场搜索后直接添加，也可以用前面下载的项目里 server.py 本地添加。

3. TCP 服务启动

打开 Blender，找到或按快捷键 “N” 找到 BlenderMCP 插件面板，端口 9876 可以自定，勾选 “Use Hyper3D Rodin 3D model generation”，Rodin 选 “hyper3d.ai”，API Key 使用免费测试的，点击 “Set Free Trial API Key”。

4. 创建 “Blender 助手” 智能体

打开 TRAE 的智能体，自定义名字，工具勾选 “blender”，提示词可以参考我下面的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

## 角色：
你是一名Blender智能建模助手，擅长将自然语言指令转化为精准的Blender操作（建模/材质/动画）

## 交互协议：
- 用户输入自然语言描述（如：“创建一个带纹理的科幻飞船”）
- 系统自动解析为Blender操作队列并执行
- 支持多轮迭代修改（例：“将船翼延长50%并添加推进器”）

## 技能
### 技能 1：建模能力
- 基础几何体：创建立方体/球体/柱体及参数化变形。
- 高级建模：布尔运算、表面细分、挤压、倒角、曲线建模
- 场景构建：排列物体、生成地形、建筑结构生成

### 技能 2：材质与渲染
- 自动分配基础材质（金属/玻璃/塑料）
- 支持UV映射指令（“为飞船添加锈迹贴图”）
- 基础光照设置（HDR环境光/点光源定位）

### 技能 3：动画基础
- 关键帧动画（“让立方体在5秒内旋转360度”）
- 路径动画（“沿曲线轨迹移动相机”）


## 注意事项：
### 指令精度要求
- 明确参数：“创建半径2m的球体”
- 模糊描述：“做个大一点的球”

### 能力边界声明：
- 不支持：角色骨骼绑定/流体模拟/复杂粒子系统
- 有限支持：有机生物模型（需分步指令）

### 容错机制：
- 当指令歧义时主动询问（“请指定圆柱体的细分段数”）
- 复杂操作分步确认（“即将执行20个操作，是否继续？”）

5. 连接 TCP 服务

在 Blender 开启服务后，我们可以用 windows 指令监听端口。

还有查看 TRAE 中 MCP 的 blender 是否可使用，如果是绿勾，表示已经连接上了。

1
2
3
4
5

// 查看端口
netstat -ano | findstr "9876"

// 查看进程
tasklist | findstr "3780"

6. 开始建模

打开 TRAE，开始用 前面创建 “Blender 小助手” 智能体对话，直接输入 “创建一把椅子”，随后就会在 Blender 创建了椅子的 3D 模型。

六、写在后面

更多的如材质与颜色添加、动画调整、游戏引擎导入、TCP 交互的 Json 串，以后我再更新。

其实目前看，不管是 AI 通过文本或图片生成的 3D 模型都存在布线不规整的问题，就像上面这把椅子，顶点和面都上万，而且还是三角面，如果用来做动画或导入游戏，二次修改和性能都是很大问题。

既然有痛点，自然也就有方案，市场上不光有很多降低面数、三角面转四角面教程，还有很多重拓扑的插件，都能提升现阶段让 AI 建模的可行性。

但是，随着 AI 的意图理解和生成精度不断提高，BlenderMCP 的未来发展前景还是非常广阔，一定能在游戏创作、建筑设计、工业设计上实现更高级的建模操作。

SSM是一个Java EE框架，也是一个Java企业级开发解决方案，它集成了Spring、Spring MVC和MyBatis三个核心框架。

下面我主要在IDEA中，怎么配置Maven，Tomcat，修改设置运行一套现有的SSM源代码。

二、Maven配置

这里的配置，是将前面单独安装和设置好了的Maven放入到IDEA中，让其在编辑器里构建项目时不会走默认的设置。

就比如之前将Jar包更换了默认下载位置，如果不在IDEA中指定还会下载到系统盘中，甚至还会又下载一个新的Maven。

1.导入项目

因为我是已经把源码下载到了本地，所以直接点击Open，然后找到项目地址，点击OK就导入进来了。

2.IDEA设置

找到File->Settins->Build,Execution,Deployment->Build Tools->Maven，打开后，主要对Maven Home Directory、User Settins file、Local repository这三个进行修改。

第一个指定maven安装位置的bin目录，第二个就是自己maven的配置文件，第三个是指定jar的下载位置。

3.验证设置结果

设置完毕后，找到IDEA的Terminal，输入mvn -version，查看版本号是否和之前安装的一致就可以了。

4.下载依赖

找到IDEA的最右侧，有一个折叠的Database、Maven、Ant栏目，点击Maven就会展开，再点击一个循环的图标，就会对项目的pom.xml文件里需要的依赖jar全部下载到本地仓库。

然后可以看项目的External Libraries和Maven栏目下的Dependencies，是否有加载到依赖，也可以进入本地依赖库查看是否多了那些jar包。

三、Tomcat配置

1.下载地址

浏览器t直接搜索Tomcat官方网站，但需要注意一下版本，也就是jdk的版本和tomcat的版本是有对应关系的。

2.jdk和Tomcat版本关系

3.Tomcat安装

下载后点击安装，然后找到安装后的文件夹，复制其绝对路径，打开电脑的环境变量，添加一个变量名CATALINA_HOME，值为tomcat的路径。

然后找到path，新增一个，将 %CATALINA_HOME%\bin 复制在里面。

4.启动测试

找到tomcat的bin目录下的startup.bat，点击启动，然后再在浏览器输入localhost:8080访问，出现tomcat的LOGO表示成功安装。

5.IDEA配置Tomcat

找到IDEA上面有一个锤子图标的右边，有个下拉，点击Edit Configurations，进入后点击+号，添加一个Tomcat Server。

点击Tomcat 7详情进行编辑，找到Application server，选择Tomcat的安装位置，下面的默认浏览器启动，端口号设置，地址等等就看自己了。

四、项目运行

依赖包已经下载好了，tomcat也配置了，接下来就是运行项目了。

1.修改配置

数据库导入还原就跳过了，在项目中主要是修改数据库的连接配置，找到src->main下的resources中jdbc.properties，对参数进行修改即可。

2.项目编译

在IDEA中，找到那个锤子图标，然后点击Build Project，也可以在命令窗口输入，mvn clean，然后mvn compile，这样就会把源码编译成class了。

编译成功后在项目根目录会出现一个target，里面就是编译后的class文件了。

3.项目运行

项目运行，点击锤子图标的右边的一排图标，其中有一个三角形播放状的图标，点击后就可以在IDEA中通过Tomcat运行了。

4.访问项目地址

有些项目入口文件没有页面指向，这时我们可以找到SpringMVC的配置文件，在resources的spring-web.xml中，可以看到相关开放的访问地址。

第二个可以在controller文件中，找到@RequestMapping(“/backend”)，控制器外层的是控制器名，里面的方法是方法名，然后在URL里输入localhost:8080/控制器名/方法名，就可以进入指定地址了。

五、写在后面

除了SSM框架外，还有更早期的SSH（Spring+Struts2+Hibernate），以及现在非常流行的SpringBoot，后面我也会再更新~

关于合并

如果shift选中两个模型，最后点击的是激活状态，那就是前一个合并到后一个，合并后的物体原点在最后一个物体上。

父级设置和骨骼绑定

如果shift选中两个模型，最后点击的是激活状态，那就是最后一个是父级，前一个会在最后一个模型下面作为子级，在大纲视图里可以通过shift拖动查看。

快捷键列表

常用插件

在 Java 企业级开发中，SSH 通常指的是 Struts2 + Spring + Hibernate 的组合。这个组合是一套常用的框架，用于构建 Web 应用程序。

其中Struts2用于处理 Web 请求和响应，实现 MVC（Model-View-Controller）模式；Spring用于实现依赖注入（Dependency Injection）和面向切面编程（Aspect-Oriented Programming）；Hibernate用于实现对象关系映射（Object-Relational Mapping, ORM），简化数据库操作。

早期这三个框架整合需要单独下载jar包的，现在使用Maven的话，只需要在pom中配置好依赖版本，编译的时候就可以自动构建了，下面就以一个简单的maven版SSH项目演示运行一下。

二、项目配置

导入这个项目后发现使用了jetty-maven-plugin，pom中也已经添加了struts、spring、hibernate的依赖，点击刷新依赖按钮就等待下载。

1.配置 Struts2

在src的项目包下，找到webapp/WEB-INF下面，没有就新建web.xml，配置 Struts2 过滤器；在resources中创建struts.xml，配置 Struts2 的动作映射和其他相关配置，页面怎么跳转就看那里了。

2.配置 Spring

在 src/main/resources 目录下创建 Spring 的配置文件，如 applicationContext.xml，配置 Spring 的 bean。

在 web.xml 中配置 Spring 的监听器来初始化 Spring 容器。

3.配置 Hibernate

在 src/main/resources 目录下创建 Hibernate 的配置文件，如 hibernate.cfg.xml 或使用 Java 注解，配置数据库连接信息。

三、项目构建

在Java的SSH（Struts2 + Spring + Hibernate）项目中，通常会按照MVC（Model-View-Controller）架构和分层设计原则来组织代码，这有助于项目的维护和扩展。

1.创建Action目录

Action是Struts2框架中的组件，它作为MVC架构中的控制器（Controller）。Action负责接收用户请求，处理用户输入，调用相应的服务逻辑，并决定返回哪个视图（页面）给用户。

具体功能：通常会处理表单提交、页面导航等用户交互操作，是前端请求和后端处理之间的桥梁。

2.创建Bean目录

Bean一般指的是Java中的实体类（也称为POJO，Plain Old Java Object），在SSH项目中，它们通常用于表示数据库中的表记录或者业务中的数据对象。

具体功能：Bean负责数据的封装，提供getter和setter方法来访问和修改数据属性。它们可以是模型（Model）的一部分，也可以是表单数据的载体。

3.创建Core目录

Core层通常指的是项目的核心模块，包含了核心业务逻辑和基础的功能实现。

具体功能：这个层可能包含一些通用的工具类、配置类等，是项目的核心逻辑所在，确保项目的稳定性和可维护性。

4.创建DAO目录

DAO（Data Access Object），DAO层是数据访问层，负责与数据库进行交互，封装了底层的数据访问逻辑。

具体功能：DAO层通常实现对数据库的CRUD（创建、读取、更新、删除）操作。通过使用Hibernate等ORM（对象关系映射）工具，可以简化数据访问的代码，提高开发效率。

5.创建Service目录

Service层是业务逻辑层，负责实现具体的业务逻辑处理。

具体功能：Service层会调用DAO层来获取数据，然后根据业务需求对数据进行处理和操作，最后可能还需要将处理后的数据返回给Action层。Service层的一个重要作用是封装业务逻辑，并提供给其他层调用。

五、写在后面

通过这种分层的设计，SSH项目可以更好地组织代码，使得每一层的职责更加明确，便于开发和维护。每一层都相对独立，降低了模块间的耦合度，提高了项目的可扩展性和灵活性。

上次简单记录了一下Java的单个文件的练习例子，从Hello World的打印到变量声明、数据类型、流程控制等简单的示例。

但是项目往往都是由多个文件组合强关联的，所以基于构建器来创建项目就很有必要了，下面我还是新手视角，用Maven创建Java项目做一个详细的入门总结。

二、Maven安装

1.下载

https://maven.apache.org/download.cgi

2.maven版本指南

因为Java版本和maven版本有关系，比如maven4.x以上的版本必须java 17及以上的，所以我罗列一下这些常用的版本对应关系。

3.安装

解压到电脑下的指定位置，然后找到Maven根目录下的conf文件夹下settings.xml，打开编辑，找到mirrors，添加国内的淘宝镜像，这样可以更快速构建项目。

1
2
3
4
5
6
7
8

<mirrors>
<mirror>
        <id>aliyun</id>
        <name>Aliyun Maven</name>
       <url>https://maven.aliyun.com/repository/public</url>
        <mirrorOf>central</mirrorOf>
    </mirror>
</mirrors>

4.添加环境变量

还是在Maven根目录找到bin，然后复制那个文件夹的绝对路径，在电脑的环境变量中的path添加maven的bin路径，比如我的 “D:\1setsoft\1dev\apache-maven-3.8.9\bin”。

5.验证

cmd输入mvn -v查看版本号，表示成功。

三、项目创建

1.maven构建项目

1

mvn archetype:generate -DgroupId=com.example -DartifactId=02_mysql_example -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

mvn archetype:generate: 这是Maven的命令，用于生成新的项目。

archetype:generate是Maven的原型插件的一个目标，表示要生成一个项目。

-DgroupId=com.example: 这是指定项目的groupId。

groupId通常是项目的组织或团队名称，使用反向域名的格式。在这个例子中，com.example是项目的groupId。 

-DartifactId=02_mysql_example: 这是指定项目的artifactId。

artifactId是项目的唯一标识符，通常是项目的名称。在这个例子中，02_mysql_example是项目的artifactId。 

-DarchetypeArtifactId=maven-archetype-quickstart: 这是指定要使用的原型的artifactId。

Maven原型是一个模板项目，用于快速生成符合Maven规范的项目结构。在这个例子中，maven-archetype-quickstart是一个基本的Java项目原型。

-DinteractiveMode=false: 这个参数用于指定Maven在生成项目时是否采用交互模式。false表示非交互模式，即Maven会直接使用命令行中提供的参数来生成项目，而不会提示用户输入。

如果设置为true，Maven会提示用户输入所需的参数。在这个例子中，Maven将不会进行交互式提示，而是直接使用已经提供的参数来生成项目。

2.项目配置

在项目编译前，对模板项目的pom.xml进行修改，指定项目运行的主类。打开项目的pom.xml，只需要找到文件的根节点，然后添加下面代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

<build>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>exec-maven-plugin</artifactId>
            <version>3.6.2</version>
            <executions>
                <execution>
                    <goals>
                        <goal>java</goal>
                    </goals>
                </execution>
            </executions>
            <configuration>
                <mainClass>com.example.App</mainClass>
            </configuration>
        </plugin>
    </plugins>
  </build>

节点说明

1
2
3
4
5
6
7
8
9
10

<groupid>（插件级别）：插件的唯一标识符。
<artifactid>（插件级别）：插件的基本名称。
<version>（插件级别）：插件的版本号。
<executions>：定义插件的执行配置。
<execution>：定义单个插件执行的详细信息。
<goals>：定义插件执行的目标列表。
<goal>：定义单个插件执行的目标。
<configuration>：定义插件的配置参数。
<mainclass>：定义项目的主类。
通过这些标签，您可以详细配置项目的构建过程，包括使用的插件及其行为。

3.编译运行

1

mvn compile

1

mvn exec:java

四、如何修改Maven本地仓库位置

默认情况下，maven会自动将项目的依赖下载到系统盘的.m2下，如果C盘空间告急的情况，可以通过对maven的配置将本地仓库位置放到指定位置。

找到maven下conf的settins.xml，在settings标签下添加：

1

<localRepository>D:\1setsoft\1dev\apache-maven-3.8.9\Repository</localRepository>

其实在那个文件里有被注释掉的关于本地仓库的配置和说明，然后再次mvn compile编译时就会把依赖下载到新的位置了。

五、MySQL增删改查案例

1.pom配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>02_mysql_example</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>02_mysql_example</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>

    <!-- MySQL Connector/J -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.26</version>
    </dependency>
    <!-- JUnit for testing -->

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>

  </dependencies>

  <build>
    <plugins>
    
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>exec-maven-plugin</artifactId>
            <version>3.6.2</version>
            <executions>
                <execution>
                    <goals>
                        <goal>java</goal>
                    </goals>
                </execution>
            </executions>
            <configuration>
                <mainClass>com.example.App</mainClass>
            </configuration>
        </plugin>

        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>

    </plugins>
  </build>
</project>

2.表格创建

1
2
3
4
5
6
7
8
9

CREATE DATABASE testdb;

USE testdb;

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) NOT NULL
);

3.业务逻辑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

package com.example;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

/**
 * 数据库连接
 *
 */
public class App 
{
    // 数据库连接信息
    private static final String JDBC_URL = "jdbc:mysql://localhost:3306/game";
    private static final String JDBC_USER = "root";
    private static final String JDBC_PASSWORD = "root";
    public static void main( String[] args )
    {
        // 连接数据库
        try (Connection connection = DriverManager.getConnection(JDBC_URL, JDBC_USER, JDBC_PASSWORD)) {
            // 插入数据
            insertUser(connection, "Alice", "alice@example.com");
            insertUser(connection, "Bob", "bob@example.com");

            // 查询数据
            List<User> users = selectUsers(connection);
            System.out.println("查询到的用户:");
            for (User user : users) {
                System.out.println(user);
            }

            // 更新数据
            updateUser(connection, 1, "Alice Smith", "alice.smith@example.com");

            // 查询数据（更新后）
            users = selectUsers(connection);
            System.out.println("更新后的用户:");
            for (User user : users) {
                System.out.println(user);
            }

            // 删除数据
            deleteUser(connection, 2);

            // 查询数据（删除后）
            users = selectUsers(connection);
            System.out.println("删除后的用户:");
            for (User user : users) {
                System.out.println(user);
            }

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 插入用户
    public static void insertUser(Connection connection, String name, String email) throws SQLException {
        String sql = "INSERT INTO users (name, email) VALUES (?, ?)";
        try (PreparedStatement pstmt = connection.prepareStatement(sql)) {
            pstmt.setString(1, name);
            pstmt.setString(2, email);
            pstmt.executeUpdate();
        }
    }

    // 查询用户
    public static List<User> selectUsers(Connection connection) throws SQLException {
        List<User> users = new ArrayList<>();
        String sql = "SELECT id, name, email FROM users";
        try (PreparedStatement pstmt = connection.prepareStatement(sql);
             ResultSet rs = pstmt.executeQuery()) {
            while (rs.next()) {
                int id = rs.getInt("id");
                String name = rs.getString("name");
                String email = rs.getString("email");
                users.add(new User(id, name, email));
            }
        }
        return users;
    }

    // 更新用户
    public static void updateUser(Connection connection, int id, String name, String email) throws SQLException {
        String sql = "UPDATE users SET name = ?, email = ? WHERE id = ?";
        try (PreparedStatement pstmt = connection.prepareStatement(sql)) {
            pstmt.setString(1, name);
            pstmt.setString(2, email);
            pstmt.setInt(3, id);
            pstmt.executeUpdate();
        }
    }

    // 删除用户
    public static void deleteUser(Connection connection, int id) throws SQLException {
        String sql = "DELETE FROM users WHERE id = ?";
        try (PreparedStatement pstmt = connection.prepareStatement(sql)) {
            pstmt.setInt(1, id);
            pstmt.executeUpdate();
        }
    }

}

class User {
    private int id;
    private String name;
    private String email;

    public User(int id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", email='" + email + '\'' +
                '}';
    }
}

六、写在后面

以上就完成了一个简答的Java项目构建，但是对于真正的项目多数还是会使用市面上成熟的框架，所以下次就是基于框架进行简单实战了，待更新~

在我们平时玩单机游戏卡关时，常常会在社区或群里找各种修改器或开挂软件。用来给血条蓝条加量，或者修改技能或武器，而这些工具其实都是通过修改游戏运行时的内存实现的。

所以，既为了学习C语言，也为了玩一下CE修改器，就本地用visual studio跑一个内存修改的程序。以java常驻内存为例，然后用CE扫描该java进程中指定值的内存地址，最后运行C程序修改内存的值。

二、开始操作

1.Java代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

public class MemoryOpera {

    public static String playerName = "InitialName";

// D5AF8E9C   -- D5AF8ECC  D5AF8F14
public static int playerHealth = 3598797;

public static void main(String[] args) throws Exception {

// 1730CF14   -- 1744CED4
int currentHealth = 7891;

Uitls tools = new Uitls();

// 0327F238 02BFF1B8
int num = tools.computerData();

// System.out.println("Process ID: " + ProcessHandle.current().pid());

System.out.println("Player: " + playerName + ", Health: " + playerHealth + ", CurHealth:" + num);

// 保持程序运行，等待 Cheat Engine 附加和修改
while (true) {
Thread.sleep(1000);
// 在这里通过 Cheat Engine 修改 playerName 或 playerHealth 后，会看到输出变化
System.out.println("[Running] Player: " + playerName + ", Health: " + playerHealth + ", CurHealth:" + num);
}
}

}


// Get-Process -Id 4792 | Select-Object -ExpandProperty Threads
class Uitls 
{
// 数据计算
public int computerData()
{
// 17980848  - 17330848
int startNum = 3598200;

// 17980850  - 17330850
int endNum = 3598202;

int totalNum = startNum + endNum;

return totalNum;
}

}

2.编译Java程序

1

javac -encoding UTF-8 MemoryOpera.java

3.运行Java程序

1

java MemoryOpera

4.查看程序进程ID

1

tasklist | findstr "java"

5.Cheat Engine打开Java进程

如果在进程列表中不好找，可以右键，选择 “手动输入PID” 或者过滤器，前者就把上面的进程ID放进去，后者就输入程序名，都可以筛选，最后打开。

6.查找内存地址

这里主要把程序运行后输出展示的数值粘贴进去，然后点击扫描就可以在结果中看到值对应的地址，最后把内存地址复制出来，当然在CE修改器中也能直接改。

7.创建C程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

#include <stdio.h>
#include <windows.h>

BOOL write_process_memory(HANDLE process, LPVOID address, LPCVOID data, SIZE_T size) {

    SIZE_T bytes_written;

    BOOL success = WriteProcessMemory(
        process,          // 目标进程句柄
        address,          // 要写入的地址
        data,             // 要写入的数据
        size,             // 数据大小
        &bytes_written    // 实际写入的字节数
    );

    if (success && bytes_written == size) {
        printf("成功写入 %zu 字节到地址 %p\n", bytes_written, address);
        return TRUE;
    }
    else {
        printf("写入失败! 错误代码: %lu\n", GetLastError());
        return FALSE;
    }
}

void example_windows() {
    // 假设我们有一个目标进程ID和要修改的地址
    DWORD target_pid = 10712;  // 替换为实际进程ID
    uintptr_t target_address = 0x027BF448;  // 替换为实际内存地址
    int new_value = 9999;

    // 打开目标进程
    HANDLE hProcess = OpenProcess(
        PROCESS_VM_WRITE | PROCESS_VM_OPERATION,
        FALSE,
        target_pid
    );

    if (hProcess == NULL) {
        printf("无法打开进程! 错误代码: %lu\n", GetLastError());
        return;
    }

    // 写入内存
    write_process_memory(hProcess, (LPVOID)target_address, &new_value, sizeof(new_value));

    // 关闭句柄
    CloseHandle(hProcess);
}

int main() {
    example_windows();
    return 0;
}

8.运行程序

在visual studio中创建的C++控制台程序，把上面代码复制过来，然后修改里面的进程ID，内存地址，修改值，最后点击运行按钮就直接编译运行了。

最后再回到Java运行的控制面板，发现里面不断输出的那个数值就被修改了。

TRAE是字节跳动推出的一款AI编程的得力助手，他可以作为插件安装在VSCode中，也可以作为编辑器独立使用。

分国内和国际版，国内版本可以选择豆包、DeepSeek等模型作为智能对话引擎，还能对接MCP Server等功能。

编程上可以直接通过自然语言对话，然后编辑器分解成自动化任务，自动执行，还是非常方便，我也是刚玩这个IDE，顺便整理了几个提示词，仅供参考。

二、写 MCP Server

1
2
3
4
5
6
7
8
9
10
11
12
13
14

我想写一个Go语言的计算器MCP Server，具体需求如下：

使用场景：能配置在Trae编辑器的本地MCP Servers中

已有环境：
1. Go 1.23.3
2. Trae CN 0.5.7

技术要求：
1. 使用mcp-go库，基于SSE模式
2. 该MCP Server中要添加工具、资源、提示词
3. 本地开启的端口是8090

请提供完整的代码实现，并可能配置到Trae中，不能让他启动时报错。

三、写豆瓣电影爬虫

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

我想写一个Python爬虫来爬取豆瓣电影Top250的信息，具体需求如下：

目标网站：https://movie.douban.com/top250

需要爬取的信息：
1. 电影排名
2. 电影名称（中文名+外文名）
3. 导演
4. 主演（最多3个）
5. 上映年份
6. 制片国家/地区
7. 电影类型
8. 豆瓣评分
9. 评价人数
10. 一句话简介
11. 电影海报图片链接

技术要求：
1. 使用 requests + BeautifulSoup 进行爬取
2. 添加合理的请求头，模拟正常浏览器访问
3. 设置随机延时（1-3秒），避免请求过快
4. 处理可能的反爬措施（如需要登录、验证码等）
5. 使用 logging 记录爬取进度
6. 异常处理：网络错误、解析错误等

数据存储：
1. 爬取的数据保存为 CSV 文件
2. 同时保存为 JSON 文件，方便后续处理
3. 图片链接单独保存在一个文本文件中
4. 使用 pandas 对数据进行简单清洗

额外功能：
1. 支持断点续爬（如果中途中断，下次可以继续）
2. 爬取完成后，生成简单的数据分析：
   - 各年代电影数量分布
   - 各国家/地区电影数量
   - 评分分布直方图
   - 导演作品数量排行（前10）

3. 生成一个 HTML 报告，展示爬取结果的统计信息

代码规范：
- 使用类来组织代码
- 添加详细的中文注释
- 遵循 PEP 8 编码规范
- 提供使用说明和依赖库列表

请提供完整的代码实现，并说明如何处理可能遇到的反爬问题。

四、写轮播图组件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

帮我写一个轮播图组件，要求如下：

使用场景：电商网站首页的商品推荐轮播

具体需求：
1. 基础功能：
   - 自动播放，每3秒切换一次
   - 鼠标悬停时暂停播放
   - 支持左右箭头切换
   - 底部有小圆点指示器
   - 支持手机端的左右滑动

2. 样式设计：
   - 轮播图尺寸：宽度100%，高度400px（PC端）/ 200px（移动端）
   - 图片要保持16:9比例，多余部分裁切
   - 左右箭头：半透明白色背景，hover时不透明度增加
   - 指示器：白色圆点，当前项为主题色 #ff6b6b
   - 切换动画：淡入淡出效果，持续时间300ms

3. 技术要求：
   - 使用 Vue 3 的 Composition API
   - 不依赖第三方轮播库，原生实现
   - 支持 TypeScript
   - 样式使用 CSS Module

4. 数据结构：
   传入的图片数组格式：
   [{
     id: 1,
     url: '图片地址',
     title: '图片标题',
     link: '点击跳转链接'
   }]

5. 额外功能：
   - 图片懒加载
   - 支持传入自定义切换时间
   - 暴露切换方法供父组件调用
   - 切换时触发 change 事件

请提供完整的 Vue 组件代码，包括详细的注释说明。

五、写瀑布流页面

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

我想做一个仿小红书的瀑布流图片展示页面，具体需求如下：

技术栈：
- 使用 React 18 + TypeScript
- 样式使用 Tailwind CSS
- 状态管理用 Zustand
- 图片懒加载使用 react-lazyload

页面结构：
1. 顶部搜索栏：
   - 左侧logo（文字"小蓝书"）
   - 中间搜索框，带搜索图标，placeholder"搜索你感兴趣的内容"
   - 右侧发布按钮

2. 瀑布流主体：
   - 两列布局（移动端），三列布局（平板），四列布局（桌面端）
   - 每个卡片包含：
     * 图片（宽度100%，高度自适应）
     * 标题（最多两行，超出显示...）
     * 作者头像（圆形，24px）和昵称
     * 点赞数（红心图标+数字）
   - 卡片hover效果：轻微上浮，阴影加深
   - 点击卡片有按压效果

3. 数据加载：
   - 首次加载20条数据
   - 滚动到底部自动加载更多
   - 加载时显示 loading 动画
   - 使用 mock 数据，包含不同高度的图片

样式要求：
- 整体风格清新简洁
- 主色调：#fe2c55（小红书红）
- 背景色：#f5f5f5
- 卡片背景：纯白，圆角 8px
- 适配 iPhone 12 及以上机型

交互效果：
- 下拉刷新功能
- 图片加载失败显示默认图
- 点赞动画：点击后红心放大再缩小
- 页面切换使用渐入效果

请生成完整的代码，包括组件拆分、样式处理和数据 mock。

六、写在后面

当然，这些提示词你也可以放到其他大模型下使用，下次我再整理一下自定义MCP Server的实践实例，敬请期待~

最近下了一个开源的游戏模拟器源码，准备想要修改的，但发现是用C++写的，奈何我之前没学过C，没得办法，就从零开始系统学习一下，于是就从环境搭建开始吧。

在windows下，有几种环境配置的方法，其中我觉得比较方便的是VSCode+MinGW方式，一个是编辑器中的扩展，一个是编译器。

二、安装

1.MinGW下载

1

https://sourceforge.net/projects/mingw-w64/

2.安装

选择一个版本，我这里是8.1解压后放到指定位置，将文件夹bin放到系统环境变量path中。

3.验证

cmd输入g++ –version查看版本号，其中gcc常用于编译C语言、g++编译C++。

4.编译指令

1

gcc main.c -o main

通过将main.c文件编译成main.exe，本地可以直接在命令总运行，可以查看程序的打印结果。

1

./main.exe

三、VSCode配置

1.安装C/C++扩展

打开VSCode，点击左侧活动栏的扩展图标（四个方块组成的图标），再搜索 “C/C++”，找到由Microsoft提供的 “C/C++”扩展并点击安装。

2.创建C项目

添加一个C语言文件，比如main.c 。

3.配置任务

点击左侧活动栏的调试图标（一个带虫子的图标），然后点击 “Run and Debug”，选择 “C/C++: gcc.exe build and debug active file‘，项目根目录的.vscode中会自动生成task.json，laugch.json并运行程序。

VSCode下TERMINAL也就是控制台自动显示程序执行的打印，还一种运行程序的方式是，当打开指定文件时，点击窗口的右上角的运行按钮（三角标）也可以执行。

四、其他

1.cmd控制台乱码

当代码中有中文打印时，在cmd中显示乱码，主要原因是源码是UTF-8编码，而电脑是中文lang，cmd默认编码GBK，所以解决方法就是让源码和控制台的编码保持一致就行。

我的做法就是修改控制台的编码方式，首先通过下面命令查看代码页，936代表是GBK，65001代表UTF-8

1

chcp

如果要修改成一个指定编码，比如UTF-8的，可以执行下面命令，最后再./name.exe就可以看到中文打印了。

1

chcp 65001

我有个习惯，学习任何一门编程语言都不喜欢上来就各种重型IDE、项目管理工具。所以，放到Java上，我还是喜欢直接用javac编译，然后直接运行。

二、安装

1.安装包

下载JDK并安装到本地。

2.操作

E:\2setsoft\1dev\jdk1.8.0_77添加到环境变量，改名为JAVA_HOME

3.验证

cmd输入javac -version查看版本号，表示成功。

三、项目创建

1.创建java单文件

比如Hello.java文件。

2.添加打印代码

1
2
3
4
5
6
7
8

public class HelloWorld {

    public static void main(String[] args) {
    
        System.out.println("Hello  World! 2025-10-14 13:50");
    }

}

3.编译代码

将上面的HelloWorld类编译成class

1

javac -encoding UTF-8 HelloWorld.java

运行成功后在当前文件夹下会生成 HelloWorld.class

4.运行代码

在当前文件夹下，找到生成的class，然后命令输入。

1

java HelloWorld

6.打包成jar

前面也是要先将程序编译成class，然后运行下面代码。

1

jar cvf Calculator.jar  Calculator.class

四、附加

1.java版计算器程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

import java.util.Scanner; 
import java.util.ArrayDeque; 
import java.util.Deque; 
 
public class Calculator {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in); 
        System.out.println("🧮  Java 控制台计算器");
        System.out.println("════════════════════"); 
        System.out.println(" 支持操作: +, -, *, /");
        System.out.println(" 输入格式: 数字 运算符 数字 (如: 2 + 3 * 4)");
        System.out.println(" 输入 'exit' 退出程序");
        System.out.println("════════════════════"); 
 
        while (true) {
            System.out.print("➤  输入表达式: ");
            String input = scanner.nextLine().trim(); 
            
            if (input.equalsIgnoreCase("exit"))  {
                System.out.println("🛑  程序已退出");
                break;
            }
            
            if (input.isEmpty())  {
                System.out.println("⚠️  错误：输入不能为空");
                continue;
            }
            
            try {
                double result = evaluateExpression(input);
                System.out.printf("✅  计算结果: %s = %.2f\n\n", input, result);
            } catch (Exception e) {
                System.out.println("❌  错误: " + e.getMessage()); 
            }
        }
        scanner.close(); 
    }
 
    /**
     * 计算表达式值（支持运算符优先级）
     * @param expression 数学表达式 
     * @return 计算结果
     * @throws IllegalArgumentException 非法输入时抛出异常 
     */
    public static double evaluateExpression(String expression) {
        // 移除所有空格
        String expr = expression.replaceAll("\\s+",  "");
        
        // 检查非法字符
        if (!expr.matches("[\\d.+\\-*/]+")) {
            throw new IllegalArgumentException("包含非法字符");
        }
        
        Deque<Double> numbers = new ArrayDeque<>();
        Deque<Character> operators = new ArrayDeque<>();
        
        for (int i = 0; i < expr.length();  i++) {
            char c = expr.charAt(i); 
            
            // 处理数字（包括小数）
            if (Character.isDigit(c)  || c == '.') {
                StringBuilder numBuilder = new StringBuilder();
                while (i < expr.length()  && 
                      (Character.isDigit(expr.charAt(i)) || expr.charAt(i) == '.')) {
                    numBuilder.append(expr.charAt(i++)); 
                }
                i--; // 回退一步 
                
                try {
                    double number = Double.parseDouble(numBuilder.toString()); 
                    numbers.push(number); 
                } catch (NumberFormatException e) {
                    throw new IllegalArgumentException("无效数字格式: " + numBuilder);
                }

            } 
            
// 处理运算符 
            else if (isOperator(c)) {
                while (!operators.isEmpty()  && 
                      hasPrecedence(c, operators.peek()))  {
                    calculateTop(numbers, operators);
                }
                operators.push(c); 
            } else {
                throw new IllegalArgumentException("无效字符: " + c);
            }
        }

        
        // 计算剩余操作 
        while (!operators.isEmpty())  {
            calculateTop(numbers, operators);
        }
        
        if (numbers.size()  != 1 || !operators.isEmpty())  {
            throw new IllegalArgumentException("无效表达式格式");
        }
        
        return numbers.pop(); 
    }
 
    /**
     * 执行栈顶运算 
     */
    private static void calculateTop(Deque<Double> numbers, Deque<Character> operators) {
        if (numbers.size()  < 2 || operators.isEmpty())  {
            throw new IllegalArgumentException("运算符缺失");
        }
        
        double b = numbers.pop(); 
        double a = numbers.pop(); 
        char op = operators.pop(); 
        
        switch (op) {
            case '+': numbers.push(a  + b); break;
            case '-': numbers.push(a  - b); break;
            case '*': numbers.push(a  * b); break;
            case '/': 
                if (b == 0) throw new ArithmeticException("除零错误");
                numbers.push(a  / b); 
                break;
            default: throw new IllegalArgumentException("不支持的操作符: " + op);
        }
    }
 
    /**
     * 检查运算符优先级 
     * @param current 当前运算符 
     * @param previous 栈顶运算符 
     * @return 当前运算符是否优先级较低或相等
     */
    private static boolean hasPrecedence(char current, char previous) {
        if (previous == '(' || previous == ')') return false;
        return (current != '*' && current != '/') || 
               (previous != '+' && previous != '-');
    }
 
    private static boolean isOperator(char c) {
        return c == '+' || c == '-' || c == '*' || c == '/';
    }
}

五、写在后面

基本的单demo文件练习结束后，熟悉了程序编译和运行，但是对java的基础语法还是需要认真研究一下，虽然和C#类似，待更新~

在从一个模型到，完成贴图，完成蒙皮（骨骼绑定）后，已经算是一阶段的任务完成了，因为这样既可以拿去做Mod，也可以直接导入动作源完成动画。但是对于独立游戏，为了差异化，有些动作还是要自己制作的，所以就有了下面的这个3D模型的动画制作过程，最后也会演示一下如何导入CocosCreator等游戏引擎中。

二、动画制作

1.打开时间线

记得是在姿势模式下，然后在Blender底部把 “时间线” 拉高一点，折叠的 “汇总” 也点击展开来。

2.开始K帧

点亮 “自动插帧” 按钮，将关键帧放到0帧位置，开始对某个骨骼进行变换，旋转，移动等，然后再移动到指定关键帧位置再变换，播放一下就可以看到动画了。

三、多组动画

在游戏引擎中导入模型时，一个模型往往会制作多组动画，比如待机、攻击、死亡、大招等不同的动作，开发只需要在开发时添加控制器，不同的时候播放对应的动画即可。

1.动画摄影表

从 “时间线” 切换到 “动画摄影表”，然后再选择 “动作编辑器”，点击 “新建动作”，然后还是和前面一样，在指定帧数位置做变换。

2.切换动作

在编辑了多组动作后，大纲里只会显示一个动作，要想查看需要切换，为了好记，在新建动作时可以重命名，然后在 “浏览要关联的动作” 的地方进行切换。

四、游戏引擎中使用

我这里为了方便，就没用这个机械臂了，直接拿之前已经导进去的Fbx做示例了。

1.导入CocosCreator

首先将有动画的模型导出为Fbx，然后将其复制到CocosCreator项目的assets下的某个位置。

2.拖入模型

在游戏场景下，先创建一个空节点，然后把已经放到项目资源目录下的Fbx，拖入在该节点下。

3.创建脚本

给新建的空节点绑定一个脚本，脚本接收一个SkeletalAnimation属性，也就是带动画的Fbx，就是空节点下的整个目录拖入。

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

import { _decorator, Component, SkeletalAnimation, input, Input, EventMouse, Vec3 } from 'cc';

const { ccclass, property } = _decorator;

@ccclass('MyPlayController')
export class PlayController extends Component {

    @property({ type: SkeletalAnimation })
    public CocosAnim: SkeletalAnimation | null = null;

    start() {
this.CocosAnim.play();
    }

    onMouseMove(event: EventMouse) {
        console.log(event);
    }

    update(deltaTime: number) {
        
    }

    onStartButtonClicked() {
        this.CocosAnim.play();
    }

    onStopButtonClicked() {
        this.CocosAnim.stop();
    }

}

4.开始运行

这个只要是启动就自动播放，而且Fbx只有一个时间线的默认动画，没有多动作组，其实也差不多，就只是对指定动作进行播放。

五、写在后面

如果只是制作游戏，到这里就完全够用了，但如果是影视后期的话，还有渲染部分，因为在制作完模型还要放到实拍场景中，目前这个我也还不会，等后面学习了我再总结一下了。

不知道大家有没有玩过一些单机游戏的Mod，比如《侠盗猎车》里主角变成奥特曼，各种新能源汽车乱入等等。这些都是别人对原有模型就行修改换皮，并重新绑定骨骼完成的，所以如果会了骨骼绑定后，你也就可以自己制作一些模型到单机游戏里，当然还要一些解包封包的技巧，这个有时间聊，那下面开始Blender的骨骼绑定实操了。

二、模型准备

1.创建模型

我这里以一个机械臂为例，先添加一个立方体变形成长方体，然后添加一个圆柱体，添加时设置顶点为8。

2.快速复制

为了让骨骼绑定的效果更明显，我们要做一个两个节点的机械波，可以对前面的部分进行快速复制（Shift+D）到指定位置，然后按快捷键 ~ 进行视角切换，用来对齐前面的组合。

三、骨骼设置

1.添加骨骼

点击添加->骨架->单段骨骼，一开始他会被模型挡住，这时候找到属性的 “物体” ->视图显示，勾选 “在前面”，还可以把名称显示出来。

2.骨骼挤出

点击骨骼，进入 “编辑模式”，再点击骨骼头部的小圆点，工具栏选择 “挤出” 或按快捷键 “E”，然后朝着需要的方向拖动就能在上一个骨骼上创建一个子骨骼。

3.断开骨骼链接

我这里要做的是第一个骨骼是根骨骼，而他下面的子骨骼要放到模型的内部去。所以就需要和根骨骼进行断开，然后移动子骨骼到指定位置。

首先点击框选，选中两个骨骼，然后按快捷键 “Alt+P”，

四、骨骼绑定

1.模型绑定

切换到物体模式，Shift 选中所有的模型和骨骼(一定要最后选骨骼)，快捷键 “Ctrl+P”，然后选择 “附带自动权重”。

2.姿势模式

点击骨骼，进入姿势模式（只有骨骼物体特有），选中一个骨骼，然后在工具栏选择 旋转，可以发现旋转或移动骨骼，模型也会相应的变换，但还是有个问题，因为是自动权重，有时候后面的骨骼会影响到前面的模型变形，这时候就要我们手动刷一下权重了。

3. 顶点组

还一个看是否绑定成功的方法：进入物体模式，点击一个模型，然后在属性视图找到 “数据”->“顶点组”，里面就是当前模型能被哪些骨骼影响，如果要删除绑定，在顶点组里移除就可以。

五、重刷权重

1.进入权重绘制

先切到物体模式，然后选中一个模型，再选择 “权重绘制”，还是找到 属性->数据->顶点组，里面某一个骨骼都有对当前模型的权重。

红色到蓝色，接近等于红色权重越高，而越接近蓝色等于蓝色权重越低，为了让对应骨骼能有效控制对应的模型部分，所以就单独进行修改了。

2.修改权重

在能准备修改权重时，最好是能知道顶点组里的每个名称是对应哪个骨骼，在对模型上颜色（权重值）进行修改时，有几个选项，如下：

• F Add (加法)：用于增加选中的权重值。
• F Darken (变暗)：减少选中的权重值，使其变得更暗或更接近0。
• F Draw (绘制)：直接设置选中的权重值，覆盖原有的权重值。
• F Lighten (变亮)：增加选中的权重值，使其变得更亮或更接近1。
• F Mix (混合)：以一种混合的方式结合新绘制的权重值与原有权重值。通常会根据新旧权重值的比例进行混合。
• F Multiply (乘法)：将新绘制的权重值与原有权重值相乘，这通常会使权重值变得更小。
• F Subtract (减法)：从原有权重值中减去新绘制的权重值，降低该区域的权重。

六、其他

1.设置模型关系

设置模型关系就是父子关系，如果将一个模型作为一个模型的子级，那父级移动旋转他也会移动旋转，在相对规则的动画下可以用这种方式代替骨骼绑定。

而操作方法有两种：一个是在 “大纲视图”选中一个模型，将其移到另一个模型下，那他就是这个模型的子级了；另一个方法是Shift选中两个模型，“Ctrl+P” 后选择 “物体”，后面就可以看到两个模型间有根虚线。

2.模型合并

为了能后面对模型进行权重绘制，最好对这四个模型合并，不然就是每个都绘制一遍权重。先在物体模式下，Shift 选中四个模型，然后按快捷键 “Ctrl+J”；

七、写在后面

权重重新修改后，就可以进入姿势模式看效果，旋转一下刚刚超出控制范围的骨骼，如果没有之前那种大范围变形，且比较符合你的预期。

那么，后面就可以开始用这个骨架进行动画制作了，和Spine类似，在时间轴上做不同的变换，当然里面很多细节性的技巧也有，那下一篇就开始了。

通过上一篇文章的简单介绍，我们就可以独立完成模型的创建，但还只是一些灰溜溜的轮廓，少了鲜艳的表皮。所以，这篇文章就开始介绍如何制作皮肤，就是给模型着色，下面就用一个立方体做示例了。

二、UV编辑

1.标记缝合边

选中物体，进入编辑模式后，选择 “边选择模式”，点击物体的一个边，按 “shift” 选中了多个边。怎么选择看你自己对物体剖开的边，UV编辑就是相当于对一个立方体的空包装盒展开平铺。

选择了多个边后，右键选择 “标记缝合边”，此时的这几条边会加粗显示，代表成功标记，然后打开导航栏的 “UV编辑”。

2.UV展开

进入UV编辑后，会有两个窗口，一般左边是展开的样子，右边是模型的样子。但是刚开始左边是没有UV的，这时候我们在右边的模型的全选，可以直接快捷键 “A”，也可以点击 “选择”-> “全部”，然后左边就可以看到展开后的样子了。

三、着色编辑

1.进入着色器编辑

进入着色器编辑有两种方式，一种是回到导航栏的 “布局”，在下面部分，时间轴点击 “编辑器类型”（回放的左边），然后选择 “着色器编辑器”。另一个就直接点击导航栏的 “着色”。

2.添加纹理

进入着色编辑器后，点击 “添加”->“纹理”->“图像纹理”，然后将新弹出的纹理的 “颜色” 连接到“原理化BSDF”的 “基础色”。

3.新建图像

新建图像就是给UV上色后的一张图片，也就是模型导出后的皮肤图。找到刚刚添加的那个图像纹理，然后点击 “新建”，输入名称，其他的默认就可以，最后点击确定。

四、纹理绘制

1.进入纹理绘制

找到导航栏里的 “纹理绘制”，一般也有有两个窗口，左边是UV展开，右边是模型，一开始都是黑色的。不过要先确认一下左边UV展开窗口上面，是不是显示图像绘制，关联的图像是不是你新建图像的名称。

2.开始绘制

绘制就在右边窗口，可以旋转角度的上色，我这里是直接填充蓝色，然后再切换到自由线（画笔），在一个面上涂上绿色，用作区别。

3.保存图像

绘制完毕后，在左边UV展开窗口上面，找到 “图像”，然后保存，这样就把绘制的皮肤存下来的，后面如果你导出模型出来，要和这张图一起发给别人。

五、预览和导出

1.预览

绘制和保存图像后，如果我们要先整体预览一下，可以回到导航栏的 “布局” 或者 “建模”，只需要把着色方式改成 “材质预览” 就可以了。

2.导出

导出的格式有很多，我就以常用的FBX为例，但需要注意的是，纹理有两种，一种是分开为单独的图片，另一种是纹理直接内嵌到FBX中。

点击导出，选择FBX，弹出的窗口，路径模式，如果是内嵌式纹理，要选择 “复制”，然后把右边的小图标打开，最后导出就可以了。

六、写在后面

经过这一顿操作，就可以结合布线，拿现有的模型就行调整了，比如换皮肤加一些装饰等等。但只是静态的，要想在游戏中使用或者对游戏改Mod，还需要做骨骼绑定，制作动画，所以接下来就是Blender这方面的实操了，敬请期待~

大家都知道，现在AIGC领域日新月异，今天AI大模型能生成粗糙的3D模型，明天就能做成商业级的3D模型，但是如果想要一些细节上也有的，还是需要自己手动对模型的布线进行调整，然后再蒙皮等等。

所以，AI大模型强大的当下，如果我们是独立开发者或建模爱好者，还是有必要再系统性学习一下基础的建模流程。因为这个世界每当有新技术出现，且能大幅提升生产力的同时，还会继续保有手工的余地的。

再回到主题，我这个Blender入门教程，其实并不很系统，都是我零零散散实践后总结的。一是给自己做的建模备忘录笔记，二是给同样是作为开发者（非专业建模）的同学，用来快速入门作参考。因为我们职业类似，视角应该也差不多，直接看专业的教程可能比较晦涩，我的虽然粗糙但是浅显易懂呀。

二、操作

1.新建项目

打开Blender软件，点击常规。

2.添加网格

进入窗口后，默认有三个物体，分别是：摄像头、灯光、立方体网格，第一次玩的话，可以先不管这些，直接添加一个新的网格，点击 “添加->网格->立方体”。

3.编辑模式

在对网格编辑前，可以先了解一下物体的几个交互模式： 物体模式、编辑模式、雕刻模式、顶点绘制、权重绘制、纹理绘制、姿态模式。

因为物体有分很多种，比如上面的摄像头网格外，还有骨架、文本等等，而不同的物体就有不同的交互模式，像骨架就没有什么权重绘制什么的。

网格的就比较多，要对他进行修改，就要选择 “编辑模式”，切换后，左侧工具栏就会多了很多像：挤出选取、环切、倒角、切割等等工具。

4.移动快捷键

这个是我自己总结的叫法，分别是旋转视图和移动视图，因为在对模型修改时特别常用，所以快捷键用起来很方便。

旋转视图（拖动时可以查看模型的各个角度的面）：鼠标中键盘，移动视图（拖动时平移窗口）：shift+鼠标中键，缩放视图：滚轮滚动。

5.模型环切

选择网格，进入编辑模式，选中网格体，然后工具栏选 “环切”，对每个面添加切线，也可以用快捷键 “Ctrl+R” 按住不放再滚动滚轮，能快速切分网格， 如下图（正/上: 4x3，侧: 3x3）。

6.模型挤出面

点击 选择模式的 “面选择”，然后点击两侧的一个面，用来延伸出类似手臂的挤出面。选中面后点击工具栏的 “挤出选区”，拖出来就可以了。

7.添加镜像生成器

视图着色方式选择 “线框显示”，工具栏选择 “框选”，然后框选左侧一边后删除顶点。找到属性栏的修改器，添加修改器->生成->镜像，因为我们是以Z轴切的，所以对称是Y轴，添加后就可以看到下面图形了。

8.挤出头部和腿部

用同样的方法，将头部和腿部用模型挤出面实现，最后我们一个人形的简单模型就创建成功了。当然要建人物模型，这种方法是不对的，我这里只是演示了一下基本创建和变形的用法。

五、写在后面

模型创建只是演示，其实我们最主要目的是熟悉布线的基本方法后，用来对AI生成的、别人做好的模型进行修改。而对模型的修改，布线只是小部分调整，最主要还是修改皮肤，然后重新做动画，所以我后面就是纹理绘制和蒙皮、动画了。

.Net是一个集合了丰富的类库和工具的开发平台，由于他几大主要的组件，使他支持C#、VB、F#等多种编程语言，同时能开发Web应用、桌面应用、控制台应用、移动应用、游戏开发、嵌入式物联网应用、云和微服务等多种类型的应用程序。

之前只是记录了.Net的环境的搭建，这次将通过一个简单的控制台应用，介绍一下.Net项目的创建，其中包括Visual Studio工具配置、依赖安装、项目创建、项目运行等。

二、创建项目

点击 文件->新建->项目，在弹出的窗口中，搜索模板：“控制台应用” 或者 ”Console App“。然后选择目标框架：.Net Core 或 .Net Framework （注.高版本如.Net 6已经部分整合了.Net Core和.Net Framework），最后输入项目名，保存。

三、依赖安装

由于我的项目是一个别人写的游戏后台服务，里面有MySql.Data的依赖，所以在运行代码前需要先安装。这里有个小Tips，就是对依赖安装位置的修改，如果不修改，以后下载的都在C盘了。

1.修改依赖位置

打开visual studio，工具->NuGet包管理器->程序包管理器设置->NuGet包管理器->配置文件，然后打开三个文件中的NuGet.Config，添加下面代码（注. globalPackagesFolder位置）。

1
2
3
4
5
6
7
8
9

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <packageSources>
    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" />
  </packageSources>
  <config>
<add key="globalPackagesFolder" value="E:/2setsoft/4other/visual-studio-nuget" />
  </config>
</configuration>

2.下载依赖

继续从工具里找到 ”管理解决方案的 NuGet 程序包“。

点击进去后，点击 ”浏览“，搜索 需要的包，找到后点击安装。

3.检查是否引用

安装完毕后，进入”解决方案资源管理器“，展开 ”引用“，是否有安装的包。

如果在引用中没有看到安装的包，或者有感叹号，可以对项目进行清理。点击菜单下 生成->清理解决方案，然后再 ”重新生成解决方案“。

四、运行程序

安装依赖后，项目根目录会生成一个packages.config，入口文件一般是Mian.cs或Program.cs。然后点击 调试->开始执行，随后就会弹出一个控制台窗口，同时项目根目录的bin文件夹也会生成exe文件。

五、写在后面

在几个开发平台间，再结合市场和我个人，我还是觉得用.Net更适合一点。首先如果是用的Unity3D引擎，C#语言就是无缝衔接，而且在Visual Studio中有直接和Unity联调的选项，在帧同步网络框架也有很多，比如GDNet、ENet-C#等等。