DEV Community: Rajendra🙏🏼👇🏽

Basics of Resilience4j with spring boot

Rajendra🙏🏼👇🏽 — Fri, 27 Mar 2020 03:43:51 +0000

What is a Circuit Breaker pattern?

The circuit breaker pattern is something that can prevent from repeatedly trying to call a service or a function that will likely fail and save CPU cycles.

It is pretty common for a software service to call remote software service and the remote service can fail or not respond as expected and this is pretty common in a microservice architecture when you have hundreds of clients calling the service which is failing eventually all the resources get used up, that is why it is a best practice to implement circuit breaker pattern in those scenarios.

How does Circuit Breaker work?

Circuit Breaker has three states Closed State, Open State, Half Open State. The image below shows how the flow from one state to another changes. The Circuit Breaker will be in the Closed state when everything is running as expected when failure starts coming it waits until the set threshold limit is reached then goes to Open state. While in Open states no calls will be going to failing remote service until certain wait time, then it goes to Half-Open state, in this stage reduced amount of calls goes to remote service to make sure the calls are successful, IF the calls are responding as expected it will go to Closed state or it goes back to Open state avoiding calls to failing remote service.

What is Resilience4j?

Resilience4j is a lightweight, easy-to-use fault tolerance library designed for Java 8 and functional programming, it is a lightweight as it doesn't depend on any other external libraries.

If you are a video person here is the video tutorial

Please show some love and subscribe to my channel Subscribe Hacker Heap.

Implementation with Spring boot2

Add the dependency to pom.xml

<dependency>
            <groupId>io.github.resilience4j</groupId>
            <artifactId>resilience4j-spring- 
                            boot2</artifactId>
            <version>1.3.1</version>
</dependency>

Add the required configurations to application.yml file or application.properties file

resilience4j:
  circuitbreaker:
    configs:
      default:
        registerHealthIndicator: true
        slidingWindowSize: 10
        minimumNumberOfCalls: 5
        permittedNumberOfCallsInHalfOpenState: 3
        automaticTransitionFromOpenToHalfOpenEnabled: true
        waitDurationInOpenState: 5s
        failureRateThreshold: 50
        eventConsumerBufferSize: 10
        recordExceptions:
                - org.springframework.web.client.HttpServerErrorException
                - java.util.concurrent.TimeoutException
                - java.io.IOException
    instances:
      mainService:
        baseConfig: default

The above is the base configuration for resilience4j, waitDurationInOpenState is how much time the circuit breaker will be in Open state before it goes to Half-Open state .
failureRateThreshold sets the threshold limit before it goes to the open state.
recordExceptions records the type of exception on which you want your circuit breaker to be activated.
You can have multiple profiles for different service calls or operations, the above configuration has just one profile default, which is assigned to the mainService declared in the below class.

package com.springsleuth.demo.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;

@RestController
public class MainServiceController {

    private static final Logger LOGGER = LoggerFactory.getLogger(MainServiceController.class);

    private static final String MAIN_SERVICE = "mainService";

    @Autowired
    private RestTemplate restTemplate;

    @Bean
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }


    @GetMapping("/getSleuthTest")
    @ResponseStatus(HttpStatus.OK)
    @CircuitBreaker(name = MAIN_SERVICE, fallbackMethod="testFallBack")
    public ResponseEntity<String> getSleuthTest(){
        LOGGER.info("I'm here in main service calling service one");
        String response = restTemplate.getForObject("http://localhost:8081/serviceOne", String.class);
        return new ResponseEntity<String>(response, HttpStatus.OK);

    }


    private  ResponseEntity<String> testFallBack(Exception e){
        return new ResponseEntity<String>("In fallback method", HttpStatus.INTERNAL_SERVER_ERROR);
    }

}

In the above class, we activated circuit breaker using @CircuitBreaker annotations, it has two parameters.
1) service name, which is the service name defined in the config file (mainService) with default profile.
2) fallBackMethod, which is called when an error occurs, fallBackMethod is optional.

Spring Cloud Sleuth Tutorial With Zipkin

Rajendra🙏🏼👇🏽 — Mon, 16 Mar 2020 03:59:39 +0000

As microservice architecture has become a standard for all the latest distributed systems, the tracing of the calls from one microservice to others has been a challenging thing for a while.

To solve this Sprig Cloud introduced Spring Sleuth which borrows heavily from dapper. Spring sleuth adds traceID and spanID to the logs so it makes easy to trace a microservice/ web service call.

In this tutorial, we will implement Spring Sleuth and integrate with Zipkin which is a distributed tracing system that provides a UI that lets us search the transactions using traceID and also view the dependency diagram which shows how many traced transactions went through each microservice.

Let's create three spring boot microservice namely ServiceOne ServiceTwo ServiceThree.
In each of the services add the dependencies for Spring Sleuth, Zipkin, and spring boot stater web, the resultant pom.xml file should like below.

If you are a video person here is the video tutorial

Please show some love and subscribe to my channel Subscribe.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>MainService</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>Service One</name>
    <description>Spring Boot With Spring Sleuth</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.SR3</spring-cloud.version>
    </properties>

    <dependencies>
    <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web-services</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-sleuth</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zipkin</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

Add a RestController for three services each having GET endpoints /serviceOne /serviceTwo /serviceThree as shown below.

package com.springsleuth.demo.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
public class ServiceOneController {

    private static final Logger LOGGER = LoggerFactory.getLogger(ServiceOneController.class);

    @Autowired
    private RestTemplate restTemplate;

    @Bean
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }

    @GetMapping("/serviceOne")
    @ResponseStatus(HttpStatus.OK)
    public ResponseEntity<String> getSleuthTest(){
        LOGGER.info("I'm here in service calling service two");
        String response = restTemplate.getForObject("http://localhost:8081/serviceTwo", String.class);
        return new ResponseEntity<String>(response, HttpStatus.OK);

    }

}

Spring Sleuth has the capability to integrate the same traceId to the microservice chain if the services are called using RestTemplate and have been Autowired, create the restTemplate object like the one in the above example and auto-wire so that spring handles the dependency injection.

We have the endpoint for serviceOne is ready, and create the endpoints for serviceTwo and serviceThree similar to the above serviceOne example below is the code for serviceTwo and serviceThree controllers.

package com.springsleuth.demo.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
public class ServiceTwoController {

    private static final Logger LOGGER = LoggerFactory.getLogger(ServiceTwoController.class);

    @Autowired
    private RestTemplate restTemplate;


    @Bean
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }


    @GetMapping("/serviceTwo")
    @ResponseStatus(HttpStatus.OK)
    public ResponseEntity<String> getServiceTwo() throws Exception {
        LOGGER.info("Here inside service two ");
        String response =  restTemplate.getForObject("http://localhost:8080/serviceThree", String.class);
        return new ResponseEntity<String>(response, HttpStatus.OK);
    }

}

package com.springsleuth.demo.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
public class ServiceThreeController {

    private static final Logger LOGGER = LoggerFactory.getLogger(ServiceThreeController.class);

    @Autowired
    private RestTemplate restTemplate;


    @Bean
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }


    @GetMapping("/serviceThree")
    @ResponseStatus(HttpStatus.OK)

    public ResponseEntity<String> getServiceThree() throws Exception {
        LOGGER.info("Here inside service Three ");
        return new ResponseEntity<String>("Success calling Spring Sleuth", HttpStatus.OK);
    }

}

Application Properties

Since we will be running all the three microservices on the same machine we will have them run on different ports, set the ports in the application.properties file of the respective projects. The appliction.properties file will have two attributes service.name and server.port like below.

spring.application.name=serviceOne
server.port=8080

Zipkin Setup

Zipkin is an open-source project that you can download using the below command, more about Zipkin can be found at Zipkin.io.

curl -sSL https://zipkin.io/quickstart.sh | bash -s

Once downloaded run Zipkin jar using the following command.

java -jar zipkin.jar

Zipkin UI can be seen at localhost:9094/zipkin, which looks like below.

Now let's start all the three microservices on different ports, and hit the serviceOne endpoint. Use the log below with [serviceName, traceId, spanId, True/False] these are added by spring sleuth and we have nothing to do.

2020-03-14 23:31:05.084  INFO [serviceOne,2ed9f774e90e9450,2ed9f774e90e9450,true] 17903 --- [nio-8082-exec-2] c.s.d.controller.MainServiceController   : I'm here in main service calling service one

2020-03-14 23:31:05.181  INFO [serviceTwo,2ed9f774e90e9450,4bc477a78961a834,true] 17902 --- [nio-8081-exec-1] c.s.d.controller.ServiceTwoController    : Here inside service Two 

2020-03-14 23:31:05.304  INFO [serviceThree,2ed9f774e90e9450,dbc9d06429c2394a,true] 17901 --- [nio-8080-exec-1] c.s.d.controller.ServiceOneController    : Here inside service Three

If you observe the above logs all the logs for three microservices has the same traceID for the call, now go back to zipkin UI and search with the traceID and you we the calls going from one service to other like below, it also shows the time taken for each call.

If you are a video person here is the video tutorial

Intro to GraphQL With Apollo Server

Rajendra🙏🏼👇🏽 — Tue, 28 Jan 2020 00:46:49 +0000

This is a basic introduction to GraphQL with Apollo Server, originally posted on my Youtube Channel.

Please show some love and subscribe to my channel Subscribe.

Netflix Eureka Server And Client Setup With Spring Boot

Rajendra🙏🏼👇🏽 — Tue, 21 Jan 2020 04:12:48 +0000

Overview

We will set up a Eureka server (service registry used to register multiple services/microservices).
We will set up multiple Eureka clients(REST services that register to Eureka Server).
We will do client-side load balancing and service discovery through Eureka.

Here is the video tutorial. Please show some love and subscribe to my channel Subscribe.

Setting up Eureka Server

The dependency required to set up a eureka server is "spring-cloud-starter-netflix-eureka-client" along with spring-boot-starter-parent. you can generate the code by going to https://start.spring.io/, and provide the group id, artifact id and provide the required dependencies as shown below, and click on generate which will generate the sample code with dependency added to your pom.xml

The corresponding pom.xml should look like the below

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>eurekaserver</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>eurekaserver</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.SR1</spring-cloud.version>
    </properties>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

Once you have the project open the main Springboot Class with annotation @SpringbootApplication and add the annotation @EnableEurekaServer, the class should look like this.

package com.example.eurekaserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class EurekaserverApplication {

    public static void main(String[] args) {
        SpringApplication.run(EurekaserverApplication.class, args);
    }

}

The last step in setting up the server is adding the application.yml file which will have eureka relate properties when you start the application with @EnableEurekaServer annotation it will look for bootstrap.yml file if not found it will look for application.yml file for the properties the yml file should look something like this.

server:
  port: 9090

eureka:
  client:
    register-with-eureka: false
    fetch-registry: false
    serviceUrl:
      defaultZone: http://localhost:9090/eureka/

The above properties yaml file defines the eureka defaultZone serviceUrl where eureka is supposed to run. register-with-eureka property is set to false as we don't want to register Eureka Server to itself.
Once everything is the project structure should look like the below image

Go ahead and start the spring boot application, the eureka server should be up in whatever port you mentioned in application.yml file in this case eureka server will be up at localhost:9090 and will look like below.

Ola, we have set up the eureka server.

Now we will go ahead and create two clients named client1 and client2 from the spring initializer like the above with adding one more dependency Eureka Discovery Client, as shown below

Once we have both the projects created we will go ahead and add the annotation @EnableDiscoveryClient on the root SprintBootApplication class as shown below for both the clients Client1 and Client2

package com.example.client2;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient
public class Client2Application {

    public static void main(String[] args) {
        SpringApplication.run(Client2Application.class, args);
    }

}

Similarly, we need to update the application.yml file as below providing the required eureka config details.

spring:
  application:
    name: 'client1'
server:
  port: 8081

eureka:
  instance:
    hostname: ${vcap.application.uris[0]:localhost}
    prefer-ip-address: true
    lease-renewal-interval-in-seconds: 10
    lease-expiration-duration-in-seconds: 20
  client:
    service-url:
      defaultZone: http://localhost:9090/eureka

In the above code, we have provided the spring application name and eureka client service URL where the eureka server resides, so once you start the client it will look into the service URL and tries to register itself. The property *lease-renewal-interval-in-seconds: 10 & lease-expiration-duration-in-seconds: 20* lets the Eureka Server when to check for the health of the client. Once you made these changes go ahead and start both the clients.

If you go back to Eureka Server you will now be able to see the two clients registered with names CLIENT1 and CLIENT2 as shown below.

Now the setup has been completed the two clients can talk to each with using the service discovery.

Here is the video tutorial. Please show some love and subscribe to my channel Subscribe.

Base Java Part 3 (Datatypes In Java)

Rajendra🙏🏼👇🏽 — Mon, 13 Jan 2020 12:55:05 +0000

Here is the video tutorial. Please show some love and subscribe to my channel Subscribe.

What is a Datatype?

A data type is an attribute of data that tells the compiler or interpreter how the programmer intends to use the data.

Data types in Java programming language

There are two different sets of data types in Java

Primitive Datatypes
Non Primitive Datatypes

The below image depicts different data types in java

The Java programming language is statically-typed, which means that all variables must first be declared before they can be used. This involves stating the variable's type and name.

boolean: is used to store true or false value.

byte, short, int, long: is used to store whole numbers.

float, double: is used to store fractional numbers.

The below table depicts different datatypes and the size of those datatypes.

The below class has all these datatypes defined and declared.

package com.test.java;

public class BasicDataTypes {

    static byte i = 127;
    static short j = 3456;
    static int k = 24233534;
    static long l = 34564;
    static float fl = 35325432;
    static double db = 34523763;
    static boolean b = true;
    static char c = 'c';

    static String testString = "Hello World";


    public static void main(String [] args) {
        char[] testCharString = new char[11];
        testCharString[0] = 'h';
        testCharString[1] = 'e';
        testCharString[2] = 'l';
        testCharString[3] = 'l';
        testCharString[4] = 'o';
        testCharString[5] = ' ';
        testCharString[6] = 'w';
        testCharString[7] = 'o';
        testCharString[8] = 'r';
        testCharString[9] = 'l';
        testCharString[10] = 'd';

        System.out.println("Default value of byte is ---> "+i);
        System.out.println("Default value of short is ---> "+j);
        System.out.println("Default value of int is ---> "+k);
        System.out.println("Default value of long is ---> "+l);
        System.out.println("Default value of float is ---> "+fl);
        System.out.println("Default value of double is ---> "+db);
        System.out.println("Default value of boolean is ---> "+b);
        System.out.println("Default value of char is ---> "+c);
        System.out.println("Default value of String is ---> "+testString);
        System.out.println("Default value of char is ---> "+String.valueOf(testCharString));


    }

}

Here is the video tutorial. Please show some love and subscribe to my channel Subscribe.

Base Java Part 2 (Class vs Object)

Rajendra🙏🏼👇🏽 — Mon, 06 Jan 2020 13:04:32 +0000

This is part of the Base Java series, in this part 2 we discuss

Difference between Class & Object.
How to create an object in Java.
Talk about constructor in Java.
Different ways to create an object in Java.

Here is the full video of the part 2 Base Java Series. Please show some love and subscribe to my channel Subscribe.

Class

A class is a template or a set of instructions to build a specific type of object, it determines how an object behaves and what the object contains.

Object

Objects represent real-life entities, Object determines the behavior of the class, the object has a state, behavior, and identity. Object implements the state and behavior in the form of variables and methods and requires some memory allocated.

Let's take the example, you want to build a car management system

You will define car class which will have a name, type, color, and functions like running, autopilot, stopping, etc.

The objects are tesla, accord, Lexus, etc.. as shown in the below image

Different ways to create an Object

We create an object in Java in multiple ways

"new" keyword.
"newInstance()" method.
using "Clone()" method.
using "ClassLoader".

The below Car Class and SampleJavaProject Class demonstrates these 4 ways to create Objects in Java.

Car.java

package com.test.java;

public class Car implements Cloneable{

    private String Name;

    private String Type;

    private String Color;

    public Car() {
        super();
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }


    public  Car(String name, String type, String color) {
        this.Name = name;
        this.Type = type;
        this.Color = color;
    }

    @Override
    public String toString() {
        return "Car [Name=" + Name + ", Type=" + Type + ", Color=" + Color + "]";
    }

    public String getName() {
        return Name;
    }

    public void setName(String name) {
        Name = name;
    }

    public String getType() {
        return Type;
    }

    public void setType(String type) {
        Type = type;
    }

    public String getColor() {
        return Color;
    }

    public void setColor(String color) {
        Color = color;
    }


}

SampleJavaProject.java

package com.test.java;

public class SampleJavaProject {

    public static void main(String [] args) {

        Car accord = new Car("Accord","2WD","Blue");
        Car tesla = new Car("Tesla","4WD","White");
        Car camry = new Car("Camry","2WD","red");
        try {
        Class clsClass = Class.forName("com.test.java.Car");
        Car tesla2 = (Car)clsClass.newInstance();
        tesla2.setColor("grey");
        tesla2.setName("model3");
        tesla2.setType("AWD");
        System.out.println("tesla2---->"+tesla2.toString());
        }catch(Exception e) {
            e.printStackTrace();
        }
        try {
        Car obj1 = new Car();
        Car obj2 = (Car) obj1.clone();
        obj2.setColor("purple");
        obj2.setName("cloenCar");
        obj2.setType("NWD");
        System.out.println("clone car----->"+obj2.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }

        Car classLoaderObjeCar = null;
        try {
            classLoaderObjeCar = (Car) new SampleJavaProject().getClass().getClassLoader().loadClass("com.test.java.Car").newInstance();
            classLoaderObjeCar.setColor("purple");
            classLoaderObjeCar.setName("classloader car");
            classLoaderObjeCar.setType("MWD");
            System.out.println("Class Loader car----->"+classLoaderObjeCar.toString());
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("Accord---->"+accord.toString());
        System.out.println("Tesla---->"+tesla.toString());
        System.out.println("Camry---->"+camry.toString());
    }
}

Here is the full video of the part 2 Base Java Series. Please show some love and subscribe to my channel Subscribe.

Beginner Git Essentials

Rajendra🙏🏼👇🏽 — Sun, 29 Dec 2019 21:05:11 +0000

This video is first published on YouTube
Please subscribe to my channel for tutorials
In this video, we will be looking into 20 git essential commands.

Base Java Part 1

Rajendra🙏🏼👇🏽 — Mon, 23 Dec 2019 13:54:15 +0000

This is a series covering Java basics, which hopefully help a beginner to get up and running.

In this part1 tutorial, we will cover

What is Java?
Differences between JDK, JRE, and JVM.
Features of Java.
First Java program.

Here is the full video of the part 1 Base Java Series. Please show some love and subscribe to my channel HERE.

Why Java?
Because Java is still among the most popular and most used programming languages because of its scalability and community. It is still the 3rd most language on Github and the 5th most popular language according to StackOverflow 2019 survey.

What is Java?
Java is a general-purpose programming language that is class-based, object-oriented, and designed to have as few implementation dependencies as possible. It is intended to let application developers write once, run anywhere (WORA), we will get deep into it later.

History of Java
Java was developed by sun microsystems, James Gosling is known as the father of Java, The first version of Java JDK (Java Development Kit) was first released in 1995, the latest version at the time of recording is Java SE 13 released September 2019.

Difference between JDK, JRE, JVM

JDK (Java Development Kit): JDK is the one you need to build applications in Java, it contains everything that is required to build and run Java applications. When you download java from the oracle site to develop applications you actually download JDK, which comes with JRE and the following Devtools,

JavaC: Java Compiler which compiles your Java code. 
Java: Interpreter/loader which reads your java code. 
JavaDoc: This helps in generating java documentation for your code.

JRE (Java Runtime Environment): JRE contains everything to run the java application, it contains code libraries required to develop java applications. JRE contains the Java class libraries, the Java class loader, and the Java Virtual Machine. In this system: The class loader is responsible for correctly loading classes and connecting them with the core Java class libraries. The JVM is responsible is to ensure Java applications have the resources they need to run and perform well in your device or cloud environment. The JRE is an orchestrator between these components.

JVM (Java Virtual Machine): JVM is machine-specific and can only read byte code that has been generated using java compiler. Once the java compiler compiles the code to byte code, JVM is the one which reads it and runs on that machine, you might have heard that Java is portable, this is what it meant the compiled byte code can be run on any machine with the help of JVM.

You might have seen the below image saying Java is being run on 3 billion devices, it actually means JVM is running on 3 billion devices.

Features of Java

There are many features that led Java to be one of the most popular languages for over 2 decades. These are the features of Java.

Object-Oriented

Everything in Java is Object Oriented. We organize our software as a combination of different types of objects that incorporates both data and behavior.

Simple

Java syntax is very simple and easy to learn. The syntax is based on C++ but removed unnecessary and complicated stuff.

Platform Independent

Java language is platform-independent, you write once and run anywhere (WORA). When you compile java file with Javac it generates .class file which can run on any machine by installing the JVM on that machine.

Secured

Java is best known for its security, you can build virus free software, it runs inside a virtual machine sandbox, unlike C++ runs on an OS, it doesn't have pointers like C++ which allows it write more secure code.

Multi-Threaded

Java multi-threaded features allow the application to run multiple processes concurrently. A process can be divided into multiple threads and can be run on all the threads simultaneously which makes the whole operation faster.

High Performance

Java is faster than traditional interpreted languages, as its byte code is closed to the native code. Java uses JIT (Just in Time) Compilers, which enables for high performance.

Dynamic

Supports dynamic loading of classes. Holds excessive amount of run time info, that can be used to access objects during runtime. You don't have to instantiate all the objects at the initialization, you can instantiate the objects when required at the runtime.

Here is the full video of the part 1 Base Java Series. Please show some love and SUBSCRIBE to my channel HERE.

In the next part, we will cover Java Variable, Java Datatypes, Operators and Keywords, etc...

Persist Data to Firebase With Rest API

Rajendra🙏🏼👇🏽 — Mon, 16 Dec 2019 17:59:21 +0000

In this tutorial will see how to connect to Firebase Firestore Database and persist data using rest web services.

For this will start from the rest web service that we built using spring boot in the previous blog post Build Restful web service using Spring boot and Java.

If you are a video guy here is the video which demonstrates connecting to Firebase and persists data

Go to firebase.google.com and click on the got to console on the top right corner, it will take you to the console as shown below. Click on Add project and give it a name.

Once created it will take you to your project console page as shown below, click on the database and create a collection named "users".

Once created the collection, we will go to project settings -> service Accounts tab to generate the key and save it in your project, that we will use to connect to the firebase firestore database. We will also grab the admin SDK configuration snippet for java.

Now open the pom.xml and add the google firebase admin SDK dependency

<dependency>
    <groupId>com.google.firebase</groupId>
    <artifactId>firebase-admin</artifactId>
    <version>6.11.0</version>
 </dependency>

Add a file named FirebaseInitialize which we will use to make a connection to firebase during the application startup. The class looks like this.

package com.example.demo.service;

import java.io.FileInputStream;

import javax.annotation.PostConstruct;

import org.springframework.stereotype.Service;
import com.google.auth.oauth2.GoogleCredentials;

import com.google.firebase.FirebaseApp;
import com.google.firebase.FirebaseOptions;

@Service
public class FirebaseInitialize {

    @PostConstruct
    public void initialize() {
        try {
        FileInputStream serviceAccount =
                  new FileInputStream("./serviceAccount.json");

                FirebaseOptions options = new FirebaseOptions.Builder()
                  .setCredentials(GoogleCredentials.fromStream(serviceAccount))
                  .setDatabaseUrl("https://fir-demo-8920f.firebaseio.com")
                  .build();

                FirebaseApp.initializeApp(options);
    } catch (Exception e) {
        e.printStackTrace();
    }

}
}

@Service Annotation lets the spring bootup know that it is a service class and needs to be bound.
@PostConstruct Annotation specifies that the function initialize() should run before the launch of the application, so it creates a firebase connection.
We have the code that we copied from the firebase console in the earlier step pasted here.
The first line reads the serviceAccount.json which we generated on the firebase project settings page from step 1.
It connects to firebase with FirebaseApp.initializeApp using the options build using FirebaseOptionsBuilder which will have credentials that we extracted from serviceAccount.json and the databaseURL.

We will now write a Firebase Service class which will have four functions to do crud operations, createUser (to create new User), updateUser (to update existing User), getUserDetails(to retrieve user details), deleteUser (to delete existing User) the class looks like below.

package com.example.demo.service;

import java.util.concurrent.ExecutionException;

import org.springframework.stereotype.Service;

import com.example.demo.objects.Person;
import com.google.api.core.ApiFuture;
import com.google.cloud.firestore.DocumentReference;
import com.google.cloud.firestore.DocumentSnapshot;
import com.google.cloud.firestore.Firestore;
import com.google.cloud.firestore.WriteResult;
import com.google.firebase.cloud.FirestoreClient;

@Service
public class FirebaseService {

    public String saveUserDetails(Person person) throws InterruptedException, ExecutionException {
        Firestore dbFirestore = FirestoreClient.getFirestore();
        ApiFuture<WriteResult> collectionsApiFuture = dbFirestore.collection("users").document(person.getName()).set(person);
        return collectionsApiFuture.get().getUpdateTime().toString();
    }

    public Person getUserDetails(String name) throws InterruptedException, ExecutionException {
        Firestore dbFirestore = FirestoreClient.getFirestore();
        DocumentReference documentReference = dbFirestore.collection("users").document(name);
        ApiFuture<DocumentSnapshot> future = documentReference.get();

        DocumentSnapshot document = future.get();

        Person person = null;

        if(document.exists()) {
            person = document.toObject(Person.class);
            return person;
        }else {
            return null;
        }
    }

    public String updateUserDetails(Person person) throws InterruptedException, ExecutionException {
        Firestore dbFirestore = FirestoreClient.getFirestore();
        ApiFuture<WriteResult> collectionsApiFuture = dbFirestore.collection("users").document(person.getName()).set(person);
        return collectionsApiFuture.get().getUpdateTime().toString();
    }

    public String deleteUser(String name) {
        Firestore dbFirestore = FirestoreClient.getFirestore();
        ApiFuture<WriteResult> writeResult = dbFirestore.collection("users").document(name).delete();
        return "Document with ID "+name+" has been deleted";
    }
}

We will have this class also defined with @Service annotation so it will be available for auto wiring.
Since having the connection to the database initialized earlier we will extract the DB here to perform operations on that.

Firestore dbFirestore = FirestoreClient.getFirestore();

this will instantiate the firestore client object which we will use to access the collections we created.

ApiFuture collectionsApiFuture = dbFirestore.collection("users").document(person.getName()).set(person)

this line of syntax gets the collection "users" and tries to document with id (In our case I'm setting the id as the user's name) if it didn't find the document with specified id it will create the new document with Person object.
If there is an id already exists it will update the document, if you observer the function updateUser it will have the same logic as createUser.
For deleteUser the syntax would be

dbFirestore.collection("users").document(person.getName())

If you have a problem following the tutorial, here is the video which demonstrates the complete tutorial.

Build A RESTful Web Service Using Spring Boot

Rajendra🙏🏼👇🏽 — Thu, 12 Dec 2019 06:07:08 +0000

The continuation of this tutorial is here connect to firebase and persist data

In this following tutorial, we will build a simple REST web service using java with spring boot.

Here is the complete video if you like to watch the video instead.

What is a Web Service?
Web Service is a standard or common way of communication between a client and a server.

The above diagram shows the pictorial representation of a web service call, the clients a computer, or a phone are basically clients, when you try to perform open facebook app your mobile phone app, it sends a web service request (Http Request) to get the data to show on your feed.

There are in general two kinds of web services in usage

SOAP (Simple Object Access Protocol).
REST (REpresentational State Transfer).

SOAP: SOAP as the name says it's an access protocol to make requests and receive responses based on a protocol that will be defined between the client and the server.
There are many caveats of using SOAP one of it is you can only transfer and receive XML data when using a SOAP web service. Hence restful web services came into existence.

REST: Rest as the name says its a state of transferring data between clients and servers, there are no set protocols attached to it, you can send any kind of data, XML, JSON, TEXT, FILE format data using REST web services, in most cases, you will be using JSON format.

SPRING BOOT makes it so much easier to build REST web services from the ground up, it provides a lot of configuration inbuilt so that you can build web services/ microservices rapidly, it also provides inbuilt tomcat server which removes the hassle of having a server install in and deploy your JAR/WAR file like the old times, we will see how to build the rest web service using Spring boot, Java and maven build tool.

Using the spring tool suite we can create a sample spring boot project. Go to File -> New -> Other Project and select Spring boot-> Spring boot Starter project it will create you a default spring boot project.

Follow the steps on STS/eclipse and you will have your demo application created and you should be able to see a java file named DemoApplication.java (Demo is the name of the project) which will look something like this.

package com.example.demo; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class DemoApplication { public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); } }

@SpringBootApplication annotation takes care of three annotations combined
@Configuration: Tags the class as a source of bean definitions for the application context.
@EnableAutoConfiguration: Tells Spring Boot to start adding beans based on classpath settings, other beans, and various property settings. For example, if spring-webmvc is on the classpath, this annotation flags the application as a web application.
@ComponentScan: Tells Spring to look for other components, configurations, and services in the base package in our case com.example.demo letting it find the controllers.

If you have never used Spring MVC you might have not known of these annotations. Spring boot starter project also creates a POM.XML like below which will have all the required dependencies except spring-boot-starter-web dependency which we need to add for creating Rest web service.

<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.2.2.RELEASE</version> <relativePath/>  </parent> <groupId>com.example</groupId> <artifactId>demo</artifactId> <version>0.0.1-SNAPSHOT</version> <name>demo</name> <description>Demo project for Spring Boot</description> <properties> <java.version>1.8</java.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> <exclusions> <exclusion> <groupId>org.junit.vintage</groupId> <artifactId>junit-vintage-engine</artifactId> </exclusion> </exclusions> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project>

Now we will go ahead and create a controller class that will have our REST endpoints, which will look something like below.

package com.example.demo.controller; import org.springframework.web.bind.annotation.DeleteMapping; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.PutMapping; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestHeader; import org.springframework.web.bind.annotation.RestController; import com.example.demo.object.Person; @RestController public class UserController { @GetMapping("/getUserDetails") public String getUserDetails(@RequestHeader String name) { return "Requesting Details of User"+name; } @PostMapping("/createUser") public String createNewUser(@RequestBody Person person) { return "Created new User "+person.getName(); } @PutMapping("/updateUser") public String updateUser(@RequestBody Person person) { return "Updated user "+person.getName(); } @DeleteMapping("/deleteUser") public String deleteUser(@RequestBody Person person) { return "Deleted User "+person.getName(); } }

HTTP Methods: There are four main HTTP methods that we use in common for web service calls they are

GET (used to retrieve existing data).
POST (used to create/insert new data).
PUT (used to update existing data).
DELETE (used to delete data).

We have implemented all these methods in the above UserController class.
@RestController lets the spring boot application that this class is a controller class having rest endpoints so that spring configures this class to its HTTP routes.
@GetMapping, having this annotation makes the corresponding method is called when a get call is made to the endpoint /getUserDetails.
Similarly @PostMapping, @PutMapping, @DeleteMapping calls the corresponding methods/functions when those methods are used.
@RequestHeader captures the data sent in the header parameters and @RequestBody captures the data sent in the body of the Rest Call.

That is all you need to bring up the service, set up the run configurations in STS or whichever IDE you might be using pointing to the DemoApplication.java class as the main class, it boots up the spring application using inbuilt tomcat and your services will be available on PORT 8080 by default.

You can follow through this video if you need any help in getting it up and running

The continuation of this tutorial is here connect to firebase and persist data

What it takes to make your first YOUTUBE video?

Rajendra🙏🏼👇🏽 — Mon, 09 Dec 2019 17:41:30 +0000

I have been procrastinating to make a youtube video for so long, it took me about 30 hours since I firmly decided to make a video.

The desire to make a tutorial video started long back when I was unable to understand many tutorials on youtube and other sites. The issue is not that the videos are good enough, the issue is the teaching style didn't work for me.

Finally, I decided to make a video about 2 months ago, I want my first video should be simple and useful to the #webdev community.

Step 1 (Deciding on a topic): Again procrastinating comes into play, I spent a lot of time thinking on the topic HTML? CSS? JAVASCRIPT? JAVA? finally, I ended up picking How to make VS CODE User Snippets.

Please CLICK HERE if you like to subscribe

Step 2 (Tools): As a beginner, we strive for perfection and quality, so I started trying a bunch of screen recording tools, microphones, audio mixers, etc.. and if I have to buy the best products in the market I would definitely go bankrupt. so I decided to use Camtasia 2 for screen recording and editing which I bought years ago on the app store with a gift card I got from apple,(Imovie and Quick time are free tools you can use if you have MAC). I wanted a decent microphone as audio plays a major role, so I bought the Blue Yeti USB microphone during thanksgiving deals.

Camtasia 2(Video/Screen Recording and Editing).
Blue Yeti Microphone (For good voice quality).
Canva (To create thumbnail and title animation).

Free Tool Alternative:

QUICK TIME & IMovie For MAC, CamStudio for windows.
Use the inbuilt MAC/PC microphone or your Earpiece microphone.
Canva (It's free for creating thumbnails or simple stuff, there is a paid plan as well)

Step 3 (Recording & Editing): Its recording time, it felt very weird hearing my voice recorded, I spent almost 2 hours for a 10 minute video re-recording what I recorded the first time, surprise it didn't get any better than the first time and I got really tired. Final step editing, since me being a newbie in editing it took me 2 hours to edit the video and get it down to some 8 minutes, I wanted the video to be crisp so I edited a lot of gaps and fillers.

Finally, I uploaded the video on youtube and got a huge number of views, just kidding I got 10 views all mostly from my friends whom I asked to watch.

The bottom line is just don't wait to be perfect in anything, just started doing even though it sucks like my VIDEO on youtube. I will try to make more tutorials and fun videos on my channel HackerHeap. Please CLICK HERE if you like to subscribe.

Hi, I'm NagaRajendra.Chamata

Rajendra🙏🏼👇🏽 — Thu, 01 Jun 2017 16:54:28 +0000

I have been coding for 6 years.

You can find me on GitHub as rajendrach

I live in Chicago Metro Area.

I work for Capital One

I mostly program in these languages: Java, Java Script(NodeJS, AngularJS, ReactJS), Python(Novice).

I am currently learning more about Machine Learning/Deep Learning/AI.

Nice to meet you.