While developing an application it's mandatory to keep components independent from each other, this is what loose coupling is. It provides standardization, consolidation, normalization, and governance over your application. A loosely coupled application is easy to scale up.

In this article: You will learn with an example, how to make your application loosely coupled and get the maximum out of it.

Need of Loose Coupling:

Let's say you are fetching something from your UserDatabase database, here is the data-layer defined function to fetch database records:

public class UserDatabase {
    public String getUserDetails(){
        return "User Deatils ";
    }
}

In our service layer, let's create a function to talk to our data layer in order to fetch records:

public class UserDatabase {
    public String getUserDetails(){
        return "User Details in DB1";
    }
}

In our application layer or main function we will talk to our service layer:

public static void main(String[] args) {
        //Tight Coupling
        UserManager userManager = new UserManager();
        System.out.println(userManager.getUserInfo());
    }

In this application, when we try to scale up our application, tight coupling will make it redundant and hard to expand.
That's why a loosely coupled application is so important, In spring boot we achieve it using interfaces. Let's make the above app loosely coupled.

Loose Coupling:

Let's define an interface that will give us an overall structure for the data layer:

public interface UserDataProvider {
    String getUserDetails();
}

Now fetch database records while implementing this interface:

public class UserDatabase implements UserDataProvider{
    @Override
    public String getUserDetails(){
        return "User Details in DB1";
    }
}

Now define the service layer to communicate with the data layer:

public class UserManager {
    private UserDataProvider userDataProviderr;
    public UserManager(UserDataProvider userDataProvider) {
        this.userDataProviderr = userDataProvider;
    }

    public String getUserInfo(){
        return userDataProviderr.getUserDetails();
    }
}

Here while injecting a UserDataProvider reference object into UserManager we will be able to access the UserDatabase function which implements that interface so it will provide us abstraction at the level of the data layer.

Now we can access records through UserManager :

    UserDataProvider userDataProvider = new UserDatabase();
        UserManager userManager = new UserManager(userDataProvider);
        System.out.println(userManager.getUserInfo());

We can easily scale up our application and integrate as many database connections as we want like if we need to configure another database for example WebServerDatabase, we only need to create its instance assigned to the implemented interface, and then through UserManager we can access that too. Using an interface provides us Abstraction, loose coupling, and PolyMorphism(implementing the same interface by different classes provides us polymorphism).

Happy Coding :)