DEV Community: Suvasish Das

Spring Auto-wiring and interact with other POJOs

Suvasish Das — Wed, 12 Jan 2022 08:40:56 +0000

In this tutorial, I'm going to cover how to interact with internal POJOs (Plain Old Java Objects) in spring application. Also I'm going to cover why spring need auto-wiring between two POJOs.

How it works

Sometime the POJO instances or beans need to refer another POJO instance to complete application's functionality (i.e. a POJO instance is dependent on another POJO instance). To access a POJO inside another POJO, we need to specify the bean reference inside the configuration file. Often, this dependency need to handle manually by programmers. But, in large commercial application, we need a more reliable way to resolve this inner dependency. That's where spring auto-wiring comes in place.

By auto-wiring, spring container establish a relationship between two POJO instances. By enebeling auto-wiring, we let spring to resolve collabration between beans automatically. Thus autowiring can be especially useful during development, without negating the option of switching to explicit wiring when the code base becomes more stable.

The autowiring functionality has four modes. They are-

Mode	Explanation
`no`	(Default) No auto-wiring. Bean references must be defined by ref elements. Changing the default setting is not recommended for larger deployments, because specifying collaborators explicitly gives greater control and clarity. To some extent, it documents the structure of a system.
`byName`	Auto-wiring by property name. Spring looks for a bean with the same name as the property that needs to be auto-wired. For example, if a bean definition is set to auto-wire by name and it contains a master property (that is, it has a setMaster(..) method), Spring looks for a bean definition named master and uses it to set the property.
`byType`	Lets a property be auto-wired if exactly one bean of the property type exists in the container. If more than one exists, a fatal exception is thrown, which indicates that you may not use byType auto-wiring for that bean. If there are no matching beans, nothing happens (the property is not set).
`constructor`	Analogous to byType but applies to constructor arguments. If there is not exactly one bean of the constructor argument type in the container, a fatal error is raised.

Program structure

Github repository link: click here

Program logic

Let's create a java class named Laptop having four local variable, name, price, motherboard, processor. motherboard is an object of Motherboard class and processor is an object of Processor class.

So, we can clearly see that, Laptop class has inner dependency on Motherboard and Processor class. In normal programming approach, we need to declare each of dependent object with new operator. But, whenever we use new to declare object, we are hardcoding the value (the program will have tight coupling). So, we are going to resolve this problem by declaring POJO instances. Now, we don't need to hardcoding values inside our program logic.

// Filename: Laptop.java
package com.example.SpringAutowire;

public class Laptop {
    private String name;
    private int price;
    private Motherboard motherboard;
    private Processor processor;

    // constructors
    public Laptop() {}
    public String getName() {
        return name;
    }

        // getters and setters
    public void setName(String name) {
        this.name = name;
    }
    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }
    public Motherboard getMotherboard() {
        return motherboard;
    }
    public void setMotherboard(Motherboard motherboard) {
        this.motherboard = motherboard;
    }
    public Processor getProcessor() {
        return processor;
    }
    public void setProcessor(Processor processor) {
        this.processor = processor;
    }
    public void getLaptopDetails() {
        System.out.println("Laptop Name: "+name);
        System.out.println("Laptop price: "+price);
        System.out.println("Motherboard: "+motherboard.getName());
        System.out.println("Processor: "+processor.getName());
    }
}

// Filename: Motherboard.java
package com.example.SpringAutowire;
public class Motherboard {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

// Filename: Processor.java
package com.example.SpringAutowire;
public class Processor {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

Now, It's time to define POJO instances for the above java classes. To do this, I'm going to create a .xml file named Beans.xml inside my application root class-path.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd"></beans>

Now, inside those <beans> </beans> tag, we are going to define our individual POJO instances, with some values.

    <bean id="laptop" class="com.example.SpringAutowire.Laptop">
        <property name="name" value="dell vostro 1450s"/>
        <property name="price" value="45000"/>
        <property name="motherboard" ref="motherboard"/>
        <property name="processor" ref="processor"/>
    </bean>
    <bean id="processor" class="com.example.SpringAutowire.Processor">
        <property name="name" value="intel i3 11g"/>
    </bean>
    <bean id="motherboard" class="com.example.SpringAutowire.Motherboard">
        <property name="name" value="gigabyte h81ms v2"/>
    </bean>

Note that inside laptop bean, the value of motherboard and processor is referencing (ref attribute inside property tag refer to another POJO. It's not mandatory to place the POJO instances inside same xml file) to another POJO instances, which are declared after laptop POJO. By doing this, we have resolve internal POJO dependency. Now, if you run your application (with driving code), it will work successfully.

Autowiring POJOs

So far we resolve internal POJO dependency. But, still we writing POJO dependency by ourself manually. By using autowire attribute inside a <bean> tag, we let spring to automatically fetch the internal beans.

    <bean id="laptop" class="com.example.SpringAutowire.Laptop" autowire="byName">
        <property name="name" value="dell vostro 1450s"/>
        <property name="price" value="45000"/>
    </bean>

Note that, now laptop no longer has processor and motherboard value defined. By define autowire="byName", srping will search for the required beans by its name, and whenever match found, spring will automatically refer the bean at compile time.

Driving code

Now, we are ready to write our final pice of code or the driving code. Now create a java class containing the main method(if you create your project using maven or groovy project template, you are provided a java class containing main mathod, just use those file).

Inside those class declare a ApplicationContext variable and
define with ClassPathXmlApplicationContext() with parameter the string representation of your configuration xml file name with fully specified path (in my case, my xml file is placed at the root location, so I no need to enter the fully specified path name). Make sure that this variable is declared as static, so that we can access it from main method.

The ApplicationContext interface is responsible to create the spring IOC container(if you are not familiar with IOC, click here and go through the documentation). ClassPathXmlApplicationContext class is a subclass which implemented ApplicationContext interface. There are many other subclass available to create IOC container.

Now, inside the main method of our code, create a variable of type Laptop and instantiated it with a defined bean. In this case context.getBean("laptop", Laptop.class) return a variable of type Laptop. The first argument of getBean refers to the bean name as string and the second argument refers to the actual class. By default getBean() method's return type is java.lang.Object. The second argument in the getBean() method actually used to typecast the value. So we no need to typecast it manually. In the below code, I'm typecasting the value to Laptop.class type.

package com.example.SpringAutowire;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    private static ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
    public static void main( String[] args ){
       Laptop laptop = context.getBean("laptop", Laptop.class);
       laptop.getLaptopDetails();
    }
}

Output

Create simple HelloWorld spring application

Suvasish Das — Sat, 08 Jan 2022 15:02:59 +0000

In this tutorial I'm going to cover step by step, how to create simple annotation based "HelloWorld" spring application. To create spring application, first of all you need to configure or create a spring project in your IDE (for this tutorial I'm going to use Eclipse IDE). If you having some trable with project creation, I strongly recommend to click here and get start with your spring journey.

Project Structure

Step1

Let's create a simple POJO class named HelloWorld, inside your project classpath (in my case com.example.SpringAnnotation is my project classpath). HelloWorld.java POJO class containing one string variable named greeting and one setGreeting(String greeting) and getGreeting() function. Those function are called getter and setter methods.

setGreeting(String greeting) function simply set the local variable named greeting and getGreeting() function simply fetch the data of the local variable greeting.

Another public function sayHello() simply print the message in the console using println() method.

package com.example.SpringAnnotation;

public class HelloWorld {
    private String greeting;

    public String getGreeting() {
        return greeting;
    }

    public void setGreeting(String greeting) {
        this.greeting = greeting;
    }
    public void sayHello() {
        System.out.println("Message is: "+greeting);
    }
}

Step2

After creating your POJO class, now it's time to define a configuration class. Let's create a HelloWorldConfig class.
Annotate the class with @Configuration annotaion. By defining the class with @Configuration we telling spring that this class is going to contain bean definations.

Now inside the class we are going to create bean defination. Every bean definations must annotated with @Bean annotation. One configaretion class can have multiple bean definations. In this case I'm going to create one bean named helloWorld() (started with small 'h').

package com.example.SpringAnnotation;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class HelloWorldConfig {
    // Bean name = helloWorld
    @Bean
    public HelloWorld helloWorld() {
        HelloWorld hello = new HelloWorld();
        hello.setGreeting("Hello Spring");
        return hello;
    }
}

Step3

Now, bean defination is complete. Now create a xml file in your application classpath. I'm going to create Config.xml in my root class path so that no need to specify the xml files with fully specified path name. Now copy the following code and paste in your xml file. This step is important beacause it define the beans prototype.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-3.2.xsd"></beans>

Now add the following tag inside <beans></beans> tag.

<context:component-scan base-package="com.example.SpringAnnotation"/>

context:component-scan tag allow your code to scan for a specific bean. The base-package="<your_component_classpath>" locate for your defined components class path, so that it can scan for the secified beans in those location.

Step4

Now, inside the main method of our code, create a variable of type HelloWorld and instantiated it with a defined bean. In this case context.getBean("helloWorld", HelloWorld.class) return a variable of type HelloWorld. The first argument of getBean refers to the bean name as string and the second argument refers to the actual class. By default getBean() method's return type is java.lang.Object. The second argument in the getBean() method actually used to typecast the value. So we no need to typecast it manually. In the below code, I'm typecasting the value to HelloWorld.class type.

Now, we are all set. Simply call the sayHello() method and your code works successfully.

package com.example.SpringAnnotation;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    private static ApplicationContext context =  new ClassPathXmlApplicationContext("Config.xml");
    public static void main( String[] args ){
        HelloWorld helloWorld = context.getBean("helloWorld", HelloWorld.class);
        helloWorld.sayHello();
    }
}

Output

Plox!!! our code runs successfully. Here is the output-

Floyd’s Cycle Detection Algorithm

Suvasish Das — Sun, 24 Oct 2021 13:28:15 +0000

The purpose is to determine whether the linked list has a cycle or not. This is the fastest method to find cycle in a linked list. The terminology of this algorithm is-

Traverse linked list using two pointers named slow_ptr and fast_ptr.
Move the pointer slow_ptr by 1 and fast_ptr by 2.
If these pointers meet at the same node then there is a loop. If pointers do not meet then linked list doesn’t have a loop.

Algorithm

INPUT: Pointer to a linked list say HEAD.

OUTPUT: Return true if linked list contains loop else return false.

DATA STRUCTURE: A singly linked list.

STEPS:

    If(HEAD == NULL || HEAD->link == NULL) then
        Return false
        Exit
    Else
        // initializing staring pointers
        fast_ptr = HEAD
        slow_ptr = HEAD
        While(HEAD != NULL) do
            // move slow_ptr by 1 step and fast_ptr by 2 steps
            slow_ptr = slow_ptr->link;
            fast_ptr = fast_ptr->link->link;
            If(slow_ptr == fast_ptr)then
                Return true
            EndIf
            HEAD = HEAD->link
        EndWhile
        Return false
    EndIf

Complexity

Time complexity: O(n). Only one traversal of the loop is needed.

Auxiliary Space: O(1). There is no space required.

References

codingninjas.com, geeksforgeeks.org

Conclusion

Hope you understand this algorithm. Let's solve some problem using this algorithm. click here

Stringstream in c++

Suvasish Das — Thu, 19 Aug 2021 19:17:07 +0000

A stream in c++ is a flow of data into or out to the program. For example, we can say that std::cin is an input stream whose job is to input some data, and std::cout is an output stream whose job is to output or display data. Stringstream in c++ is a class that allows a string object to be treated like a stream. It can be included using #include<sstream> command.

The following diagram shows that stringstream class is derived from iostream class.

Insertion operation

Insertion operation is used to insert value into a stringstream object.

#include<iostream>
#include<sstream>

using namespace std;
int main(){
     stringstream ss;
     ss >> "Hello world!";
return 0;
}

The example shows how string object can inserted in a stringstream variable ss using >> operator. The >> operator return true if succeed, false otherwise.

There are another method to insert value into a stringstream object. Using str method we can take the data string as argument and assigned the data string to the stringstream variable.

#include<iostream>
#include<sstream>

using namespace std;
int main(){
     stringstream ss;
     ss.str("Hello world!");
return 0;
}

This program does the same job as the above program.

Extraction operation

Extraction operation is used to get data from a stringstream object.

#include<iostream>
#include<sstream>

using namespace std;
int main(){
     stringstream ss.str("Hello world!");
     string str;
     ss >> str;   // str variable get the value of ss
     cout << str;     // this line output 'Hello world!'
return 0;
}

Here in this example, extraction operator >> is use to extract the data from a stringstream object. We use a string obj str to store the value.

#include<iostream>
#include<sstream>

using namespace std;
int main(){
     stringstream ss.str("Hello world!");
     cout << ss.str();    // this line output 'Hello world!'
return 0;
}

Here in this example, str() function is used to get the value stored in stringstream.

Practical use

Using stringstream is useful to get integer type data from a given string. Suppose, we have a string my_string which contains "10,20,30" string. So, how can we extract the integers from the given string. Impossible right?
stringstream can be useful solve this type of problems.

#include<iostream>
#include<sstream>

using namespace std;
int main(){
     string my_string = "10,20,30";     // given string
     stringstream ss.str(my_string);     // passing the my_string object to the str method
     int a,b,c;
     char ch;
     ss >> a >> ch >> b >> ch >> c ;     // now the value of a = 10, b = 20, c = 30, and ch = ','
     // ch variable is used for get the inner commas
     cout "a:"<< a << ", b:" << b << ", c:" << c << endl;
     return 0;
}

The above code out put the following result-

     a:10, b:20, c:30

What next?

Hope you understand the basic concept of using stringstream.
Let's solve some problems. click here