异常处理的设计与重构

catch (IOException e) {
// 忽略异常是不好的错误示例
}

catch (IOException e) {
e.printStackTrace(); // 打印异常效果几乎等同忽略异常
}

catch (IOException e) {
throw new UnhandleException(e);
}

catch (IOException e) {
logger.error("找不到系统文件", e);
throw new UnhandleException(e); // 写入日志文件后不要在丢异常
}

try{
    CommandExecutor executor = new CommandExeception();
    executor.execute(new Runnable() {
        public void run() {
            System.out.println(
                "Encounter SQLException"
);
            );
            throw new TunnelingException(new SQLException());
}
        }
    });
} catch (TunnelingException e) {
    if (e.getCause() instanceof SQLException) {
        // 处理 SQLException
    }
}

catch (java.sql.SQLException e) {
    rollback(con);
    if (e.getErrorCode() == EXTERNAL_ROUTINE_EXCEPTION) {
        compensate();
}
    }
    throw new AggregationException(e, sql);
}

public void runBatchJob(List<Job> aList, ErrorCollector collector) {
    for (Job job: aList) {
try {
        try {
            job.execute();
        } catch(Exception e) {
            collector addError(e);
}
        }
    }
}

public interface ErrorCollector {
    List<Exception> getErrors();
    void addError(Exception error);
    void clear();
    int size();
}

public void run() {
    while(Thread.currentThread().isInterrupted()) {
        try {
            Task task = queue.task();
            task.execute();
        } catch(InterruptedException ex) {
            Thread.currentThread().interrupt();
        } catch(Exception e) {
            logger.error(e);
        }
    }
}

public int withdraw(int amount) {
    if (amount > this.balance) {
        return -1;
    } else {
        this.balance = this.balance - amount;
        return this.balance;
    }
}

public void useWithdraw () {
    int balance = withdraw(500);
    if (-1 == balance) {
        // 错误处理
    } else {
        // 执行正常逻辑
    }
}

public void doIt () {
    FileInputStream fis = null;
    try {
        fis = new FileInputStream(new File("aFileName"));
    } catch (FileNotFoundException e) {
        // 忽略它
    } finally {
        close(fis);
    }
}

public void noExceptionThrown () {
    try {
        // 可能会抛出异常的正常程序逻辑
    } catch (Throwable e) {
        // 捕捉并忽略所有异常
    }
}

static public void main (String[] args) {
    MyApp myapp = new MyApp();
    myapp.start();
}

catch (FileNotFoundException) {
    e.printStackTrace(); // Dummy Handler
} catch (IOException e) {
    System.out.printIn(e.getMessage()); // Dummy Hnndler
}

try {
    in = new FileInputStream("aFile");
} catch (IOException e) {
        // 处理异常
} finally {
    try { // 嵌套Try语句
        if (in != null) {
            in.close();
        }
    } catch (IOException e) {
        // 将异常写入日志
    }
}

try {
    // 主要实现
} catch {
    // 替代方案
}

try {
    FileInputStream fis = new FileInputStream(new File(aFileName));
    fis.close(); // 错误
} catch (IOnterruptedException ex) {
    // 处理异常
}

try {
    FileInputStream fis = new FileInputStream(new File(aFileName));
} catch (IOException e) {
    fis.close(); // 错误
    // 处理异常
}

public void carelessCleanup(String aFileName) throws IOException {
    FileInputStream fis = null;
    DataInputStream dis = null;
    try {
        fis = new FileInputStream(new File(aFileName));
        dis = new DataInputStream(fis);
    } finally {
        fis.close();
dis.close(); // 如果上面一行发生异常，就执行不到
}
}

public synchronized int withdraw(int amount) {
    if (amount > this.balance) {
        return -1;
    } else {
        this.balance = this.balance - amount;
        return this.balance;
    }
}

public synchronized int withdraw(int amount) throws NotEnoughMoneyException {
    if (amount > this.balance) {
        throw new NotEnoughMoneyException;
    }
    this.balance = this.balance - amount;
    return this.balance;
}

} catch(IOException e) {
    // ignoring the exception
}

catch (IOException e) {
    throw new UnhandledException(e);
}

catch (IOException e) {
    e.printStackTrace();
}

catch (IOException e) {
    throw new UnhandledException(e);
}

static public void main (String[] args) {
    // 主程序
}

static public void main (String[] args) {
    try {
        // 主程序
    } catch (Throwable e) {
        // 显示错误信息并且记录到日志文件中
    }
}

finally {
    try {
        if (in != null) in.close();
    } catch (IOException e) {
        // log the exception
    }
}

finally {
    cleanup(in);
}

private void cleanup (Closeable cls) {
    try {
        if (cls != null) cls.close();
    } catch (IOException e) {
        // log the exception
    }
}

public void moveFiles(String srcFolder, String destFolder) throws IOException {
    try {
        // 复制srcFolder所有文件到destFolder
        // 可能发生IOException
    } finally {
        // 释放资源
    }
}

public void moveFiles (String srcFolder, String destFoler) throws IOException {
    folerCheckpoint fscp = null;
    try {
        fscp = new FolerCheckpooint();
        fscp.extablish(srcFolder);
        // 复制 srcFolder 所有档案到 destFolder,
        // 可能会发生 IOException
    } catch (Exception e) {
        fscp.restore();
        throw e;
    } finally {
        fscp.drop();
        // 释放资源
    }
}

public User readUser (String name) throws ReadUserExeption {
    try {
        return readFromDatabase(name);
    } catch (Exception e) {
        try {
            return readFromLDAP(name);
        } catch (IOException e) {
            throw new ReadUserException(ex);
        }
    }
}

public User readUser(String name) throws ReadUserException {
    final int maxAttempt = 3;
    int attempt = 1;
    while(true) {
        try {
            if (attempt <= 2) {
                return readFromDatabase(name);
            } else {
                return readFromLDAP(name);
            }
        } catch (Exception e) {
            if (++attempt > maxAttempt) {
                throw new ReadUserException(e);
            }
        }
    }
}

public void setupMessageV2(DataInputStream aIS) throws InvalidPacketExeption {
    int length = 0;
    try {
        length = ais.readInt();
        setMessageLength(length);
    } catch (IOException e) {
        throw new InvalidPacketException("读取封包长度错误", e);
    }

    try {
        byte[] messageBody = new byte[length];
        aIS.readFully(messageBody);
        setMessageBody(new String(messageBody));
    } catch (EOFException e) {
        throw new InvalidPacketException("封包长度少于封包表头数据所示", e);
    } catch (IOException e) {
        throw new InvalidPacketException("读取封包内容错误", e);
    }
}

public void setupMessageV3(DataInputStream aIS) throws InvalidPacketExeption {
    int length = readMessageLength(aIS);
    byte[] messageBody = readMessageBody(length, aIS);
    setMessageLength(length);
    setMessageBody(new String(messageBody));
}

private int readmessageLength(DataInputStream aIs) throws InvalidpacketException {
    try {
        int length = aIS.readInt();
        return length;
    } catch (IOException e) {
        throw new InvalidPacketException("读取封包长度错误", e);
    }
}

private byte[] readMessageBody(int aLength, DataInputStream aIS) throws InvalidPacketException {
    try {
        byte[] messageBody = new byte[aLength];
        aIS.readFully(messageBody);
        return messageBody;
    } catch (EOFException e) {
        throw new InvalidPacketException("封包长度少于封包表头数据所示", e);
    } catch (IOException e) {
        throw new InvalidPacketException("读取封包内容错误", e);
    }
}