Creating Function Pipelines In Java

To trigger the Pipeline first we need to create a reference, then chain the functions.

Function<String, String> pipeline = Text :: addText;

String result = pipeline  
                    .andThen(x -> removeSpecialCharacter(x))  
                    .andThen(x -> capitalize(x))  
                    .apply("Java@#$%%%Programming%$##Language\"");  

System.out.println(result); # JAVA PROGRAMMING LANGUAGE

Above code can be refactored further to use method reference,

result = pipeline  
        .andThen(Text :: removeSpecialCharacter)  
        .andThen(Text ::  capitalize)  
        .apply("Java@#$%%%Programming%$##Language\"");

Creating the second Pipeline

The more meaningful example would be a traditional line by line file reading a file. Let's re-factor the below code in the pipeline.

public static void main(String[] args) {
    BufferedReader br;

    try {
        br = new BufferedReader(new FileReader("example.txt"));
        String line = br.readLine();

        while (line != null) {
            System.out.println(line);
            line = br.readLine();
        }
        br.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

The first step would be to create an instance of BufferedReader by passing in a String filename as a parameter. The second step is to read the lines. The third step is to print the lines, and the fourth step is to close the reader. The class methods looks like,

public static BufferedReader openReader(String filename) {  
    System.out.println("Step1:Creating BufferedReader");  
    BufferedReader br;  
     try {  
        br = new BufferedReader(new FileReader(new File(filename)));  
    } catch (FileNotFoundException e) {  
        throw new RuntimeException(e);  
    }  
    return br;  
}  

public static BufferedReader readLines(BufferedReader br) {  
    System.out.println("Step2:Reading file");  
    StringBuilder sb = new StringBuilder();  
    try {  
        while(br.readLine()!=null){  
            sb.append(br.readLine());  
        }  
    } catch (IOException e) {  
        throw new RuntimeException(e);  
    }  
    lines = sb.toString();  
    return br;  
}  

public static BufferedReader print(BufferedReader br) {  
    System.out.println("Step3:Printing Lines");  
    System.out.println(lines);  
    return br;  
}  

public static BufferedReader closeReader(BufferedReader br) {  
    System.out.println("Step4:Closing Connection");  
    try {  
        br.close();  
    } catch (IOException e) {  
        throw new RuntimeException(e);  
    }  
    return br;  
}

To trigger the pipeline first we need to create the Function reference and then chain the remaining functions

Function<String, BufferedReader> pipeline = FileOperations :: openReader;
pipeline  
        .andThen(FileOperations :: readLines)  
        .andThen(x -> print(x))  
        .andThen(x -> closeReader(x))  
        .apply("example.txt");

Or we can use Method reference,

Function<String, BufferedReader> pipeline = FileOperations :: openReader;
pipeline  
        .andThen(FileOperations :: readLines)  
        .andThen(FileOperations :: print)  
        .andThen(FileOperations :: closeReader)
        .apply("example.txt");

The way a simple Function is applied to the chained functions, similarly a BiFunction can be applied in which the method takes 2 parameters.

Function<String, BufferedReader> pipeline = FunctionPipeline :: openReader;  
BiFunction<BufferedReader, String, BufferedReader> printBiFunction = (a, b) -> print(a, b);  
pipeline.andThen(br -> readLines(br))  
        .andThen(x -> printBiFunction.apply(x, getLines()))  
        .andThen(x -> closeReader(x))  
        .apply("example.txt");