DEV Community: Abhiram

🚀 Demystifying APIs and REST with Spring Boot: Crafting Product Services Made Easy🚀

Abhiram — Sun, 07 Jan 2024 12:34:10 +0000

What is API

API stands for Application Programming Interface. How can we understand API from full form ? Let us simpliy this. We can say it is an interface for an application. Till now we might have created interface for a class. We might have implemented this interface.

Interface Runnable {
Void run();
}

Any class implemented this interface has to implement run method in it. We can say it is a contract between class and interface ,that whichever class implements this, has to implement this method in it.

Basically when we create a interface it is like we are creating a contract that whichever class implements this interface has to follow a certain structure ,i.e. it has to implement all the methods or else we will get compilation error.

Similarly API is also a contract. If any service wants to connect to our API be it front end, third party, anything, it has to follow a certain structure that we created for API. Contract in API is what we will accept in API and what we will return from API.

Major things we will follow in API are

- HTTP methods

HTTP stands for Hyper Text transfer protocol. But why we are not discussing HTTPS. Difference between HTTP and HTTPS is protocol. In HTTPS the data will be in encrypted format, in between client and server ,it will not be readable.

HTTP or HTTPS is used ,how to transfer the text, how to send it in optimized manner. As transfer is happening between two systems we can say two operating systems over network, so we should be having knoweldge about which data structure to use to send the data in optimized way and also about networking and operating systems.

HTTP methods shows us ,what operations we can use to interact with server.

In postman we can see all the HTTP methods, they are basically different methods that we can use to interact with server

- Endpoint URL

It means ,the URL that our API will be executing. For example we want to create products it will be like www.domain.com, this will be the domain and for creating products it will be www.domain.com/createProducts. createProducts is API end point.

- Request

-> It is input what we send

- Response

-> It is output what we get from API

For example ,I am running an e-commerce website and I want to use services from razorpay for payment gateway. So for this to happen, the e-commerce websit has to send the order details to razorpay for the transaction to happen, how do we send the data to razorpay ?

In the above you can see

HTTP method is post to create order
End point URL is /orders.
Right side of the image, you can -d which is the request we are sending for example money, currency type etc
Response we will get like in the below image.

When two applications are talking to each other, they must have well defined API contract.

Above all forms the API contract, which means

what is operation we are doing
what is the end point URL
what type of information we have to send in request
what response we can except from API

Concluding API is set of functionalities or methods that are provided by other system for us to use.

- What is REST ?

REST stands for Representation State Transfer. It means that every call we make to API, there should be a transfer of state.

For example in first call I will call the API for all the products and In the second call I will call the API for a particular product., now in the second call all the details will be sent again. The authorization etc will happen again in the second call also.

Every call we make to the backend ,it will be a new call. It may be the same API or different API, it will become a new call. No state will be remembered. Whether we will call the same API 10 times or different API it will be a new call and the previous call state will not be remembered.

But why do we need to send the data again and again to server ? It reduces the task for server i.e. the server will not remember all the client details, the client has to provide the details to the server again and again.

There will be thousands of customers making thousands of calls, if the server has to remember all the details of the users and their call, it will be a huge dataset at server side.

REST helped to make server less complex and it helped in reducing the development time.
Whenever you see a name REST API’s ,it means API’S are built using REST concept.

- API Hands-On

Let us build API’s related to product service. Let us create two models, one for product and one for category. one product will have one category but one category can have multiple products that means 1: 1 relationship between product and category and many : 1 relationship between category and product.

So let product model contains
• Productid
• Title
• Price
• Description
• Image
• cateogoryID

and let category contains
• id
• title
• description

Now we will build the API’s in controller layer, the controller layer calls service layer and service layer calls repository and repository calls Database, for database we will create models.

So first we will create Database, from Database we will create models, then we will create repositories and then service layer and in controller we will create the API i e (END POINT URL).

But right now what we will do is instead of creating Database we will call third party product API’s in service layer. So the data flow will be like

- Request will be like

Client -> API (Controller END POINT URL) -> Service layer -> Third party API **

- Response will be like**

Third party API -> Service layer -> Controller -> Client

We will use this https://fakestoreapi.com/docs third party service which provides API for this demo

Since we are not using Database do we still need models ? Yes because from API what ever data we return we will send it in models, from models we will create DTO (Data transfer object). So we will always build models even if we call third party or even if we have database.

What is DTO ?

Suppose we have a User model in which we have
• UserId
• Email
• Password
• Address

And we are returning User model data to frontend from API, now we are sending confidential data to frontend. This data can be hacked through browser, so to filter out data and send what is necessary we use DTO

In DTO we will be having
• UserId
• Email
• Addrress

From DTO we do

Hide confidential data
Reduce pay load size (response)
Maintains separation between model and actual data we send as response

So first we will code

Models
DTO’s
Controller with dummy API
Service layer calling third party API as well as Database.

In https://start.spring.io/ we will setup the Spring Boot project in a easy manner. I have filled the project data and I have added dependencies such as spring web with which we can REST API’s using spring MVC and Lombok for using getters and setters.

In the above picture ,I have imported the project in intellij IDE and I have created the packages for model, dto, service, controller.

Now we will go to fakestore and by seeing it’s entities and attributes in those entities, we will create our own models.

Output is can be seen below

Below we can see the attributes of products.

I have created product model and I have created attributes as per the products attributes in fakestore api. Make sure that attributes names matches with attributes in fakestore attributes.

Here we can see the categories reposnse for get all categories.

We created two DTO’s for the products model. ProductRequestDTO is for incoming data (client request) and ProductResponseDTO is for output data that we send it back to client from REST API.

Here we are adding all the attributes of product model including id as it may help in front-end.

We will use @RestController Annotation for Controller. In Spring Boot, a web application can have many end point URL’s (API’s) that clients can use and these are handled by controller’s. Now @RestController annotation is designed specifically for building RESTful API’s

If we simplify this

• A controller is the one which decides where each request should go.
• RESTful means that the web service follows a set of principles that make it easy to work with. In the context of Spring Boot, it often means that the service can provide and receive data in a format like JSON or XML and follows certain conventions for how URLs should look.
• @RestController: When a class is marked with @RestController, it's like saying, this class is a special type of controller, and it's specifically designed to handle requests and responses for RESTful web services.
• @GetMapping, @PostMapping, etc.: Inside a @RestController, we often see methods annotated with things like @GetMapping, @PostMapping, etc. These annotations specify which URLs (endpoints) the methods should handle and what type of HTTP request (GET, POST, etc.)

Let us create one dummy REST API in the REST controller which will create two products and return it and we will call this REST API to see if API is getting invoked or not.

Here we have created two ProductResponseDTO and we are returning this two as a list from the API.
To set the data to ProductResponseDTO object we have used getters and setters, for that we have used Lombok dependency which will automatically create getters and setters if we use @Getters and @Setters annotations

In above image we can see response is returned as ResponseEntity. In simple words ResponseEntity is like a bucket which will hold our response and in addition we can add the status of the response. Above we can I have put the status as ok and we are sending the response.

Inside ResponseEntity we can see, the response can be anything and we can the status also.
Now I will run the SpringBoot application and we will test the API in postman.

Crucial points

How the request reached from postman / client to Spring Boot server or tomcat server
How the request reached the correct controller and how the response was sent back correctly

In the next blog we will cover the above points.

🚀 Mastering Collaboration in Software Development: A Deep Dive into Version Control Systems & Git 🚀

Abhiram — Sat, 23 Dec 2023 13:26:39 +0000

Version Control System:

If we see the word Version control system, the meaning which will strike is managing different versions or tracing different versions.

For example take company Amazon or any other company, do you think the entire code of amazon is written in one go? Or one software engineer has written the entire code?

Thousands of software engineer might have contributed. Combined all those code, combining all those versions of code makes one code base of any company.

If I am the only one writing the code, there is no need to maintain the versions of code, but there will be multiple people working on a project. There will be lot of challenges that we may face like

• Conflicts can happen
• Sync problems can happen (One engineer can be working on latest version & another may be working on old version of codebase. While merging both of their commits to the Master branch we will face the problems due to different versions of code base)
Assume that in a project there are 4 versions of code base V1, V2, V3, V4. Let us think about a scenario to move from V4 to V3 (previous version)?

Whenever we get a bug in the production, first thing we check for is what the code changes are made or database changes made in the last few days. If we found out until version V3, the code was functioning properly and there is a bug surfaced now. So we might have missed something like testing or any other think for version V4.

To fix the BUG we can rollback to previous version V3 and continue working on BUG. This is the reason to maintain the history of the project.

Another reason for version control system is to maintain all the code changes done by all the team members, so that in future any bug comes they might approach the person who worked on developing the code to get more details about the feature that he has developed.

Types of Version control system

Centralized VCS: Single server that maintains the complete history of codebase.
• One need to be connected to the server all the time.

• If something happens to the server like server crash etc., then we cannot access codebase or we cannot add or modify the code base. This scenario is called as "Single point of failure"
Example:- Any file on shared server

Distributed VCS: Allows people to work independently offline, no need to connect to the server all the time

• People working on codebase should download codebase to their local machines.
• No "Single point of failure" scenario occurs as the codebase is spread across the local machines

We will discuss about Git as example for Distributed version control system.
• Git - Version control system to track changes
• GitHub - Central repository to host codebase.

With Git we can manage changes to files overtime and you can come back and see what the changes are made. We can see the difference between the versions of codebase and we can view who changed what.

Let us discuss how we can use git by using all its features.
There are 4 git locations

• Working tree - Contains location of local repo. All brand new files added into the project are called "untracked files" & edited files are called "Modified files" in local.

• Staging Area - Sort of filtering zone. Suppose there are 5 files I am working on & I want commit only 2, then only 2 will be moved from working tree to Staging area. Files here are called as staged files

  Command to move files from working tree to staging
               ** git add file1 file2**

  Command to move files from Staging area to local git repo –
              ** git commit -m "message for commit”**

• Local git repo - Files will be saved to git repo locally here after committing

 Command to move files from local git repo to remote git repo 
       ** git push origin **

 **_But in the above command what is origin?_**

 Suppose we have a local project that we want to host on 
 multiple remote service providers like GitHub, GitLab. I 
 create repository in GitHub & GitLab.

 Now using Git I want to connect to multiple repositories on 
different service providers.

GitHub & GitLab give us a link after creating repository 
there. The link is the identifier. 

Typing the link to connect to remote repo like GitHub or 
GitLab is difficult because we have to type in the entire URL.
What we do is we maintain a map in Git for mapping the link.

Example: name is origin & value is "link of GitHub remote 
         repo"

To map this we have command – git remote add origin "link of GitHub remote repo

Note: Any name we can give while mapping but first name should always be origin

Example: git remote origin2 "GitLab remote repo link"

"Until the above everything is in local"

•Remote git repo (GitHub, GitLab etc) - Central repository to host all codebase.

Git helps us to connect to multiple remote repo because if GitHub gets hacked & all codebase is deleted, we need to maintain some backup for codebase.

Note : "Always remember while designing, always design for failure, always be sure to lookout for failure & have a solution for that"

Let us do the hands on regarding all the above locations

To turn any project to a local git repository we use command "git init". Now the project will be initialized to Git repository.

We have to configure who is the developer for the local repo. For that we use "git config user.name --name" & "git config user.email"

Let us create few files & we will come across all the above git locations

Now we have created a new file & we will see which location the file is using "git status" command.

Here we can see the file is called "untracked files" present in working tree (working tree - contains location of local repo).

Let us move from working tree to staging area using "git add ." command

Let us see the output of " git status" command

Now we can see “Changed to be committed “which means the file is in staging area & it can be committed.

If we want to send back the file back to working tree from staging area we can see the above command in the image "git rm --cached filename"

Command to move from staged to local repo we use " git commit -m "message" " command.

Now if we see git status

Let us add one more file & let us modify the first file.

Let us view the git status

We can see first file is modified & second file is untracked. Now we will move both of them to staging area and we will commit them.

Let us view the status

Now copy the link of new repo created in GitHub

Let us connect local repo to remote repo create din GitHub using " git remote add origin "remote repo link" "

Let us modify the first file again & let us not commit it & we will see if the changes will be reflected or not in remote repo.

Let us view the status now

Let us not commit this change, let us push these to remote repo.

In GitHub if we go to the commits section, but you can see in the first page that the change that we did not commit is not getting reflected. So it did not get pushed to remote repo.

Let us discuss git branches now.

Suppose we have some code & we have deployed it on one server. Now we want to add one more feature we cannot directly modify the code which is running on the server.
Another idea what we can do is get a copy of the code, make changes and replace the code with the copy but the problem is we may face some bugs which did not identify and we may lose some history of the codebase.
To solve this git gives us branches with which we can maintain multiple replicas of code.

We will use " git branch "branchName " command to create branch. If we use git branch we can see which branch we are using.

Now if we see the branches we have 2 branches but we are still on master branch. Now will switch to feature 1 branch using " git checkout " command

But the interesting part we will see now is by using "git status" command. Here we can see the first file is modified as feature1 is new branch.

We can use " git merge " to merge the branch with master
We will create a new branch and we will create one more file but will push a new branch to remote repo & we will create pull request.

After pushing our branch to remote repo, we will create pull request. We can write the changes that we have made and the changes will be displayed to us. Through this the branch will merged to master in remote repo.

The thing that we must remember is we should not merge directly to master branch, every time we have to raise a pull request.

Understanding the Factory Design Pattern: A Beginner's Guide

Abhiram — Sat, 01 Apr 2023 06:06:00 +0000

Factory Design Pattern

Factory method is a creational pattern that uses factories to instantiate objects without having to specify the exact class of the objects that will be created

Creational Pattern

Pattern that is related to creation of new objects
Alternative way of using objects than just a regular constructor.
Not going to use new keyword to create objects

Factories

Within the context of object-oriented programming we mean methods or functions or other objects that create new objects.
And the return types from factories are going to be new instances of objects in themselves.
Factories isolates or encapsulates the behaviour of creation of some new object.
In short, the separation between the code that creates products from the code that uses products are factories
we need not modify the client code for creating new types of products.
Follows Open close principle in solid which means *the code should be open for extension and close for modification which means we can add to our code without changing existing code when we want to implement new factories. *
Fundamental benefits of factory method in terms of designing software - Different levels of abstraction

Real world example

When you order a cup of coffee in a restaurant, you do not see how the coffee is served, whether in a glass or ceramic cup.
Once the coffee is served you accept it and drink it.
No implementation is shared just like how the coffee is served.
We can think of software design in similar fashion.
We want to separate our code that takes care of implementation details.
Without changing our core business logic, we want to implement things

Every design patten is meant to solve a problem, we will see which problem factory design patten solves

Suppose we are building custom operating system which plays audio to remotely connected device.
Example: Alexa, Google Assistant device.
We are going to create Music Player class -> which invokes play method in Alexa.

We have also another class Video Player -> Invokes play method in Alexa.

Alexa objects are created, and we are invoking play method.

Consider a scenario, we have to connect to Google Assistant device to play Audio.
The selection between Amazon Alexa & Google Assistant may vary on set of conditions or configuration.
To support selection, we have to modify Music Player as well as Video player class.

*Assume there are plenty of classes & we have to continuously modify the changes in All classes. *

Problems

Consumer logic has to take care of creating objects on some condition.
Logic to create object should be duplicated in every consumer code.

whenever new type is introduced, we have to modify the consumer logic.

How the factory design pattern solves the above problems

Consumer has to place their decision, factory pattern will take care of all the decisions to produce products.
Factory Method exposes one public class through which we can pass our condition.
Rule driven logic is now abstract to consumer, just call factory and we have to place our choice.

How to decide if one should use Factory design Pattern

If we have multiple derived classes and consumer can request either of them based on certain condition.

What Everyone Ought to Know About Singelton design pattern

Abhiram — Thu, 02 Mar 2023 04:10:26 +0000

Singleton Pattern

Singleton Pattern says that just "define a class that has only one instance and provides a global point of access to it".

The above image depicts the UML of Singleton design pattern

UML - Unified Modeling Language

Popular for diagrammatic notation.
For Visualization, to understand & remember.
In UML, first block is considered as the class, second block is considered as Attributes & third block is considered as Methods
Signs used such as +, -, # have certain meaning. They will tell which Access modifier is being used.

(+) - Public
(-) - Private
(#) - Protected

Steps to create Singleton design pattern

Through constructor the client can create many objects of a class
So make the constructor as private.
Now, how do we get the instance of the class
Create getInstance method which checks if instance is null or not. If instance is not null, return the same instance or call the constructor to create new instance.
Now how the client can call this method? because methods are called by objects
Client doesn't have object, so no access to constructor. Use static keyword. We do not need instance of the class if we use static.

What is Multithreading and how to handle Multiple threads

In main method, do mistake purposefully in System.out.println we will see error exception in thread main which means main is a thread & by running it we are getting the error.
Normally code runs line by line but if we want 2 things to run simultaneously, then it will be multithreading.
Do Ctrl + Shift + Escape, you will get Task manager go to performance tab in that We can view how many cores are there & in each core 2 threads can be run. So Logical processors = 2 * Cores.
At a time only (Logical processors = 2 * Cores) threads can be run.
In Task manager We will see thousands of threads working at a time. But the (Logical processors = 2 * Cores) threads will take turns & switch within microseconds. That is why we see thousand of threads in numbers.

Why we are handling Mutiple threads in Singleton design pattern

If 2 threads access the getInstance method, both threads will check if instance is null or not. To both of them instance will be null and each thread will create one obecjt.
But our objective in Singleton design pattern is to create one object and use it for all instances. So to avoid this we will use synchronized key word.
To handle multiple threads we will be using synchronized key word. What it does is it will lock the operation until one thread operation is completed. So that multiple threads can not use a method at a time.

In above image we can view we made the getInstance method synchronized so that multiple threads can not access it at the same time

Cons of Singleton design pattern

Should be handled carefully in Multithreaded environment
```
               Happy Reading
```

Why Design Patterns ?

Abhiram — Thu, 16 Feb 2023 15:36:10 +0000

As a developer, as we work on enterprise application problems using a programming language. We document the best practices & common recurring problems and proven solutions to those problems.

The recurring problems and ready-made solutions which can be applied universally are Design Patterns

Design Patterns

Helps to identify recurring problems + Ready-made solution to it.

Example: If you want to create one instance of the class no matter how many times the objects have been created, we can use a design pattern.

Idea of design pattern was born in Civil Engineering.
Gang of Gour have popularized design patterns through their book.

Why Design Patterns

Reuse of particular situation & solution.
Application Structure will get better.
As it is proved and used universally, any developer can understand the flow of Application easily.
Provides common language across all community.

Types Of Design Patterns

Types of design pattern depends on the problem.

Core pattern catalogue.
Java EE patterns catalogue.

Core pattern catalogue -

Creational Design Pattern (Deals with problem's related to Object creation)
Structural Design Pattern (Deals with problem's related to Relationship between classes)
Behavorial Design Pattern (Deals with problem's related to communication should happen between objects and classes)

How To Study & Use Design Patterns?

After learning the basics of object-oriented programming, one should follow the three-step learning process given below:

Acceptance: First, try to accept the fact that design patterns solve commonly occurring problems in object-oriented software design. Hence, when we are developing any object-oriented software we should not complicate the process by reinventing the wheel.

Recognition: Recognize the importance of following the best practices while developing object-oriented software applications. Read about the problems that are solved using design patterns and identify similar problems in your own development work. In this way, we may find a way to use these design patterns efficiently.

Internalization: Once a suitable design pattern is identified for our software application, we can try to implement it and add it internally to our application in such a way that it provides reusability, manageability, and extensibility.

Java Strings...

Abhiram — Wed, 27 Jul 2022 11:37:11 +0000

Java String

In Java, string is basically an object that represents sequence of char values. An array of characters works same as Java string. For example:

char[] ch={'A','B','C','D','E','F','G','H','I','J'};  
String s=new String(ch);  
Is same as
String s="ABCDEFGHIJ";

Java String class provides a lot of methods to perform operations on strings such as compare(), concat(), equals(), split(), length(), replace(), compareTo()

CharSequence Interface

The CharSequence interface is used to represent the sequence of characters. String, StringBuffer and StringBuilder classes implement it. It means, we can create strings in Java by using these three classes.

The Java String is immutable which means it cannot be changed. Whenever we change any string, a new instance is created String objects are immutable. Immutable simply means unmodifiable or unchangeable.. For mutable strings, you can use StringBuffer and StringBuilder classes.

Generally, String is a sequence of characters. But in Java, string is an object that represents a sequence of characters. The java.lang.String class is used to create a string object.

There are two ways to create String object:
1. By string literal
2. By new keyword

When string literal is used to create a string object first it checks whether this string already exists in String Pool. String Pool is a set of string constants that sits in the heap area. If the string already exists in this String Pool then a reference is returned else a new string object is created in this pool and the reference of this newly created object is returned.
When a new keyword is used to create a string object it always creates an object in the heap area and a reference of this object is returned. While creating a string object in the heap area it checks if this string object is present in String Pool or not. If the string object is not present in String Pool then it creates a new object in String Pool as well. But the newly created string variable will always point to the string object in the heap and not in the String Pool.

String Pool Example
public class Main {

        public static void main(String[] args) {

            String name1 = "Tom";
            String name2 = "Tom";//name1.intern();

            String name3 = new String("Bob");
            String name4 = "Bob";

            System.out.println(name1 == name2);
            System.out.println(name3 == name4);

        }
    }

output :
true
false

StringBuilder :

• StringBuilder represents a mutable sequence of characters.
• The instance of this class does not guarantee Synchronization and hence should not be used in multi-threaded environments.
• Wherever possible we should always try to use StringBuilder instead of StringBuffer as StringBuilder is faster than StringBuffer under most implementations.

Below are the StringBuilder class’s methods and descriptions. They can be used as an individual method or in combination.

append(): Appends the string representation of the specified argument to the specified StringBuilder instance sequence.
insert(): Inserts the string representation of the specified argument to the specified StringBuilder instance sequence.

String builder example
public class Main {

        public static void main(String[] args) {

            StringBuilder stringBuilder = new StringBuilder("Abhiram");
            System.out.println(stringBuilder);
            stringBuilder.append(" Karnam");
            System.out.println(stringBuilder);
            stringBuilder.insert(8," Rama");
            System.out.println(stringBuilder);
}}
output:
Abhiram
Abhiram Karnam
Abhiram Rama Karnam

Note: insert method can be used for appending the string at the end of the specified string using the length() function.
stringBuilder.insert("Abhiram".length()," Karnam");
//this results "Abhiram Karnam"

StringBuffer :

• StringBuffer class represents a thread-safe, mutable sequence of characters.

• A string buffer is like a String but it can be modified. At any point in time, it contains some particular sequence of characters, but the length and content of the sequence can be changed through certain method calls.

• The methods of StringBuffer class are synchronized where necessary so that all the operations on any particular instance behave as if they occur in some serial order that is consistent with the order of the method calls made by each of the individual threads involved.

• The principal operations on a StringBuffer instance are the append and insert methods, which are overloaded so as to accept data of any type. Each converts a given data to a string and then appends or inserts the characters of that string to the string buffer.

• The append method always adds these characters at the end of the buffer and the insert method adds the characters at a specified point.

Below are StringBuffer class methods and descriptions. They can be used as an individual method or in combination. These methods are synchronized and can be used for a multi-threaded environment.

append(): Appends the string representation of the specified argument to the specified StringBuffer instance sequence.
insert(): Inserts the string representation of the specified argument to the specified StringBuffer instance sequence.

String buffer example
public class Main {

        public static void main(String[] args) {

            StringBuffer stringBuffer = new StringBuffer("Abhiram");
            System.out.println(stringBuffer);
            stringBuffer.append(" Karnam");
            System.out.println(stringBuffer);
            stringBuffer.insert(8, "Rama ");
            System.out.println(stringBuffer);
        }
    }

output:
Abhiram
Abhiram Karnam
Abhiram Rama Karnam

Java String Example
public class StringExample{    
public static void main(String args[]){    
String s1="java";//creating string by Java string literal    
char ch[]={'s','t','r','i','n','g','s'};    
String s2=new String(ch);//converting char array to string    
String s3=new String("example");//creating Java string by new keyword    
System.out.println(s1);    
System.out.println(s2);    
System.out.println(s3);    
}}

The above code, converts a char array into a String object. And displays the String objects s1, s2, and s3 on console using println() method.

Following are some features of String which makes String objects immutable.

1. ClassLoader:

A ClassLoader in Java uses a String object as an argument. Consider, if the String object is modifiable, the value might be changed and the class that is supposed to be loaded might be different.To avoid this kind of misinterpretation, String is immutable.

2. Thread Safe:

As the String object is immutable we don't have to take care of the synchronization that is required while sharing an object across multiple threads.

3. Security:

As we have seen in class loading, immutable String objects avoid further errors by loading the correct class. This leads to making the application program more secure. Consider an example of banking software. The username and password cannot be modified by any intruder because String objects are immutable. This can make the application program more secure.

4. Heap Space:

The immutability of String helps to minimize the usage in the heap memory. When we try to declare a new String object, the JVM checks whether the value already exists in the String pool or not. If it exists, the same value is assigned to the new object. This feature allows Java to use the heap space efficiently.

Why String class is Final in Java?

The reason behind the String class being final is because no one can override the methods of the String class. So that it can provide the same features to the new String objects as well as to the old ones.

**Happy reading friends....**

Java Arrays.....

Abhiram — Wed, 27 Jul 2022 10:01:13 +0000

Array ?

In your coding journey, you will find that arrays are used in many problems, no matter which programming language you choose, the usage of arrays will be there.

 An Array is a collection of similar data types stored in contiguous memory locations.
 At the time of declaration of an array, you must specify the type of data with the array name
 . You can access different elements present in an array using their index.

Array declaration syntax in Java:
int [] intArray;

• An array is fixed in length i.e static in nature.
• An array can hold primitive types and object references.
• In an array when a reference is made to a nonexistent element, an IndexOutOfRangeException occurs

Advantages
o Code Optimization: It makes the code optimized, we can retrieve or sort the data efficiently.
o Random access: We can get any data located at an index position.
Disadvantages
o Size Limit: We can store only the fixed size of elements in the array. It doesn't grow its size at runtime. To solve this problem, collection framework is used in Java which grows automatically.

There are two types of array.
o Single Dimensional Array
o Multidimensional Array

Example of Java Array
Let's see the simple example of java array, where we are going to declare, instantiate, initialize and traverse an array.Java Program : how to declare, instantiate, initialize and traverse the Java array.

class Testarray{  
public static void main(String args[]){  
int a[]=new int[5];//declaration and instantiation  
a[0]=10;//initialization  
a[1]=20;  
a[2]=70;  
a[3]=40;  
a[4]=50;  
//traversing array  
for(int i=0;i<a.length;i++)//length is the property of array  
System.out.println(a[i]);  
}}

For-each Loop for Java Array
We can also print the Java array using for-each loop. The Java for-each loop prints the array elements one by one. It holds an array element in a variable, then executes the body of the loop.

//Java Program to print the array elements using for-each loop  
class Testarray1{  
public static void main(String args[]){  
int arr[]={33,3,4,5};  
//printing array using for-each loop  
for(int i:arr)  
System.out.println(i);  
}}

Anonymous Array in Java
Java supports the feature of an anonymous array, so you don't need to declare the array while passing an array to the method.

//Java Program to demonstrate the way of passing an anonymous array to method.

class TestAnonymousArray{
//creating a method which receives an array as a parameter
static void printArray(int arr[]){
for(int i=0;i<arr.length;i++)
System.out.println(arr[i]);
}
public static void main(String args[]){
printArray(new int[]{10,22,44,66});//passing anonymous array to method
}}

ArrayIndexOutOfBoundsException
The Java Virtual Machine (JVM) throws an ArrayIndexOutOfBounds Exception if length of the array in negative, equal to the array size or greater than the array size while traversing the array.

Multidimensional Array in Java
In such case, data is stored in row and column based index (also known as matrix form).
Example to instantiate Multidimensional Array in Java int[][] arr=new int[3][3];//3 row and 3 column
Example of Multidimensional Java Array
Let's see the simple example to declare, instantiate, initialize and print the 2Dimensional array.

 //Java Program to illustrate the use of multidimensional array  

class Testarray3{  
public static void main(String args[]){  
//declaring and initializing 2D array  
int arr[][]={{1,2,3},{2,4,5},{4,4,5}};  
//printing 2D array  
for(int i=0;i<3;i++){  
 for(int j=0;j<3;j++){  
   System.out.print(arr[i][j]+" ");  
 }  
 System.out.println();  
}  
}}

Output

Copying a Java Array
We can copy an array to another by the arraycopy() method of System class.
Syntax of arraycopy method

Syntax of arraycopy method
public static void arraycopy(  
Object src, int srcPos,Object dest, int destPos, int length  )  

//Java Program to copy a source array into a destination array in Java  

class TestArrayCopyDemo {  
    public static void main(String[] args) {  
        //declaring a source array  
        char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e',  
                'i', 'n', 'a', 't', 'e', 'd' };  
        //declaring a destination array  
        char[] copyTo = new char[7];  
        //copying array using System.arraycopy() method  
        System.arraycopy(copyFrom, 2, copyTo, 0, 7);  
        //printing the destination array  
        System.out.println(String.valueOf(copyTo));  
    }  
}

Output

Cloning an Array in Java
Since, Java array implements the Cloneable interface, we can create the clone of the Java array. If we create the clone of a single-dimensional array, it creates the deep copy of the Java array. It means, it will copy the actual value. When the clone method is invoked upon an array, it returns a reference to a new array which contains (or references) the same elements as the source array.
So in your example, int[] arr is a separate object instance created on the heap and int[] carr is a separate object instance created on the heap. (Remember all arrays are objects).

//Java Program to clone the array  
class Testarray1{  
public static void main(String args[]){  
int arr[]={33,3,4,5};  
System.out.println("Printing original array:");  
for(int i:arr)  
System.out.println(i);  

System.out.println("Printing clone of the array:");  
int carr[]=arr.clone();  
for(int i:carr)  
System.out.println(i);  

System.out.println("Are both equal?");  
System.out.println(arr==carr);  

}}

Output

Addition of 2 Matrices in Java
Let's see a simple example that adds two matrices.

//Java Program to demonstrate the addition of two matrices in Java  

class Testarray5{  
public static void main(String args[]){  
//creating two matrices  
int a[][]={{1,3,4},{3,4,5}};  
int b[][]={{1,3,4},{3,4,5}};  

//creating another matrix to store the sum of two matrices  
int c[][]=new int[2][3];  

//adding and printing addition of 2 matrices  
for(int i=0;i<2;i++){  
for(int j=0;j<3;j++){  
c[i][j]=a[i][j]+b[i][j];  
System.out.print(c[i][j]+" ");  
}  
System.out.println();//new line  
}  

}}

output

Multiplication of 2 Matrices in Java
In the case of matrix multiplication, a one-row element of the first matrix is multiplied by all the columns of the second matrix which can be understood by the image given below.

//Java Program to multiply two matrices  
public class MatrixMultiplicationExample{  
public static void main(String args[]){  
//creating two matrices    
int a[][]={{1,1,1},{2,2,2},{3,3,3}};    
int b[][]={{1,1,1},{2,2,2},{3,3,3}};    

//creating another matrix to store the multiplication of two matrices    
int c[][]=new int[3][3];  //3 rows and 3 columns  

//multiplying and printing multiplication of 2 matrices    
for(int i=0;i<3;i++){    
for(int j=0;j<3;j++){    
c[i][j]=0;      
for(int k=0;k<3;k++)      
{      
c[i][j]+=a[i][k]*b[k][j];      
}//end of k loop  
System.out.print(c[i][j]+" ");  //printing matrix element  
}//end of j loop  
System.out.println();//new line    
}    
}}

** ** Happy reading friends..... ****

Algorithm...

Abhiram — Mon, 28 Mar 2022 13:41:59 +0000

What Is An Algorithm?

In mathematics and computer science, an algorithm is a finite sequence of well-defined instructions, typically used to solve a class of specific problems or to perform a computation.

A good algorithm should be optimized in terms of time and space. Different types of problems require different types of algorithmic-techniques to be solved in the most optimized manner. There are many types of algorithms

example,

An algorithm to add two numbers:

Take two number inputs

Add numbers using the + operator

Display the result

Important basic rules to follow

Input and output should be defined precisely.
Each step in the algorithm should be clear and unambiguous.
Algorithms should be most effective among many different ways to solve a problem.

Why are Algorithms Important ?

The ability to define clear steps to solve a problem, is crucial in many different fields. Knowingly or unknowingly, we use algorithms and algorithmic thinking all the time. It allows us to break down problems and find the best possible solutions in terms of discrete steps.

The efficiency of an algorithm depends on two parameters:

1. Time Complexity

2. Space Complexity

**Time Complexity: **Time Complexity is defined as the number of times a particular instruction set is executed rather than the total time is taken. It is because the total time taken also depends on some external factors like the compiler used, processor’s speed, etc.

**Space Complexity: **Space Complexity is the total memory space required by the program for its execution.

Types of Algorithms

Algorithms are classified based on the concepts that they use to accomplish a tasks. Below are the widely known and widely used few algorithm techniques.

Divide and conquer algorithms –
In Divide and Conquer algorithms, the idea is to solve the problem in two sections, Divide the problem into smaller subproblems of the same type; solve those smaller problems, and combine those solutions to solve the original problem.

Brute force algorithms –
This is the most basic and simplest type of algorithm. A Brute Force Algorithm is the straightforward approach to a problem i.e., the first approach that comes to our mind on seeing the problem. More technically it is just like try all possible solutions until a satisfactory solution is found.

Greedy algorithms –
Find an optimal solution at the local level with the intent of finding an optimal solution for the whole problem.

Recursive algorithms –
Solve the lowest and simplest version of a problem to then solve increasingly larger versions of the problem until the solution to the original problem is found.

Backtracking algorithms –
Divide the problem into subproblems, each which can be attempted to be solved; however, if the desired solution is not reached, move backwards in the problem until a path is found that moves it forward.

Dynamic programming algorithms –
This type of algorithm is also known as the memorization technique because in this the idea is to store the previously calculated result to avoid calculating it again and again. In Dynamic Programming, divide the complex problem into smaller overlapping subproblems and storing the result for future use.

Break a complex problem into a collection of simpler subproblems, then solve each of those subproblems only once, storing their solution for future use instead of re-computing their solutions.

Sorting Algorithms

A sorting algorithm is an algorithm that puts elements of a list in a certain order. Sorting is often an important first step in algorithms that solves more complex problems. There are a large number of sorting algorithms, each with their own benefits and costs. Below, we will focus on some of the more famous sorting algorithms.

Linear sort:
Find the smallest element in the list to be sorted, add it to a new list, and remove it from the original list. Repeat this until the original list is empty.

Bubble sort:
Compare the first two elements in the list, and if the first is greater than the second, swap them. Repeat this with every pair of adjacent elements in the list. Then, repeat this process until the list is fully sorted.

Insertion sort:
Compare each element in the list to all the prior elements until a smaller element is found. Swap these two elements. Repeat this process until the list is fully sorted.

Why Data Structures..

Abhiram — Mon, 28 Mar 2022 09:18:42 +0000

Data structures are used in computing to make it easy to locate and retrieve information.

Primitive data structures are simple ways for programming languages to represent basic values. These include data types like integer, char (character), Boolean, pointers, and the like.

Non-primitive data structures provide ways of storing multiple values in a single variable. These include arrays, linked lists, stacks, graphs, trees etc..

In each case, the way the data is "structured" makes it easy to retrieve or manipulate.

- They should be efficient. 
Data structures make programs more productive with regards to time. ...
- They should be reusable.
 Once a data structure is implemented, it needs to demonstrate
 an ability to be used for other, similar data needs. ...
- They should remain hidden.

Types of Data Structure

Basically, data structures are divided into two categories:

- Linear data structure
- Non-linear data structure

Linear data structures

In linear data structures, the elements are arranged in sequence one after the other. Since elements are arranged in particular order, they are easy to implement.

Popular linear data structures are:
1. Array Data Structure

An array is a data structure that contains a group of elements. Typically these elements are all of the same data type, such as an integer or string. Arrays are commonly used in computer programs to organize data so that a related set of values can be easily sorted or searched.

2. Stack Data Structure

Stack is a linear data structure which follows a particular order in which the operations are performed. The order may be LIFO (Last In First Out) or FILO (First In Last Out). It works just like a pile of plates where the last plate kept on the pile will be removed first.

3. Queue Data Structure

The queue is a linear data structure used to represent a linear list. It allows insertion of an element to be done at one end and deletion of an element to be performed at the other end

Unlike stack, the queue data structure works in the FIFO principle where first element stored in the queue will be removed first.

4. Linked List Data Structure

A linked list is the most sought-after data structure when it comes to handling dynamic data elements. A linked list consists of a data element known as a node. And each node consists of two fields: one field has data, and in the second field, the node has an address that keeps a reference to the next node. Each node contains the data items and address to the next node.

Non linear data structures

Unlike linear data structures, elements in non-linear data structures are not in any sequence. Instead they are arranged in a hierarchical manner where one element will be connected to one or more elements.

1. Graph Data Structure

Graphs in data structures are used to address real-world problems in which it represents the problem area as a network like telephone networks, circuit networks, and social networks. For example, it can represent a single user as nodes or vertices in a telephone network, while the link between them via telephone represents edges.

In graph data structure, each node is called vertex and each vertex is connected to other vertices through edges.

2. Trees Data Structure

Among various real-world applications, the tree data structure is used to demonstrate relationships between different nodes with the parent-child hierarchy. It is also called a hierarchic data structure because of this. It is most popular for simplifying and speeding up searching and sorting.
Similar to a graph, a tree is also a collection of vertices and edges. However, in tree data structure, there can only be one edge between two vertices.

What is Hacktoberfest and Why you should care

Abhiram — Mon, 07 Dec 2020 11:37:27 +0000

Hacktoberfest is open to everyone in our global community. Whether you're a developer, student learning to code, event host, or company of any size, you can help drive growth of open source and make positive contributions to an ever-growing community.

During the entire month of October, all you have to do is contribute to any open source projects and open at least 4 pull requests.

Yes, any project and any kind of contributions. You don’t need to be an expert in programming or coding. It can be a be a bug fix, improvement, or even a documentation change! And win an awesome T-shirt and awesome stickers.

Why should I do it ?

Support open source , it’s not just about the t-shirts or stickers. Its about supporting open source. Its about celebrating open source, and giving it back. If you’ve never contributed to open source before, this is the perfect time to get started because Hacktoberfest provides a large list of available contribution opportunities.

5 ways to contribute to open source during Hacktoberfest

Start with open source you use every day
Explore based on your interests
Encourage projects to participate in Hacktoberfest
Use and improve documentation
Skip the code and host an event

Reasons why you should contribute to open source projects

Contributing to an open source project helps you gain a much deeper knowledge about the software.Moreover, it is absolutely normal that your changes won’t be accepted in the first run.

However, this way you get in touch with other experienced people working on the project, giving you valuable insights and feedback, as well. In fact, getting in touch with the people, who actually develop the code base of an open source project, is beneficial .

Most software projects have a roadmap, that aims to help you to plan for the future. These usually include bug fixes and features at varying granularity lined up in a rough schedule, ranging from weeks to years. For commercial, closed source projects this roadmap, however, is of little help, when it comes to dealing with the risks of not finishing essential parts of it in time.

Open source contribution can be an amazing learning experience. It allows you to give back to and be a part of communities that build valuable open source software. It enables you to make software that you use better. Although it can be tough to start, once you get the hang of it, it is immensely rewarding.

Alternatives to Github

Abhiram — Mon, 07 Dec 2020 08:21:43 +0000

I have recently started using Github.I used to think Github as an Online platform just to hold files.Now, by using Github for my project , I was truly amazed by its true potential.

I will explain it with an example.

Imagine you are given a room to do whatever you want to with your accessories , customize our furniture as per your suitability any time. Permitted to share the place with some one, bring people to come at your place and party together and you don’t have to pay or rent all this with any bills. How cool would that be…!!

Github is a similar space. You have got a free space to hold all types of files ie - python, java, c, html, js, nodejs,images etc. You may customize your code any day, any time, any where . You can give access to people to contribute, commit changes to your work. Download your project’s code and use it for their work. Follow you and your work and lot more.

Pros of GitHub

It makes it easy to contribute to your open source projects
Documentation
Showcase your work
Markdown
Track changes in your code across versions

Cons of Github

1.You have to be careful with merge operations; a bad merge can be painful to reverse.
2.Searching is good but not great.
3.Restrictions on file size and repository size.

Alternatives to Github

bitbucket

Bitbucket is more flexible than GitHub.While GitHub comes
with a lot of features and allows you to create your own workflows, Bitbucket arguably has more flexibility built-in.

Bitbucket can also import from Git, CodePlex, Google Code, SourceForge, and SVN. GitHub, meanwhile, can import from Git, SVN, HG, and TFS. Using Bitbucket, you can work precisely the way that you want, without having to try and jam a square peg into a round hole.

Gitlab

GitLab is a repository that only lets its team of web developers collaborate on codes. GitLab allows its users to locate a repository inside an organization while using the free plan.GitLab documents are similar to documentation for a language with a search bar, listing all the documents required for the installer.
With GitLab you can set and modify people’s permissions according to their role. In GitHub, you can decide if someone gets a read or write access to a repository.

With GitLab you can provide access to the issue tracker (for example) without giving permission to the source code. This is obviously great for larger teams and enterprises with role-based contributors.

AWS CodeCommit

Amazon's Git-based version control service is also an ideal for companies which are using other AWS services. With scalable cloud storage and no size limits.

Offers easy Access and Integration .AWS CodeCommit tool is designed for collaborative software development.Allows helps you to transfer files to and from AWS CodeCommit using HTTPS or SSH .It allows you to create as many repositories

My thought

Developers who prefer to use Git as the core of their source code management workflow, but don't want to rely on GitHub, have plenty of options. GitHub may still dominate the market, but depending on your specific needs and use cases, a competing platform may be a better fit.

DEV Community: Abhiram

🚀 Demystifying APIs and REST with Spring Boot: Crafting Product Services Made Easy🚀

What is API

*Major things we will follow in API are *

- HTTP methods

- Endpoint URL

- Request

- Response

Above all forms the API contract, which means

- What is REST ?

- API Hands-On

- Request will be like

- Response will be like**

What is DTO ?

Output is can be seen below

If we simplify this

🚀 Mastering Collaboration in Software Development: A Deep Dive into Version Control Systems & Git 🚀

Version Control System:

Let us do the hands on regarding all the above locations

Understanding the Factory Design Pattern: A Beginner's Guide

Factory Design Pattern

Real world example

Problems

How the factory design pattern solves the above problems

What Everyone Ought to Know About Singelton design pattern

Singleton Pattern

UML - Unified Modeling Language

Steps to create Singleton design pattern

What is Multithreading and how to handle Multiple threads

Why we are handling Mutiple threads in Singleton design pattern

Cons of Singleton design pattern

Why Design Patterns ?

Design Patterns

Why Design Patterns

Types Of Design Patterns

How To Study & Use Design Patterns?

Java Strings...

Java String

Java Arrays.....

Array ?

Algorithm...

What Is An Algorithm?

Types of Algorithms

Sorting Algorithms

Why Data Structures..

Linear data structures

Non linear data structures

What is Hacktoberfest and Why you should care

Why should I do it ?

5 ways to contribute to open source during Hacktoberfest

Reasons why you should contribute to open source projects

Alternatives to Github

Pros of GitHub

Cons of Github

Alternatives to Github

bitbucket

Gitlab

AWS CodeCommit

My thought

Major things we will follow in API are