lambda - 使用 lambda 提供基于堆栈的上下文(例如文件操作的路径)

Question

我已经想到了一种微妙的方式(可能已经实现和讨论过)在 Groovy 中执行此操作(取自 Groovy documentation here )并且我正在尝试改进它，如果可能的话:

ant.sequential {
    echo("inside sequential")
    def myDir = "target/AntTest/"
    mkdir(dir: myDir)
    copy(todir: myDir) {
        fileset(dir: "src/test") {
            include(name: "**/*.groovy")
        }
    }
    echo("done")
}

这个例子很好，但我不是在做一个基于 Ant 的程序:我想做一些流畅的 API 来操作文件和目录(我们称之为 FileManipulator，我不擅长名称:))。

基本上这将是:

new DefaultFileManipulator(Paths.get("root")).with(() -> {
  newFile("file1");          // create file      root/file1
  newFile("file2");          // create file      root/file2
  cd("directory1", () -> {   // create directory root/directory1
    newFile("file1");        // create file      root/directory1/file1
    cd("directory1", () -> { // create direcotry root/directory1/directory1
      newFile("file1");      // create file      root/directory1/directory1/file1
    });
    newFile("file2");        // create file      root/directory1/file2
  });
}); 

具有以下界面:

interface FileManipulator {
  FileManipulator with(LambdaFileManipulator m);
  FileManipulator cd(String path, LambdaFileManipulator m);
  Path newFile(String path) throws IOException;
}

@FunctionalInterface
interface LambdaFileManipulator extends FileManipulator {
  void execute() throws IOException;
  default FileManipulator with(LambdaFileManipulator m) {
    return FileManipulatorStack.manipulatorFor(this).with(m);
  }
  // for each non default method of FileManipulator, the same call to FileManipulatorStack.manipulatorFor(this).
}

DefaultFileManipulator简单地实现 FileManipulator并使用 AbstractFileManipulator下面定义。

因为我希望路径是相对的，所以我需要以某种方式保留 lambda 上下文(我不想弄乱当前的工作目录):我使用这样操作的堆栈来做到这一点:

// visibility package, because that's technical stuff!
class FileManipulatorStack {
  private static final Map<LambdaFileManipulator , ArrayDeque<LambdaFileManipulatorDelegator>> stacks = new ConcurrentHashMap<>();

  static LambdaFileManipulatorDelegator manipulatorFor(final LambdaFileManipulator delegatee) {
    final ArrayDeque<LambdaFileManipulatorDelegator> stack = stacks.get(delegatee);
    if (null == stack) {
      throw new IllegalStateException("state is empty for [" + delegatee + "]");
    }
    return stack.getLast();
  }

  static void delegate(final Path scopedPath, final LambdaFileManipulator delegatee) {
    final LambdaFileManipulatorDelegator handler = new LambdaFileManipulatorDelegator(scopedPath);
    final ArrayDeque<LambdaFileManipulatorDelegator> stack = stacks.computeIfAbsent(delegatee, key -> new ArrayDeque<>());
    stack.addLast(handler);
    try {
      delegatee.execute();
    } catch (final Exception e) {
      throw new DelegatedFileCreatorHandlerUndeclaredException(e);
    } finally {
      final LambdaFileManipulatorDelegator ss = stack.removeLast();
      if (ss != handler) {
        throw new IllegalStateException("invalid stack");
      }
      if (stack.isEmpty()) {
        stacks.remove(delegatee);
      }
    }
  }

  static class LambdaFileManipulatorDelegator extends AbstractFileManipulator {
     ... constructor ... 
  }
}

abstract class AbstractFileManipulator implements FileManipulator {
  private final Path root;
  public AbstractFileManipulator(Path root) {
    this.root = requireNonNull(root, "root");
  }

  public final FileManipulator with(LambdaFileManipulator m) {
    FileManipulatorStack.delegate(root, m);
    return this;
  }

  public final FileManipulator cd(String path, LambdaFileManipulator m) {
    FileManipulatorStack.delegate(root.resolve(path), m);
    return this;  
  }

  public final Path newFile(String path) {
    Path p = root.resolve(path);
    Files.createFile(p);
    return p;
  }
}

关于 Stackoverflow 规则，我的问题可能不是“好”，但这里是:

如何在不添加 FileManipulator 的情况下改进这一点作为 lambda 的参数(我会使用 Consumer 代替)？

使用 lambda 作为映射的键有问题吗？ (在 this comment 中，它说 lambda 将动态转换为 LambdaFileManipulator 的实例，然后我可能不需要堆栈映射)。

我是否错过了 Java 8 的某些特性，这些特性允许我使 lambda 成为某个类的实现方法？

编辑:我回答了我自己的问题......这行不通，因为 lambda 不/从不知道它是 FileManipulator 的实现.所以，它不能调用那些方法。它可能使用静态方法(和一些上下文)工作，但我认为它比使用参数更糟糕。

Answer 1

我看不出它怎么可能看起来像显示的示例，其中 newfile() 和 cd() 在它们前面没有对象的情况下被调用。

它们不是静态函数，封闭类没有理由实现这些。

我想出了这个不使用 lambdas 但可以运行与您的示例非常接近的东西。

enum FileActionType {
    CD, NEWFIlE;
}

class FileAction {

    final public String name;
    final public FileActionType type;
    final public FileAction actions[];

    public FileAction(String name, FileActionType type, FileAction[] actions) {
        this.name = name;
        this.type = type;
        this.actions = actions;
    }
}

实现静态函数:

public static void execute(File f, FileAction... actions) {
    f.mkdirs();
    for (int i = 0; i < actions.length; i++) {
        FileAction action = actions[i];
        switch (action.type) {
            case CD:
                execute(new File(f, action.name), action.actions);
                break;

            case NEWFIlE:
                try {
                    Files.createFile(new File(f, action.name).toPath());
                } catch (IOException ex) {

                }
                break;
        }
    }
}

public static FileAction cd(String name, FileAction... actions) {
    return new FileAction(name, FileActionType.CD, actions);
}

public static FileAction newFile(String name) {
    return new FileAction(name, FileActionType.NEWFIlE, null);
}

像这样使用:

execute(
        new File("/tmp/test"),
        newFile("file1"), // create file      root/file1
        newFile("file2"), // create file      root/file2
        cd(
                "directory1",
                newFile("file1"), // create file      root/directory1/file1
                cd("directory1", // create direcotry root/directory1/directory1
                        newFile("file1") // create file      root/directory1/directory1/file1
                ),
                newFile("file2") // create file      root/directory1/file2
        )
);