面试题：Java文件读取写入异常处理与资源管理的深度优化

Question

在Java文件读取与写入过程中，可能会遇到各种I/O异常，如文件不存在、权限不足、磁盘空间不足等。请详细说明如何全面且优雅地处理这些异常，确保程序的健壮性。同时，如何在复杂的业务逻辑中，合理管理文件资源，避免资源泄漏，特别是在使用了多个流和通道的情况下。请结合代码示例和设计模式进行说明。

Answer 1

异常处理

1. 文件不存在异常：在读取文件时，如果文件不存在，FileInputStream 等构造函数会抛出 FileNotFoundException。可以使用 try - catch 块捕获该异常，并进行适当处理，如提示用户文件不存在，或者尝试创建文件。

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileReadExample {
    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("nonexistent.txt");
        } catch (FileNotFoundException e) {
            System.out.println("文件不存在，请检查文件名或路径。");
        }
    }
}

2. 权限不足异常：当试图访问没有足够权限的文件时，会抛出 SecurityException 或 IOException（例如 FileOutputStream 在权限不足时可能抛出 IOException）。同样使用 try - catch 块捕获异常，向用户提示权限问题，并记录日志等。

import java.io.FileOutputStream;
import java.io.IOException;

public class FileWriteExample {
    public static void main(String[] args) {
        try {
            FileOutputStream fos = new FileOutputStream("/system/read - only - file.txt");
        } catch (IOException e) {
            System.out.println("权限不足，无法写入文件。");
        }
    }
}

3. 磁盘空间不足异常：在写入文件时，磁盘空间不足可能导致 IOException。捕获此异常后，可以向用户提示磁盘空间不足，并提供清理磁盘空间的建议。

import java.io.FileOutputStream;
import java.io.IOException;

public class DiskSpaceExample {
    public static void main(String[] args) {
        try {
            FileOutputStream fos = new FileOutputStream("large - file.txt");
            for (int i = 0; i < 1000000000; i++) {
                fos.write('a');
            }
        } catch (IOException e) {
            System.out.println("磁盘空间不足，请清理磁盘。");
        }
    }
}

资源管理避免泄漏

1. 使用 try - with - resources 语句：Java 7 引入了 try - with - resources 语句，它会自动关闭实现了 AutoCloseable 接口的资源，如 FileInputStream、FileOutputStream、BufferedReader、BufferedWriter 等。这确保了即使在操作过程中抛出异常，资源也能被正确关闭。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class TryWithResourcesExample {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("example.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.out.println("读取文件时出错: " + e.getMessage());
        }
    }
}

2. 复杂业务逻辑中多个流和通道的管理：当涉及多个流和通道时，同样可以使用 try - with - resources 语句。将所有需要管理的资源放在 try 语句的括号内，它们会按照声明的顺序被关闭。

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.channels.FileChannel;
import java.io.IOException;

public class MultipleResourcesExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("source.txt");
             FileOutputStream fos = new FileOutputStream("destination.txt");
             FileChannel sourceChannel = fis.getChannel();
             FileChannel destinationChannel = fos.getChannel()) {
            sourceChannel.transferTo(0, sourceChannel.size(), destinationChannel);
        } catch (IOException e) {
            System.out.println("文件操作时出错: " + e.getMessage());
        }
    }
}

设计模式辅助异常处理与资源管理

1. 策略模式：可以将不同类型的文件操作（读、写、追加等）封装成不同的策略类，每个策略类负责处理自己对应的异常和资源管理。这样可以将复杂的业务逻辑解耦，提高代码的可维护性和扩展性。

// 策略接口
interface FileOperationStrategy {
    void performOperation() throws IOException;
}

// 读取文件策略类
class FileReadStrategy implements FileOperationStrategy {
    private String filePath;
    public FileReadStrategy(String filePath) {
        this.filePath = filePath;
    }
    @Override
    public void performOperation() throws IOException {
        try (BufferedReader br = new BufferedReader(new FileReader(filePath))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        }
    }
}

// 写入文件策略类
class FileWriteStrategy implements FileOperationStrategy {
    private String filePath;
    private String content;
    public FileWriteStrategy(String filePath, String content) {
        this.filePath = filePath;
        this.content = content;
    }
    @Override
    public void performOperation() throws IOException {
        try (BufferedWriter bw = new BufferedWriter(new FileWriter(filePath))) {
            bw.write(content);
        }
    }
}

// 策略使用类
class FileOperationExecutor {
    private FileOperationStrategy strategy;
    public FileOperationExecutor(FileOperationStrategy strategy) {
        this.strategy = strategy;
    }
    public void executeOperation() {
        try {
            strategy.performOperation();
        } catch (IOException e) {
            System.out.println("文件操作出错: " + e.getMessage());
        }
    }
}

public class StrategyPatternExample {
    public static void main(String[] args) {
        FileOperationStrategy readStrategy = new FileReadStrategy("example.txt");
        FileOperationExecutor readExecutor = new FileOperationExecutor(readStrategy);
        readExecutor.executeOperation();

        FileOperationStrategy writeStrategy = new FileWriteStrategy("output.txt", "Hello, World!");
        FileOperationExecutor writeExecutor = new FileOperationExecutor(writeStrategy);
        writeExecutor.executeOperation();
    }
}

2. 装饰器模式：在处理文件流时，可以使用装饰器模式来动态地为文件流添加功能，如缓冲、加密等。同时，在装饰器类中可以统一处理异常和资源管理，使代码更加清晰和模块化。

// 抽象文件流组件
abstract class FileStreamComponent {
    public abstract void performOperation() throws IOException;
}

// 具体文件流组件
class FileInputStreamComponent extends FileStreamComponent {
    private String filePath;
    public FileInputStreamComponent(String filePath) {
        this.filePath = filePath;
    }
    @Override
    public void performOperation() throws IOException {
        try (FileInputStream fis = new FileInputStream(filePath)) {
            int data;
            while ((data = fis.read()) != -1) {
                System.out.print((char) data);
            }
        }
    }
}

// 装饰器抽象类
abstract class FileStreamDecorator extends FileStreamComponent {
    protected FileStreamComponent component;
    public FileStreamDecorator(FileStreamComponent component) {
        this.component = component;
    }
    @Override
    public void performOperation() throws IOException {
        component.performOperation();
    }
}

// 缓冲装饰器
class BufferedFileStreamDecorator extends FileStreamDecorator {
    public BufferedFileStreamDecorator(FileStreamComponent component) {
        super(component);
    }
    @Override
    public void performOperation() throws IOException {
        try (BufferedInputStream bis = new BufferedInputStream(((FileInputStreamComponent) component).getInputStream())) {
            int data;
            while ((data = bis.read()) != -1) {
                System.out.print((char) data);
            }
        }
    }
}

public class DecoratorPatternExample {
    public static void main(String[] args) {
        FileStreamComponent fileComponent = new FileInputStreamComponent("example.txt");
        FileStreamComponent bufferedComponent = new BufferedFileStreamDecorator(fileComponent);

        try {
            bufferedComponent.performOperation();
        } catch (IOException e) {
            System.out.println("文件操作出错: " + e.getMessage());
        }
    }
}

通过上述方法，可以全面且优雅地处理Java文件读取与写入过程中的异常，并合理管理文件资源，避免资源泄漏，提高程序的健壮性。