Обработка исключений

public static void copy(InputStream in, OutputStream out1, OutputStream out2, int bufferSize) throws IOException
    {
        byte[] buffer = new byte[bufferSize];
        
        while ((in.read(buffer)) != -1)
        {
            out1.write(buffer);
            out2.write(buffer);
        }
    }
 
public static void main(String[] args) throws IOException
    {
        URL url = new URL("http://www.google.com");
        File file1 = new File("D:\\file1.txt");
        File file2 = new File("D:\\file2.txt");
        
        
        try(InputStream in = url.openStream();
                OutputStream out1 = new FileOutputStream(file1);
                    OutputStream out2 = new FileOutputStream(file2);)
        {
            copy(in, out1, out2, 2048);
            out1.flush();
            out2.flush();
        }
        catch(IOException IO_ex)
        {
            try
            {
                file1.delete();
            }
            catch(SecurityException secur_ex1)
            {
                IO_ex.addSuppressed(new IOException("Cant delete file " + file1));          
            }
            
            try
            {
                file2.delete();
            }
            catch(SecurityException secur_ex2)
            {
                IO_ex.addSuppressed(new IOException("Cant delete file " + file2));
            }
            
            throw IO_ex;
        }
    }

file1.delete();
file2.delete();

File temp= file1;
try{           
          file1.delete();
          
          temp = file2;
          file2.delete();
 
}catch(SecurityException secur_ex){
          IO_ex.addSuppressed(new IOException("Cant delete file " + temp));
}

package io;
 
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Observable;
import java.util.Observer;
 
/**
 * @author mutagen
 */
public class IoTransaction {
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws MalformedURLException, IOException {
 
        BufObservable bufObservable = new BufObservable();
 
        URL url = new URL("http://www.google.com");
        File file1 = new File("D:\\file1.txt");
        File file2 = new File("D:\\file2.txt");
 
        InputStream is = url.openStream();
 
        boolean rezult = bufObservable.copy(is, file1, file2);
        System.out.println(rezult);
 
        is.close();
    }
 
    static class BufObservable extends Observable {
 
        private File f1;
        private File f2;
 
        public boolean copy(InputStream is, File f1, File f2) {
            this.f1 = f1;
            this.f2 = f2;
            try {
                if (!this.copy(is, new FileOutputStream(f1), new FileOutputStream(f2))) {
                    rollback();
                    return false;
                }
            } catch (FileNotFoundException ex) {
                rollback();
                return false;
            }
            return true;
        }
 
        private boolean copy(InputStream is, OutputStream os1, OutputStream os2) {
            ByteContainer byteContainer = new ByteContainer(1024);
            BufObserver bo1 = new BufObserver(byteContainer, os1);
            BufObserver bo2 = new BufObserver(byteContainer, os2);
            this.addObserver(bo1);
            this.addObserver(bo2);
            try {
                while ((is.read(byteContainer.getBuf())) != -1) {
                    setChanged();
                    notifyObservers();
                    if (bo1.getTransaction().isFailed()) {
                        return false;
                    }
                    if (bo2.getTransaction().isFailed()) {
                        return false;
                    }
                }
                return true;
            } catch (IOException ex) {
                return false;
            } finally {
                if (bo1.getOs() != null) {
                    try {
                        bo1.getOs().close();
                    } catch (IOException ex) {
                        return false;
                    }
                }
                if (bo2.getOs() != null) {
                    try {
                        bo2.getOs().close();
                    } catch (IOException ex) {
                        return false;
                    }
                }
            }
        }
 
        private void rollback() {
            if (f1 != null) {
                this.f1.delete();
            }
            if (f2 != null) {
                this.f2.delete();
            }
        }
    }
 
    static class Transaction {
 
        private boolean failed = false;
 
        public boolean isFailed() {
            return failed;
        }
 
        public void setFailed(boolean failed) {
            this.failed = failed;
        }
    }
 
    static class ByteContainer {
 
        private int size;
 
        public ByteContainer(int size) {
            this.size = size;
        }
        private byte[] buf = new byte[size];
 
        public byte[] getBuf() {
            return buf;
        }
 
        public void setBuf(byte[] buf) {
            this.buf = buf;
        }
    }
 
    static class BufObserver implements Observer {
 
        public BufObserver(ByteContainer buf, OutputStream os) {
            this.buf = buf;
            this.os = os;
        }
        private Transaction transaction = new Transaction();
 
        public Transaction getTransaction() {
            return transaction;
        }
        private ByteContainer buf;
        private OutputStream os;
 
        public OutputStream getOs() {
            return os;
        }
 
        @Override
        public void update(Observable o, Object arg) {
            try {
                os.write(buf.getBuf());
            } catch (IOException ex) {
                transaction.setFailed(true);
            }
        }
    }
}