起因
去年底计划1月份开源新版 mybatis-mapper 并发布 1.0 的正式版，整个项目的主要功能已经稳定，为了更方便开发人员使用，计划提供一个代码生成器，然后就把精力投入代码生成器的设计和实现，由于石家庄疫情和多方面的原因搁置。
后来有时间之后就开始设计并实现最简单的代码生成器，代码生成器非常简单，功能很强大，这是一个和 MyBatis 没有直接关系的工具，因此不包含在 mybatis-mapper 项目中，mybatis-mapper项目中会包含一个可用的代码生成器 jar 包和模板示例文件，这个代码生成器已经可以使用，不过由于目前的精力在这个独立的代码生成器，因此还没发布 mybatis-mapper 的 1.0 正式版，距离正式发布不远了。
代码生成器可以直接在磁盘生成文件，基本功能实现之后就开始扩展一些更方便的功能。能不能在生成文件之前先预览生成的代码呢？能不能修改预览的代码后在写入到实际的文件？
在实现代码生成器过程中就设计了很多可以扩展的接口，这些接口用于创建目录和创建文件，因此想到了实现一个虚拟文件系统 VFS 来实现预览，而且基于 VFS 还可以有更多的方便的功能可以集成到代码生成器。
场景
新设计实现的这个代码生成器不仅仅可以生成代码文件，还可以生成完整的项目结构，可以是简单的一个模块，还可以是 Maven 多模块项目，因此生成代码时，会生成复杂的项目结构，像具体的目录中会生成静态、代码、配置等文件。
提供一个 VFS，在生成目录时创建一个虚拟的目录结构，写入文件时也写入到虚拟的文件中，通过这种简单的方式就能实现项目结构和代码的预览功能。VFS不仅可以用于这里的预览，只要和目录和文件有关的场景都可以用到。
设计思路和接口说明
代码一共两个类，700 行左右代码，行数较多，但是主要功能原理非常简单，这里主要介绍设计思路和接口的说明。
字段设计
一个目录或者文件，最重要的就是名称和内容，还要有办法区分是目录还是文件。对于支持多级结构的文件系统来说，记录文件的结构非常重要。想要作为一个虚拟文件系统，所有文件有必要全部使用 相对路径。Java中想要方便处理路径，需要灵活使用 java.nio.file.Path。
为了用尽可能少的字段实现必要的功能，VFSNode 虚拟文件系统节点类中用到的字段如下：
/**
* 文件名
*/
protected Path name;
/**
* 文件内容，常用的文本，个别情况有特殊类型的资源文件
*/
protected byte[] bytes;
/**
* 文件历史 <时间,内容>
*/
protected Map<String, byte[]> history;
/**
* 文件类型 enum Type {/*目录*/DIR, /*文件*/FILE}
*/
protected Type type;
/**
* 父节点，当前节点删除时需要通过父节点断开和当前节点的关系
*/
protected transient VFSNode parent;
/**
* 下级目录
*/
protected List<VFSNode> files;
基本方法设计
因为是虚拟文件系统，不能使用操作系统提供的接口判断文件类型，因此创建该类型时需要提供文件名和类型：
protected VFSNode(Path name, Type type) {
this.name = name;
this.type = type;
}
对于虚拟文件来说，上面两个属性决定了一个唯一的文件，因此重写下面两个方法：
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
VFSNode vfsNode = (VFSNode) o;
return name.equals(vfsNode.name) && type == vfsNode.type;
}
@Override
public int hashCode() {
return Objects.hash(name, type);
}
根据 Type 可以很简单的判断是目录还是文件：
protected boolean isDirectory() {
return Type.DIR == type;
}
protected boolean isFile() {
return Type.FILE == type;
}
当需要读取文件时，80% 是在读取文本，因此直接提供一个极简的读文件内容方法：
protected String read() {
if (isFile()) {
return new String(this.bytes);
}
return null;
}
写入文件内容时稍微复杂一个，上面有一个没提到的 Map<String, byte[]> history 字段，为了记住文件的修改历史和修改时间，直接通过一个简单的 Map 进行了记录，方便修改时查看历史版本。
protected void write(byte[] bytes) {
//如果已经存在内容就记录到历史
if (ArrayUtil.isNotEmpty(this.bytes)) {
if (CollUtil.isEmpty(history)) {
this.history = new LinkedHashMap<>();
}
this.history.put(DateUtil.now(), this.bytes);
}
this.bytes = bytes;
}
工具类如
DateUtil都使用的 hutool
再看一个简单的方法，想要删除当前节点，有多种方式，这里设计了最接近 Java 文件本身的操作，就是在节点上执行 delete() 方法，虚拟文件系统不会有文件真正删除，需要把层级关系断掉，因此删除当前节点时就需要从父节点的子节点列表中删除当前节点。
protected void delete() {
if (this.parent != null) {
this.parent.files.remove(this);
this.parent = null;
this.files = null;
this.bytes = null
this.history = null;
} else {
throw new UnsupportedOperationException("无法删除根目录");
}
}
遍历子文件方法
默认的 File 提供了 listFiles 方法来获取子文件，当前类中除了 setter 和 getter 方法外，如果要遍历子文件，总要判断子文件是否为空才能继续，因此提供一个方便的 forEach 方法进行遍历：
public void forEach(Consumer<VFSNode> action) {
if (CollUtil.isNotEmpty(files)) {
files.forEach(action);
}
}
在后续打印文件目录结构的一个方法中，遍历时需要判断当前节点是否为最后一个节点，因此提供一个上面遍历节点的变种方法：
public void forEach(BiConsumer<VFSNode, Boolean> action) {
if (CollUtil.isNotEmpty(files)) {
int size = files.size();
for (int i = 0; i < size; i++) {
action.accept(files.get(i), i < size - 1);
}
}
}
上面方法通过一个示例来展示用法，如何输出当前的目录结构：
protected void print(StringBuilder buffer, String prefix, String childrenPrefix) {
buffer.append(prefix);
buffer.append(name);
buffer.append('\n');
forEach((next, hasNext) -> {
if (hasNext) {
next.print(buffer, childrenPrefix + "├── ", childrenPrefix + "│ ");
} else {
next.print(buffer, childrenPrefix + "└── ", childrenPrefix + " ");
}
});
}
后面测试时会用该方法输出一个树形结构的效果。
重点方法 - 创建文件
当我们在当前目录下面增加一个文件时，实现非常简单：
private void addChild(VFSNode child) {
if (CollUtil.isEmpty(this.files)) {
this.files = new ArrayList<>();
}
this.files.add(child);
child.parent = this;
}
同样获取指定名词的子节点也非常容易：
private VFSNode getChild(Path name) {
if (CollUtil.isNotEmpty(files)) {
for (VFSNode file : files) {
if (file.name.equals(name)) {
return file;
}
}
}
return null;
}
基于这些简单的方法，当我们在当前目录增加一个相对路径为 a/b/c/d.txt 文件时，就开始复杂了。
先看下面的方法定义：
/**
* 添加子孙级节点
*
* @param node 节点信息
* @param relativePath 节点相对路径
*/
protected void addVFSNode(VFSNode node, Path relativePath)
方法中的是参数为要添加的文件（节点）node，该文件对应的相对路径relativePath。虚拟文件中想要处理好目录结构，一定要使用相对路径，并且处理好路径之间的关系。
相对路径 relativePath 在这里的作用就是要根据路径找到当前节点要 addChild 的位置，找到位置加进去就可以，在找路径的过程中，如果路径不存在，就创建相应的路径节点，一级一级添加，直到 node 节点找到父级将自己 addChild。下面是方法的实现：
protected void addVFSNode(VFSNode node, Path relativePath) {
//获取相对路径有几级（几个/分开的内容）
int nameCount = relativePath.getNameCount();
//大于1的时候存在多级，等于1的时候就到当前 node 节点了
if (nameCount > 1) {
//获取第一级目录名
Path name = relativePath.getName(0);
//查找当前目录是否存在对应的子节点
VFSNode vfsNode = getChild(name);
//子节点不存在时就创建
if (vfsNode == null) {
//中间节点一定是 DIR 类型
vfsNode = new VFSNode(name, Type.DIR);
//添加到当前子节点
addChild(vfsNode);
}
//现在有了子节点 vfsNode，对于原有的 a/b/c/d.txt 来说，现在 a 就是 vfsNode
//接下来就在在 a 中查找或者创建 b/c/d.txt，也就是 a/b/c/d.txt 需要截取 a/
//然后调用 vfsNode.addVFSNode(node, "b/c/d.txt")
//当递归到 d.txt 时就是下面 nameCount == 1 时了
vfsNode.addVFSNode(node, relativePath.subpath(1, nameCount));
} else if (nameCount == 1) {
//当在 c.add(node, "d.txt") 时就到了这里
//此时判断该文件是否已经存在，如果不存在就直接 addChild 添加到子节点
//已经到最后一级，如果不存在子文件，或者子文件不包含当前文件，就添加进去
if (CollUtil.isEmpty(this.files) || !this.files.contains(node)) {
addChild(node);
}
}
}
现在可以添加任意的相对路径文件了。
重点方法 - 查找文件
有了记录好的 VFS 文件后，现在如何获取指定相对路径的文件，得到文件后可以读取内容、写入内容，还可以删除文件，因此 查找文件 是许多功能的基础。
protected VFSNode getVFSNode(Path relativePath) {
//获取层级数
int nameCount = relativePath.getNameCount();
//多级时
if (nameCount > 1) {
//获取第一级
Path name = relativePath.getName(0);
//查找第一级
VFSNode vfsNode = getChild(name);
//如果存在就递归查找下一级
if (vfsNode != null) {
//到下一级时，相对路径需要去掉第一级
return vfsNode.getVFSNode(relativePath.subpath(1, nameCount));
}
} else if (nameCount == 1) {
//已经到最后一级，此时的 relativePath 就是最后要查找的文件名
//从子节点查找即可
return getChild(relativePath);
}
//节点不存在时返回 null
return null;
}
封装 VFS
到现在也只是在一个 VFSNode 中实现了几个方法，还看不到如何真正应用，而且这里提供的 Path relativePath 最初是相对谁的位置呢？
为了方便使用，在这个基础上继续封装，增加 VFS 类如下：
public class VFS extends VFSNode {
private Path path;
private VFS(Path path) {
super(path.getFileName() != null ? path.getFileName() : path, Type.DIR);
this.path = path;
}
/**
* 创建VFS
*
* @param path 根路径
* @return
*/
public static VFS of(Path path) {
return new VFS(path);
}
/**
* 创建VFS
*
* @param path 根路径
* @return
*/
public static VFS of(String path) {
return new VFS(toPath(path));
}
这里的VFS相当于根目录，通过 path 指定，所有其他文件都是相对 path 的相对路径。VFS中提供了一些简单的路径转换方法：
/**
* 相对路径
*
* @param file 文件
* @return
*/
public Path relativize(File file) {
return path.relativize(file.toPath());
}
/**
* 相对路径转换
*
* @param relativePath 相对路径
* @return
*/
public static Path toPath(String relativePath) {
return Paths.get(relativePath);
}
因为使用的相对路径，并且通过 VFS.path 确定了根目录，因此当添加文件时必须是 VFS.path 下面的文件，当计算相对路径时，如果出现 ../../a/b，其中 ../ 意思是当前目录的上级目录，有多个就需要逐级向上查找。因为不能超出 VFS.path 目录，所以不能出现 ../ 的情况，所以增加下面检查的方法：
/**
* 检查相对路径
*
* @param relativePath 相对路径
*/
private void checkRelativePath(Path relativePath) {
if (relativePath.getNameCount() > 0) {
if (relativePath.getName(0).toString().equals("..")) {
throw new RuntimeException(relativePath + " 超出当前虚拟文件系统的范围");
}
}
}
有了上面基础，再看如何创建目录。
VFS - mkdirs
大部分方法为了方便调用，提供了多种参数形式，例如 File file，String relativePath 和 Path relativePath，
前两种参数通过上面的转换方法都可以变成 Path relativePath，mkdirs 对应3种参数的方法如下：
/**
* 创建指定目录
*
* @param file 文件
*/
public void mkdirs(File file) {
mkdirs(relativize(file));
}
/**
* 创建指定目录
*
* @param relativePath 相对路径
*/
public void mkdirs(String relativePath) {
mkdirs(toPath(relativePath));
}
真正要实现的 mkdirs 方法：
/**
* 创建相对目录
*
* @param relativePath 相对路径
*/
public void mkdirs(Path relativePath) {
checkRelativePath(relativePath);
addVFSNode(new VFSNode(relativePath.getFileName(), Type.DIR), relativePath);
}
似乎也没做什么，直接调用了 addVFSNode 方法，这个方法参数为 VFSNode node, Path relativePath，
所以这个方法是通过 new VFSNode(relativePath.getFileName(), Type.DIR) 创建了最终要添加的 node 节点，
添加的位置就是相对路径 relativePath。到这里就用上了 VFSNode 中的方法，有了 mkdirs 方法后，
创建目录的示例代码如下：
VFS vfs = VFS.of("/");
vfs.mkdirs("/a");
vfs.mkdirs("/a/b");
vfs.mkdirs("/a/c");
//为了验证不会重复添加
vfs.mkdirs("/a/c");
vfs.mkdirs("/a/d/e.txt");
此时调用前面提供的 print 方法时输出的内容如下：
/
└── a
├── b
├── c
└── d
└── e.txt
前面 print 方法有好多个参数，该怎么用呢，直接在 VFS 中封装如下：
public String print() {
StringBuilder print = new StringBuilder();
print(print, "", "");
return print.toString();
}
在控制台输出树形结构时就简单的：
System.out.println(vfs.print());
未完，待续…
本想今晚不写代码，写个博客早点睡，没想到博客也写了几个小时还没介绍完，关于代码内容的介绍就先到这里，后续再继续写，为了让大家提前看到这个 VFS 具体的用途，下面贴几段代码展示真正的功能。
虽然是虚拟文件系统，但是还要和真实文件进行交互，所以先看个真实文件的例子：
@Test
public void test() {
String userDir = System.getProperty("user.dir");
//绝对路径
VFS vfs = VFS.of(userDir);
//绝对路径
vfs.mkdirs(new File(userDir + File.separator + "doc"));
//创建相对路径的目录
vfs.mkdirs("src/main/java");
//写入文件
vfs.write("README.md", "# Hello VFS");
//写入绝对路径文件(相对userDir)
vfs.write(new File(userDir + File.separator + "pom.xml"),
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
//输出文件结构
System.out.println(vfs.print());
//写入到指定磁盘目录
vfs.syncDisk(new File(userDir, "target/Hello"));
//输出到压缩文件
vfs.syncDisk(new File(userDir, "target/Hello.zip"));
}
输出的目录结构如下：
vfs
├── doc
├── src
│ └── main
│ └── java
├── README.md
└── pom.xml
生成的文件如下：
上面方法最后将虚拟文件内容写入到指定的目录和ZIP压缩文件中了。同样还提供了方法可以直接加载指定目录或者ZIP文件：
@Test
public void testLoad() {
VFS vfs = VFS.load(new File(userDir));
System.out.println(vfs.print());
vfs.syncDisk(new File(userDir, "target/loadFile.zip"));
}
输出的目录结构如下：
vfs
├── .DS_Store
├── target
│ ├── test-classes
│ │ ├── tk-mapper.zip
│ │ ├── io
│ │ │ └── mybatis
│ │ │ └── rui
│ │ │ └── test
│ │ │ └── VFSTest.class
│ │ ├── tk-mapper
│ │ │ ├── mapper.java
│ │ │ ├── model-lombok.java
│ │ │ ├── mapper.xml
│ │ │ ├── generator-demo.yaml
│ │ │ └── model.java
│ │ └── simplelogger.properties
│ ├── generated-sources
│ │ └── annotations
│ ├── classes
│ │ └── io
│ │ └── mybatis
│ │ └── rui
│ │ ├── VFSNode$Type.class
│ │ ├── VFSNode.class
│ │ └── VFS.class
│ ├── Hello.zip
│ ├── generated-test-sources
│ │ └── test-annotations
│ └── Hello
│ └── vfs
│ ├── pom.xml
│ ├── README.md
│ ├── doc
│ └── src
│ └── main
│ └── java
├── vfs.iml
├── pom.xml
├── README.md
└── src
├── test
│ ├── resources
│ │ ├── tk-mapper.zip
│ │ ├── tk-mapper
│ │ │ ├── mapper.java
│ │ │ ├── model-lombok.java
│ │ │ ├── mapper.xml
│ │ │ ├── generator-demo.yaml
│ │ │ └── model.java
│ │ └── simplelogger.properties
│ └── java
│ └── io
│ └── mybatis
│ └── rui
│ └── test
│ └── VFSTest.java
└── main
└── java
└── io
└── mybatis
└── rui
├── VFS.java
└── VFSNode.java
有了这个VFS之后，通过适当的使用就能实现一些方便的功能，比如 预览代码，将生成的代码保存到一个压缩包中从浏览器下载。
获取源码
整个代码生成器在前期不会开源，会提供很多方便的工具可以直接免费使用，代码生成器中的部分代码通过博客、文档等方式进行介绍和分享，如果理解文章内容，而且对 VFS 有需求就可以自己实现一下。
如果你想直接获取 VFS两个类文件的源码，可以回复留下自己邮箱。