CODEWITHSUNDEEP
javafileexceptionfile-io
Jim
Jim

Reputation: 19582

File I/O without clutering of exceptions

What is the best way to use e.g. FileOutputStream without cluttering my code.

Example the following code:

What I need to do is: 

FileOutputStream fOut = new FileOutputStream(file);    
while(!Thread.currentThread().isInterrupted()){  
   fOut.write(data);  
   //other code  
}

But if I add the exception handling is all messy. I thought for example something like the following: 

private FileOutputStream openStream(String file){  
   try{  
      return new FileOutputStream(file);    
   }  
   catch(FileNotFoundException e){  
      return null;  
   }    
 }

But then it makes the logic weird. I mean when I close the stream, e.g. in another method etc.
What is the way to get clearer code

Upvotes: 3

Views: 222

Answers (4)

user2030471
user2030471

Reputation:

What about a wrapper like this:

public class StreamWrapper {

    private FileOutputStream fileOutputStream;

    public FileOutputStream open(String file) {
        try {
            fileOutputStream = new FileOutputStream(file);
        } catch (FileNotFoundException e) {
            // Define action
        }
        return fileOutputStream;
    }

    public void close() {
        try {
            fileOutputStream.close();
        } catch (IOException e) {
            // Define action
        }
    }

}

And use it like:

StreamWrapper wrapper = new StreamWrapper();
FileOutputStream fOut = wrapper.open("file");
// something
wrapper.close();

Upvotes: 2

shamik
shamik

Reputation: 24

There are couple options that you can do:

First of all you sample code is good only thing is "in case of a exception you are returning a null object". So rather than returning a FileOutputStream object you can actually send a boolean and store the FileOutputStream object as a class variable.

So if other program want to access that can make this call and the caller will get True/False depending on whether it could create a object successfully or not, and if that is True then can use the class variable for the FileOutputStream object. I am attaching some sample code with that:

FileOutputStream fOutSt;

private boolean isOpenStream(String file){  
       try{  
          fOutSt = new FileOutputStream(file);
          return true;
       }  
       catch(FileNotFoundException e){  
           return false;  
       }    
 }

Then the caller can make call like:

if(isOpenStream) {
    obj.GetfOutSt;
}

Upvotes: 0

iGili
iGili

Reputation: 883

Applicative exceptions are there for a reason (and nobody likes RT exceptions...) You could use a factory to hide the exception handling, but the "catch" clause would have to be in your code somewhere.

One idea is to implement your own wrapper to FileOutputStream that will swallow the exception during instantiation, but since the exception is thrown at the constructor you'll end up in an unstable state if the file indeed doesn't exists. 

public class MyFileOutputStream {

private FileOutputStream fis;

public MyFileOutputStream(File file){
    try{
        fis = new FileOutputStream(file);
    } catch (FileNotFoundException e){
        fis = null;
    }
}

public boolean isOpened(){
    return fis!=null;
}

public void write(Byte b) throws IOException {
    fis.write(b);
}

}

Upvotes: 1

Tomasz Nurkiewicz
Tomasz Nurkiewicz

Reputation: 340993

There is no direct way of avoiding checked exceptions in Java, unfortunately. Few work-arounds:

Use different language

Both and treat checked exceptions as unchecked.

try-with-resources idiom in Java 7

It doesn't really help with catch, but substantially reduces the amount of finally blocks surrounding close().

Throwables.propagate(Throwable) in Guava

Avoid returning null and swallowing exceptions:

private FileOutputStream openStream(String file){  
   try{  
      return new FileOutputStream(file);    
   }  
   catch(FileNotFoundException e){  
      return Throwables.propagate(e);  
   }    
 }

See also: Long try statements.

Upvotes: 2

Related Questions