Make your application loosely coupled-Abstraction-PolyMorphism
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 :)
The above is the detailed content of Make your application loosely coupled-Abstraction-PolyMorphism. For more information, please follow other related articles on the PHP Chinese website!

Hot AI Tools

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Undress AI Tool
Undress images for free

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

Hot Topics











Troubleshooting and solutions to the company's security software that causes some applications to not function properly. Many companies will deploy security software in order to ensure internal network security. ...

Solutions to convert names to numbers to implement sorting In many application scenarios, users may need to sort in groups, especially in one...

Field mapping processing in system docking often encounters a difficult problem when performing system docking: how to effectively map the interface fields of system A...

Start Spring using IntelliJIDEAUltimate version...

When using MyBatis-Plus or other ORM frameworks for database operations, it is often necessary to construct query conditions based on the attribute name of the entity class. If you manually every time...

Conversion of Java Objects and Arrays: In-depth discussion of the risks and correct methods of cast type conversion Many Java beginners will encounter the conversion of an object into an array...

How does the Redis caching solution realize the requirements of product ranking list? During the development process, we often need to deal with the requirements of rankings, such as displaying a...

Detailed explanation of the design of SKU and SPU tables on e-commerce platforms This article will discuss the database design issues of SKU and SPU in e-commerce platforms, especially how to deal with user-defined sales...
