java - 重构扫描文件夹类(添加AllwaysPassesBlocker())

我需要在FolderScan中创建一个新的构造函数，该构造函数包含“ Checkers”列表。并且所有这些“ Checkers”始终为return true（请写出仅返回true的新Chekers List。）
但是问题是我不知道该怎么做并且不分解程序的结构。

代码（FolderScan和每个Cheker）：

class FolderScan implements Runnable {

    FolderScan(String path, BlockingQueue<File> queue, CountDownLatch latch,
            File endOfWorkFile) {
        this.path = path;
        this.queue = queue;
        this.latch = latch;
        this.endOfWorkFile = endOfWorkFile;

        checkers = new ArrayList<Checker>(Arrays.asList(
                new ExtentionChecking(),  new ProbeContentTypeCheking(),
                new EncodingChecking() ));
    }

        @Override
public void run() {
    try {
        findFiles(path);
        queue.put(endOfWorkFile);
        latch.countDown();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

    private void findFiles(String path) {

    try {
        File root = new File(path);
        File[] list = root.listFiles();
        for (File currentFile : list) {
            boolean checksPassed = true;
            if (currentFile.isDirectory()) {
                findFiles(currentFile.getAbsolutePath());
            } else {
                for (Checker currentChecker : checkers) {
                    if (!currentChecker.check(currentFile)) {
                        checksPassed = false;
                        break;
                    }
                }

                if (checksPassed) {
                    queue.put(currentFile);
                }
            }
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }


    private String path;
    private BlockingQueue<File> queue;
    private CountDownLatch latch;
    private File endOfWorkFile;
    private List<Checker> checkers;
}

class ExtentionChecking implements Checker {

    @Override
    public boolean check(File currentFile) {
        fileName = currentFile.getName().toLowerCase();
        Set<String> extensions = new HashSet<String>(Arrays.asList(".txt",
                ".pdf", ".doc", ".docx", ".html", ".htm", ".xml", ".djvu",
                ".djv", ".rar", ".rtf", ".tmp"));

        if (extensions.contains(fileName.substring(fileName.lastIndexOf(".")))) {
            return true;
        }

        return false;
    }

    private String fileName;
}

class EncodingChecking implements Checker {

    @Override
    public boolean check(File currentFile) {
        return detectEncoding(currentFile);
    }

    public static boolean detectEncoding(File file) {
        detector = new CharsetDetector();

        // validate input
        if (null == file) {
            throw new IllegalArgumentException("input file can't be null");
        }
        if (file.isDirectory()) {
            throw new IllegalArgumentException(
                    "input file refers to a directory");
        }

        // read input file
        byte[] buffer;
        try {
            buffer = readUTFHeaderBytes(file);
        } catch (IOException e) {
            throw new IllegalArgumentException(
                    "Can't read input file, error = " + e.getLocalizedMessage());
        }

        if(detector.setText(buffer) != null){
            return true;
        }

        return false;
    }

    private static byte[] readUTFHeaderBytes(File input) throws IOException {
        // read data
        FileInputStream fileInputStream = new FileInputStream(input);
        try {
            byte firstBytes[] = new byte[50];
            int count = fileInputStream.read(firstBytes);
            if (count < 5) {
                throw new IOException("Poor file!");
            }
            return firstBytes;
        } finally {
            fileInputStream.close();
        }
    }


    private static CharsetDetector detector;
}



class ProbeContentTypeCheking implements Checker {

    @Override
    public boolean check(File currentFile) {
        String mimeType = null;
        try {
            Path path = Paths.get(currentFile.getAbsolutePath());
            byte[] data = Files.readAllBytes(path);
            MagicMatch match = Magic.getMagicMatch(data);
            mimeType = match.getMimeType();
        } catch (MagicParseException | MagicMatchNotFoundException
                | MagicException | IOException e) {
            e.printStackTrace();
        }

        if (null != mimeType) {
            return true;
        }

        return false;
    }
}

题：


如何重构此代码-在此之后可以使newAllwaysPassesBlocker()并使所有Checers返回true？

最佳答案

始终返回true的检查器将是

class UncriticalChecker implements Checker {
    @Override
    public boolean check(File currentFile) {
        return true;
    }
}

不过，将这样的检查器添加到检查器列表毫无意义。您最好将列表留空。

我不太清楚为什么应该在FolderScan的构造函数中构造检查器。将它们作为参数传递给构造函数似乎更自然。

FolderScan(String path, BlockingQueue<File> queue, CountDownLatch latch,
        File endOfWorkFile, List<Checker> checkers) {
    this.path = path;
    this.queue = queue;
    this.latch = latch;
    this.endOfWorkFile = endOfWorkFile;
    this.checkers = checkers;
}

然后，当您初始化FolderScan时，将其传递给检查程序

List<Checker> checkers = new ArrayList<Checker>(Arrays.asList(
            new ExtentionChecking(),  new ProbeContentTypeCheking(),
            new EncodingChecking() ));
FolderScan folderScan =
    new FolderScan(path, queue, latch, endOfWorkFile, checkers);

或者，如果您希望创建一个返回所有文件的FolderScan，则向其传递一个空列表。

FolderScan folderScan =
    new FolderScan(path, queue, latch, endOfWorkFile, Collections.emptyList());

编辑：
我现在了解到您希望测试课程。然后，UncriticalChecker就有意义了。如果要使用始终显示“是”的检查器来测试代码，请将其传递给构造函数：

List<Checker> checkers = Collections.singletonList(new UncriticalChecker());
FolderScan folderScan =
    new FolderScan(path, queue, latch, endOfWorkFile, checkers);