I have just completed my first own project. In this project I have a web server whose main task is to load files and return them as a stream.
In the first version, there was a static handler for each file type, which loaded the file and sent it as a stream.
As part of a refactoring, I then built building blocks for various tasks and the handler changed fundamentally.
The initial code
Here you can see a part of my web server. It offers a path for both images and audio files. The real server has significantly more handlers and file types.
public class WebServer{
public static void main(String[] args) {
var app = Javalin.create()
.get("api/audio/{root}/{path}/{number}", FileHandler::handleAudio)
.get("api/img/{root}/{path}/{number}", FileHandler::handleImage)
.start(7070);
}
}
Below is a simplified illustration of the handlers. I have also shown the imports of the web server class and the web server technology, in this case Javalin. The imports are not complete. They are only intended to show these two dependencies.
import WebServer;
import io.javalin.http.Context;
// ...
public class FileHandler {
public static void handleImage(Context ctx) throws IOException {
var resource = Application.class.getClassLoader().getResourceAsStream(
String.format(
"file/%s/%s/%s.jpg",
ctx.pathParam("root"),
ctx.pathParam("path"),
ctx.pathParam("fileName")));
String mimetyp= "image/jpg";
if (resource != null) {
ctx.writeSeekableStream(resource, mimetyp);
}
}
public static void handleAudio(Context ctx) {
var resource = Application.class.getClassLoader().getResourceAsStream(
String.format(
"file/%s/%s/%s.mp3",
ctx.pathParam("root"),
ctx.pathParam("path"),
ctx.pathParam("fileName")));
String mimetyp= "audio/mp3";
if (resource == null) {
resource = Application.class.getClassLoader().getResourceAsStream(
String.format(
"file/%s/%s/%s.mp4",
ctx.pathParam("root"),
ctx.pathParam("path"),
ctx.pathParam("fileName")));
mimetyp= "video/mp4";
}
if (resource != null) {
ctx.writeSeekableStream(resource, mimetyp);
}
}
}
The handler methods each load the file and send it to the Javalin context. The audio handler first searches for an audio file and, if this is not available, for a video file. The duplication is easy to see. And with the static handler and Javalin dependencies, the code is not testable.
Refactoring
So first I build an interface, called a decorator, for the context to get the Javalin dependency out of the handlers. A nice bonus: I can manage the handling of not found files centrally. In the web server, I then inject the new WebContext instead of the Context.
public interface WebContext {
String pathParameter(String key);
void sendNotFound();
void sendResourceAs(String type, InputStream resource);
default void sendResourceAs(String type, Optional<InputStream> resource){
if(resource.isEmpty()){
sendNotFound();
return;
}
sendResourceAs(type, resource.get());
}
}
public class JavalinWebContext implements WebContext {
private final Context context;
public JavalinWebContext(Context context){
this.context = context;
}
@Override
public String pathParameter(String key) {
return context.pathParam(key);
}
@Override
public void sendNotFound() {
context.status(HttpStatus.NOT_FOUND);
}
@Override
public void sendResourceAs(String type, InputStream resource) {
context.writeSeekableStream(resource, type);
}
}
Then I write a method to load the file and send it as a stream.
private boolean sendResourceFor(String path, String mimetyp, Context context){
var resource = Application.class.getClassLoader().getResourceAsStream(path);
if (resource != null) {
context.sendResourceAs(mimetyp, resource);
return true;
}
return false;
}
The next step is to build a loader for the files, which I pass to the no longer static handler during initialization. Here I can run a quick check to see if anyone is trying to manipulate the specified path.
public class ResourceLoader {
private final ClassLoader context;
public ResourceLoader(ClassLoader context){
this.context = context;
}
public Optional<InputStream> asStreamFrom(String path){
if(path.contains("..")){
return Optional.empty();
}
return Optional.ofNullable(this.context.getResourceAsStream(path));
}
}
Finally, I build an extra class for the paths. The knowledge of where the files are located and how to determine the path from the context should not be duplicated everywhere.
public class FileCoordinate {
private static final String FILE_CATEGORY = "file";
private final String root;
private final String path;
private final String fileName;
private final String extension;
private FileCoordinate(String root, String path, String fileName, String extension){
super();
this.root = root;
this.path = path;
this.fileName = fileName;
this.extension = extension;
}
private static FileCoordinate pathFromWebContext(WebContext context, String extension){
return new FileCoordinate(
context.pathParameter("root"),
context.pathParameter("path"),
context.pathParameter("fileName"),
extension
);
}
public static FileCoordinate toImageFile(WebContext context){
return FileCoordinate.pathFromWebContext(context, "jpg");
}
public static FileCoordinate toAudioFile(WebContext context){
return FileCoordinate.pathFromWebContext(context, "mp3");
}
public FileCoordinate asToVideoFile(){
return new FileCoordinate(
root,
path,
fileName,
"mp4"
);
}
public String asPath(){
return String.format("%s/%s/%s/%s.%s", FILE_CATEGORY, root, path, fileName, extension);
}
}
Result
My handler looks like this after refactoring:
public class FileHandler {
private final ResourceLoader resource;
public FileHandler(ResourceLoader resource){
this.resource = resource;
}
public void handleImage(WebContext context) {
var coordinate = FileCoordinate.toImageFile(context);
sendResourceFor(coordinate, "image/jpg", context);
}
public void handleAudio(WebContext context) {
var coordinate = FileCoordinate.toAudioFile(context);
var found = sendResourceFor(coordinate, "audio/mp3", context);
if(!found)
sendResourceFor(coordinate.asToVideoFile(), "video/mp4", context);
}
private boolean sendResourceFor(FileCoordinate coordinate, String mimetype, WebContext context){
var stream = resource.asStreamFrom(coordinate);
context.sendResourceAs(mimetype, stream);
return stream.isPresent();
}
}
It is much shorter, easier to read and describes more what is done and not how it is technically done. Another advantage is that I can, for example, fully test my FileCoordinate and mock my WebContext.
For just these two handler methods, it still looks like a overkill. Overall, more code has been created than has disappeared and yes, a smaller modification would probably have been sufficient for this handler alone. But my application is not just this handler and most of them are much more complex. For example, I work a lot with json files, which are loaded and which my loader can now simply interpret using an additional function that return a JsonNode instead a stream. The conversion has significantly reduced the complexity of the application, avoided duplications and made the code more secure and testable.
Schneide Blog 