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;
  }
}

我的问题可能不是＆＃34;好＆＃34;关于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
        )
);

Answer 2

我有编译问题导致我认为我的想法会起作用：

lambda仅在需要时进行转换，例如：它使用lambda作为单个抽象方法的实现站点来生成该接口的实现。
事实证明，Javac和Eclipse都没有接受调用UIView，newFile脱离上下文。如果失败，则cd 类型的方法newFile(String)未定义。

因此，我将注入FileManipulatorTest作为参数（我试图避免）。

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

2 个答案: