DEV Community: rajubora

Exception In java and hierarchy

rajubora — Tue, 04 Jun 2024 18:37:57 +0000

While trying to understand the concept of exception in java , it becomes necessary to understand the hierarchy of exceptions becauce
we can see a famous interview question from exception hierarchy in java developer interview.

suppose we have a parent class with a method that throws IO exception , also there is a sub class that overrides the method of parent class throws FileNotFoundException , will this code works fine or not?

The answer is no because in Java the overridden method in the subclass cannot throw a broader or more general exception than the method in the parent class.

In our scenario IOException is a broader exception than FileNotFoundException, so the overriding method in the subclass is not allowed to throw FileNotFoundException (which is a subclass of IOException) .

let us understand by an example :

We have a parent class

import java.io.FileNotFoundException;
import java.io.IOException;
class ParentClass {
    // Method that throws a narrower exception
    public void Method() throws FileNotFoundException {
        System.out.println("IncorrectParentClass: Method");
        if (true) {
            throw new FileNotFoundException("FileNotFoundException from ParentClass");
        }
    }
}

Now we are inheriting all the features of super class in our base
class:

 class ChildClass extends ParentClass {
    // Overriding method that throws a broader exception
    @Override
    public void Method() throws IOException {
        System.out.println("IncorrectChildClass: Method");
        if (true) { 
            throw new IOException("IOException from ChildClass");
        }
    }
}

Now Declaring Main class:

public class Main {
    public static void main(String[] args) {
             ParentClass parent =   new ParentClass();
             ChildClass  child   =  new ChildClass();

        try {
            parent.Method();    
        } catch (FileNotFoundException e) {
            System.out.println("Caught FileNotFoundException from parent: " + e.getMessage());
        }

        try {
            child.Method();
        } catch (IOException e) {
            System.out.println("Caught IOException from child: " + e.getMessage());
        }
    }
}

When we try to compile Main.java along with ParentClass.java and ChildClass.java, you will get a compilation error indicating that IOException is broader than FileNotFoundException.

The ChildClass will not compile because it violates the rule that an overriding method cannot throw a broader exception than the method it overrides.

Comparable and Comparator in Java

rajubora — Sun, 12 May 2024 08:25:35 +0000

In java-8 comparable and comparator interface are used for sorting object using custom logic .
However there are some diffrences between them listed as below :

Comparable Interface :

For implementing comparable interface we have to override the compareTo() method.
CompareTo method takes only one arguement, which is the object being compared.
This CompareTo method has to be implemented in the class to define the natural ordering of the objects.
It allow us to define single sorting criteria.
Interface Signature :

public interface Comparable<T> {
    public int compareTo(T o);
}

Comparator Interface :

For implementing Comparator interface we have to override the compare() method of the interface.
This method takes two parameters and compares them (o1 and o2)
and returns:

a negative integer if o1 is less than o2.
zero if o1 is equal to o2.
a positive integer if o1 is greater than o2.

It allow is to define multiple sorting criteria and can be used to sort object in diffrent ways.
Interface Signature :

public interface Comparator<T> {
    public int compare(T o1, T o2);
}

Example :

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

// Example class representing a Student
class Student implements Comparable<Student> {
    private String name;
    private int id;
    private int age;

    // Constructor
    public Student(String name, int id, int age) {
        this.name = name;
        this.id = id;
        this.age = age;
    }

    // Getters
    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public int getAge() {
        return age;
    }

    // Implementing Comparable interface based on student id
    @Override
    public int compareTo(Student other) {
        return Integer.compare(this.id, other.id);
    }

    // toString method for displaying student details
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", age=" + age +
                '}';
    }
}

// Comparator to sort students by age
class AgeComparator implements Comparator<Student> {
    @Override
    public int compare(Student s1, Student s2) {
        return Integer.compare(s1.getAge(), s2.getAge());
    }
}

public class ComparableComparatorExample {
    public static void main(String[] args) {
        // Creating a list of students
        List<Student> students = new ArrayList<>();
        students.add(new Student("Ram", 101, 20));
        students.add(new Student("Shyam", 102, 22));
        students.add(new Student("Raj", 103, 21));
        // Sorting students using Comparable (by student id)
        Collections.sort(students);
        System.out.println("Students sorted by ID (Comparable):");
        for (Student student : students) {
            System.out.println(student);
        }

        // Sorting students using Comparator (by age)
        Collections.sort(students, new AgeComparator());
        System.out.println("\nStudents sorted by Age (Comparator):");
        for (Student student : students) {
            System.out.println(student);
        }
    }
}

In above Example :

The Student class implements the Comparable interface based on the student ID. This allows sorting a list of students by their IDs.
The AgeComparator class implements the Comparator interface to provide custom sorting logic based on student ages.
In the main method, we create a list of Student objects and sort them first using the natural ordering defined by Comparable and then using the custom ordering defined by Comparator.

Apache Kafka :

rajubora — Wed, 24 Jan 2024 19:33:01 +0000

Apache Kafka is an open-source distributed system consisting of servers and clients, which is created by linkedin. Apache Kafka is used by thousands of the world's leading organizations for high-performance data pipelines, streaming analytics, data integration and many other vital applications. Apache Kafka act as an communicaiton/transportation tool between the source system to target system with the following use cases :

Messaging systems
Activity Tracking
Application logs analysis
Decoupling of system dependencies
Integration with Big Data technologies like Spark, Flink, Storm, Hdoop.

Why apache kafka :

Distributed , resilient architecture , fault tolerance .
Horizontal scalability :
- can scale to 100s of brokers .
- can scale to millions of messages per second .
High performance latency of less then 10ms in real time.

following are the companies name that uses apache kafka for real time solutions :

1) Netflix uses kafka to apply recommendations in real time while
you are watching TV shows .

2) Uber uses kafka to gather user , taxi and trip data in real
time to compute and forcast demand and compute pricing in real
time .
3) Linkedin uses kafka to prevent spam , collect user interactions
to make better connection recommendation in real time .

Actuators in SpringBoot :

rajubora — Thu, 11 Jan 2024 16:55:19 +0000

Actuators are the list of endpoints which are provided by spring boot by default so that our applications has production ready features. the main benefit of actuators is that we can get production grade tool without having implement these features by ourselves .

To enable spring boot actuator , we need to add spring boot actuator dependency in
pom.xml :

<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> </dependency>

also add configuration to application.property file:

management.endpoints.web.exposure.include=*

some of the endpoints :

/health - it summarizes the health status of application.
/loggers- it enables us to query and modify the logging level of
our application.
/env - returns the current enviroment property .
/info - returns general information.
/beans - returns all available beans in our BeanFactory.

There are many benefits of using actuators but main is that we can check the health of microservices .for example there is an order service and a discovery server. the server send message to the service in every T seconds to check wheather service is UP or Down . if it is UP then order service send status code 200 otherwise 500 or 503 .
here T seconds should be chosen in a such a manner so that the api calls should be minimum .

Service Discovery :

rajubora — Sat, 06 Jan 2024 08:58:46 +0000

In a microservices architecture, a discovery Server is a component that helps microservices locate and communicate with each other within the distributed system. Since microservices contains
number of services so ,for storing all the services together at a location we have to use service registry at that point . Commonly used service registries include tools like Eureka, Consul, and ZooKeeper.
By using Service discovery and service registry, microservices can achieve better scalability, flexibiliy.

1) In Springboot based application we can use Service Discovery(Service Registry) as Server by adding a dependency in pom.xml file :

<dependency>
   <groupId>org.springframework.cloud</groupId> 
   <artifactId>spring-cloud-starter-netflix-eureka- 
    server</artifactId>
</dependency>

After adding dependency the next step is to add the scripts in application.yml or property file :

                  eureka:
                     instance:
                           hostname: localhost
                      client:
                            register-with-eureka: false
                            fetch-registry: false
                  sever:
                      port: 8761

by adding above scripts the service will acts as a Eureka server where we can store all the client services .

2) For Using Service Discovery as client we have to add another dependency in pom.xml file:

  <dependency>
     <groupId>org.springframework.cloud</groupId>
     <artifactId>spring-cloud-starter-netflix-eureka- 
       client</artifactId>
  </dependency>

Next step is to add scripts in Application.yml or property file :

      eureka:
            instance:
              prefer-ip-address: true
         client:
             register-with-eureka: true
             fetch-registry: true
             serviceUrl:
                defaultZone: http://localhost:8761/eureka/

by adding these scripts the service will act as a eureka client and automatically store into Service Registry

Note that : netflix-eureka-server are the servers of Netflix itself which is configured by spring developers for using it in springboot application .