Forem: Aditya Karad

Six ways of dependency injection in Spring Boot — A Deep Dive

Aditya Karad — Sun, 12 Feb 2023 04:21:56 +0000

Introduction

Dependency injection in Spring can be done through

Constructor injection
Setters injection
Field injection

Now, each approach can be executed in two ways — you can:

use Java annotations like @Autowired and let Spring scan for components in your codebase
define each bean in your spring config XML file.

Pre-requisites

Since the idea of this post is to learn about different methods of injections, our project setup is simple.

Laptop.java class represents a Laptop. Now a Laptop has different attributes like Display, HardDisk, Battery. For now, let’s only consider HardDisk.java.

public class Laptop {
    private HardDisk hardDisk;

    public Laptop(HardDisk hardDisk){
        this.hardDisk = hardDisk;
    }
    public void saveData(){
        hardDisk.saveData();
    }
}

HardDisk.java is an interface which is implemented by two HardDisk implementations: SanDiskHD and HitachiHD.

public interface HardDisk {
    public void saveData();
}

public class HitachiHD implements HardDisk {
    public void saveData(){
        System.out.println("HitachiHD: saveData");
    }
}

public class SanDiskHD implements HardDisk {
    public void saveData(){
        System.out.println("SanDiskHD: saveData");
    }
}

The point of having dependency injection is to follow the loose coupling principle in our code design.

Now we will go over the ways in which different implementations of HardDisk (i.e. SanDiskHD and HitachiHD) can be injected into Laptop.

Injection using Annotations

In my experience, this approach is widely used for large projects. This is also the one I use the most.

Spring will scan your Java code for annotations and automatically register beans in the spring container.

For enabling injection through annotations, you should:

Enable component scanning in your project in your spring config file.

<?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.xsd>
    <http://www.springframework.org/schema/context>
    <http://www.springframework.org/schema/context/spring-context.xsd>">

<!--    Enable component scan-->
    <context:component-scan base-package="com.learningspring.demo.src" />
</beans>

Mark classes with @Component annotation. Optionally, you can also provide a bean id.

@Component("hardDisk")
public class HitachiHD implements HardDisk {
    public void saveData(){
        System.out.println("HitachiHD: saveData");
    }
}

Fetch the bean using bean id.

public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        HardDisk hd = ctx.getBean("hardDisk", HardDisk.class);
        hd.saveData();
        SpringApplication.run(DemoApplication.class, args);
}

Run, and see the results.

20:13:24.494 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'hardDisk'
HitachiHD: saveData

💡 Now, spring also assigns a default bean id for a bean if you don’t give one. The pattern is a camel-case version of the class name.

So a bean of type HitachiHD would have a bean id of hitachiHD.

Injection using Annotations and Autowiring

What is Autowiring?

Spring can automatically find beans by matching the type (class or interface) and inject it automatically.

So, if you want to inject a HardDisk implementation into Laptop, you can annotate the HardDisk attribute of Laptop class with @Autowired.

This will tell spring to scan all the components in your code, find a bean which matches the class of type HardDisk, and inject it into the Laptop.

For eg: If you annotate HitachiHD with @Component, it will inject HitachiHD into Laptop.

Now, there are three ways of autowiring beans:

Field injection
Constructor injection
Setter injection

Field Injection

Annotate the implementation of HardDisk you want to inject into Laptop with @Component.

@Component
public class HitachiHD implements HardDisk {
    public void saveData(){
        System.out.println("HitachiHD: saveData");
    }
}

Inject the HardDisk bean into Laptop by annotating the HardDisk attribute with @Autowired.

@Component
public class Laptop {
    @Autowired
    private HardDisk hardDisk;

    public void saveData(){
        hardDisk.saveData();
    }
}

To test this autowiring, let’s get the Laptop bean and invoke it’s saveData() to see the results

public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        Laptop l = ctx.getBean("laptop", Laptop.class);
        l.saveData();
        SpringApplication.run(DemoApplication.class, args);
    }

21:23:50.350 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'hitachiHD'
21:23:50.351 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'laptop'
HitachiHD: saveData

Drawbacks:

Costlier than constructor-based or setter-based injection.
Incentivises to have many dependencies injected into a class, which cause design issues.

Constructor Injection

There are two patterns:

Annotating entire constructor with @Autowired.

@Component
public class Laptop {
    private HardDisk hardDisk;

    @Autowired
    public Laptop(HardDisk hardDisk) {
        this.hardDisk = hardDisk;
    }

    public void saveData(){
        hardDisk.saveData();
    }
}

Annotating only the specific attribute with with @Autowired in the constructor.

@Component
public class Laptop {
    private HardDisk hardDisk;

    public Laptop(@Autowired HardDisk hardDisk) {
        this.hardDisk = hardDisk;
    }

    public void saveData(){
        hardDisk.saveData();
    }
}

Setter Injection

Here you annotate the setter method of the relevant attribute with @Autowired.

@Component
public class Laptop {
    private HardDisk hardDisk;

    @Autowired
    public void setHardDisk(HardDisk hardDisk) {
        this.hardDisk = hardDisk;
    }

    public void saveData(){
        hardDisk.saveData();
    }
}

What kind of dependency injection should you use?

A good answer might be — to follow the pattern already followed in the codebase you’re working on.

What if there are multiple implementations annotated with `@Component`?

Because autowiring by type may lead to multiple candidates, it is often necessary to have more control over the selection process. One way to accomplish this is with Spring’s @Primary annotation.

@Primary indicates that a particular bean should be given preference when multiple beans are candidates to be autowired to a single-valued dependency. If exactly one primary bean exists among the candidates, it becomes the autowired value.

If you want to always autowire HitachiHD implementation as a HardDisk, you can annotate it with @Primary:

@Primary
@Component
public class HitachiHD implements HardDisk {
    public void saveData(){
        System.out.println("HitachiHD: saveData");
    }
}

Dependency Injection with XML configuration

Another way to configure Spring runtime with constructor-based dependency injection is to use an XML configuration file.

In this case, we need to bootstrap our Spring application context using ClassPathXmlApplicationContext.

This approach is not used commonly, and you’ll see it rarely in professional codebases. This is because for large projects, defining each bean in XML configuration file is not practical.

Constructor Injection

For injecting a bean into a class,

First, you need to accept the HardDisk bean in the constructor definition:

public class Laptop {
    private HardDisk hardDisk;

    public Laptop(HardDisk hardDisk){
        this.hardDisk = hardDisk;
    }
    public void saveData(){
        hardDisk.saveData();
    }
}

You have to define the beans you want to inject into Laptop object using constructor-arg in applicationContext.xml file. applicationContext.xml is a spring config file from which we can the set different properties for our Spring container.

<?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.xsd>
    <http://www.springframework.org/schema/context>
    <http://www.springframework.org/schema/context/spring-context.xsd>">

    <context:annotation-config/>
    <!--Defining beans here-->

    <bean id="hardDisk" class="com.learningspring.demo.src.harddisk.HitachiHD"/>
    <bean id="laptop" class="com.learningspring.demo.src.laptop.Laptop" >
        <constructor-arg ref="hardDisk"/>
    </bean>
</beans>

Let’s test this thing out by fetching the Laptop bean and invoking it’s saveData() method.

public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        Laptop l = ctx.getBean("laptop", Laptop.class);
        l.saveData();
        SpringApplication.run(DemoApplication.class, args);
    }

00:22:04.154 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'hardDisk'
00:22:04.158 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'laptop'
HitachiHD: saveData

So basically, we injected HitachiHD bean into our laptop object through its constructor.

This is called constructor injection.

Setters Injection

Create a setter method in Laptop class for injections.

public class Laptop {
    private HardDisk hardDisk;

    public void setHardDisk(HardDisk hardDisk) {
        this.hardDisk = hardDisk;
    }

    public void saveData(){
        hardDisk.saveData();
    }
}

Configure dependency injection in applicationContext.xml.

<?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.xsd>
    <http://www.springframework.org/schema/context>
    <http://www.springframework.org/schema/context/spring-context.xsd>">

    <context:annotation-config/>
    <!--Defining beans here-->

    <bean id="hd" class="com.learningspring.demo.src.harddisk.HitachiHD"/>
    <bean id="laptop" class="com.learningspring.demo.src.laptop.Laptop" >
        <property name="hardDisk" ref="hd"/>
    </bean>
</beans>

Let’s run our application.

00:37:43.878 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'hd'
00:37:43.882 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'laptop'
HitachiHD: saveData

So basically, we injected HitachiHD bean into our laptop object through its setter method.

This is called setter injection.

Injecting Literal Values through setters

Let’s say we want to inject some hard-coded value into our object. How do we do that?

Well, we can leverage the setter methods for the literal value we want to inject and pass it in applicationContext.xml file.

<bean id="hd" class="com.learningspring.demo.src.harddisk.HitachiHD"/>
<bean id="laptop" class="com.learningspring.demo.src.laptop.Laptop" >
    <property name="hardDisk" ref="hd"/>
    <property name="brandName" value="Apple"/>
</bean>

public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        Laptop l = ctx.getBean("laptop", Laptop.class);
        l.saveData();
        System.out.println(l.getBrandName());
        SpringApplication.run(DemoApplication.class, args);
    }

00:48:23.773 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'hd'
00:48:23.777 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'laptop'
HitachiHD: saveData
Apple

Injecting values from properties file

Create a properties file
Load properties file in the spring config file

brandName = Apple

Reference values from properties file in Java code. We can access it through ${variable_name}.

<?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.xsd>
    <http://www.springframework.org/schema/context>
    <http://www.springframework.org/schema/context/spring-context.xsd>">

    <context:annotation-config/>
    <context:property-placeholder location="classpath:application.properties"/>
    <!--Defining beans here-->

    <bean id="hd" class="com.learningspring.demo.src.harddisk.HitachiHD"/>
    <bean id="laptop" class="com.learningspring.demo.src.laptop.Laptop" >
        <property name="hardDisk" ref="hd"/>
        <property name="brandName" value="${brandName}"/>
    </bean>
</beans>

That's it, folks

If you like these posts, do subscribe to the newsletter. You'll be the first to know when a new blog post is released on Coding Chronicles.

ER Model Explained — DBMS Concepts | Coding Chronicles

Aditya Karad — Sun, 12 Feb 2023 04:07:29 +0000

What is an Entity-Relationship Model (ER Model)

An ER Model is a conceptual view of your database. It’s kind of a block diagram to logically visualise your database.

An ER model is used to represent the database structure or architecture of a system.

ER model consists of various components:

Entity
Attributes
Relationships

Entity

Entity is an object with a physical or conceptual existence.

It’s something that’s relevant to our database. For example, if we’re designing a school database, a student or a teacher (physical existence) is an entity.

A course taught at the school can also be an entity (conceptual existence)

Entity is represented by a rectangle in a ER model diagram

Attribute

Attribute is a property of an entity.

For example, a student (an entity) has various attributes like height, weight, blood group, class, and more.

Attribute is represented by an eclipse or oval in a ER model diagram.

Types of Attributes

There are many different types of attributes, so the most commonly used terms are below:

Key Attribute

A key attribute is used to uniquely identify one entity instance from another.

It represents a primary key of that entity.

It’s represented by an oval with the text underlined.

For an entity like Student, Student ID can be key attribute which can uniquely identify a student.

Composite Attribute

An attribute that is composed of multiple attributes is called a composite attribute.

Here’s how a composite attribute is represented:

Multivalued Attribute

An attribute which has more than one value is called a multivalued attribute.

It’s represented by a double oval in the ER diagram.

Derived Attribute

An attribute which can be derived from another is called a derived attribute.

It’s represented by an oval with dashed lines in the ER diagram.

Relationship

A relationship describes the relation between two entities.

It’s represented by a diamond or rhombus in the ER diagram.

Oh, and in case you haven’t noticed already, straight lines are used to link attributes to entities and an entity to its relationship.

Relationship Table

A relationship table contains the mapping between two entities of a relationship.

It also gives us more information of the type of relationship between two entities.

employee_id	project_id
1	2
2	3
3	1

Here,employee_id is a foreign key referencing the primary key of employee table

AND

project_id is a foreign key referencing the primary key of project table.

Types of Relationships

The number of times an entity of an entity set participates in a relationship set is known as cardinality.

On the basis of cardinality, relationships can be of different types:

One-to-One (1-1)
One-to-Many (1-M)
Many-to-One (M-1)
Many-to-Many (M-N)

One-to-One relationship

When each entity in an entity set can take part only once in the relationship, the relationship is said to be one-to-one type of relationship.

Assuming an ideal world where a person is married to only one person, we can say that a male is married to only one female. Similarly, a female is also married to only one male.

This is an example of a one-to-one relationship.

The relationship table in a one-to-one relationship looks like:

male_id	female_id
1	2
2	3
3	1

Here, since any male_id as well as female_id are unique, we can use either as a primary key for relationship table.

<aside> 💡 To save space, we can also merge male and relationship tables, since the primary key for both is male_id. We can simply add a column to employee table named female_id.

Similarly, we can also merge female and relationship table.

</aside>

One-to-Many relationship

When one entity in an entity set can take part only once in the relationship and the other can take part more than once, the relationship is said to be one-to-many type of relationship.

Consider an e-commerce store like Amazon. An Amazon customer can place multiple orders, but an order can only belong to one customer.

This is an example of a one-to-many relationship.

The relationship table in a one-to-many relationship looks like:

customer_id	order_id
1	1
1	2
2	3
1	4

Here, since any order_id is unique, we can use order_id as a primary key for relationship table.

Since there can be duplicate customer_id in this table, we cannot merge it with customers table.

We can merge this table with orders table.

Many-to-One relationship

The definition for Many-to-One relationship is the same as One-to-Many relationship.

Consider the example of privately-owned cars. An individual can own multiple cars, but a car has only one owner.

This is an example of a many-to-one relationship.

Opposite of a one-to-many type of relationship, we can use individual_id as a primary key for the relationship table.

Similarly, we can merge the relationship table with the individuals table, but not cars table.

Many-to-Many relationship

When each entity in an entity set can take part more than once in the relationship, the relationship is said to be Many-to-Many type of relationship.

In a corporate environment, an employee can be assigned to multiple projects, and a project can also be assigned to multiple employees.

This is an example of a many-to-many relationship.

The relationship table in a many-to-many relationship looks like:

employee_id	project_id
1	1
1	2
2	1
1	4

Here, employee_id as well as project_id can repeat in the table.

But a combination of employee_id and project_id is unique in this table. We can use employee_id + project_id as a primary key for this table.

We cannot reduce this table by merging it with either of the individual tables.

That's it, folks!

Learning about database management systems (DBMS) is crucial for developers as it improves data management skills, enhances problem-solving abilities, and helps with database design.

If you're looking to deepen your knowledge or learn Database Management Systems from scratch, following the Coding Chronicles DBMS series is the perfect way to do it.

Coding Chronicles Newsletter

If you like these posts, do subscribe to the newsletter. You'll be the first to know when a new blog post is released on Coding Chronicles.

Setting up CI/CD Pipeline for a React app using Travis CI

Aditya Karad — Sun, 22 Jan 2023 10:24:01 +0000

Introduction

In this tutorial, we will set up a CI/CD pipeline for a simple React application with the help of Travis-CI. Travis-CI works best with Github, so we will use GitHub in this tutorial.

Pre-requisites

Create a GitHub account.
Create a Travis-CI account and link it to your GitHub account.
Youll need to have Node >= 14.0.0 and npm >= 5.6 on your machine.

Initialize a React app

Lets create a simple react app. We will use create-react-app, which provides a nice environment for building a single-page application in React.

npx create-react-app travis-ci-react

We can start our application through npm start command in the terminal.

Adding `.travis.yml` file

Add a .travis.yml file to the react project at the root level.

What does `.travis.yml` file do?

.travis.yml will help us configure our applications CI-CD pipeline.

Travis only runs builds on the commits you push after youve added a .travis.yml file.

Now lets set some properties in travis.yml file.

Parameters to provide:

language: Provide the programming language for your project. For our case, its node_js.
version: Provide the version of the programming language for your application. I have observed that if you dont provide a version, it automatically picks up v2. This can cause your build to fail since many dependencies require a minimum Node version of 8.
cache: npm This will cache your NPM dependencies for the next run. Note that npm install will still run on every build and will update/install any new packages added to your package.json file

After this step .travis.yml file becomes:

language: node_js
node_js:
  - 16
cache: npm

Hooks provided by Travis CI

Travis provides us with hooks that are run at specific points in time during the build. These hooks are (in chronological order):

before_install
install
before_script
script
after_success
after_failure
after_script
before_deploy
deploy
after_deploy

This provides a lot of flexibility for custom requirements! Lets say you want to notify your developer about a failed Travis build. You can utilize the after_failure hook to do so.

`script` and `install` hooks

Since we know we want to install NPM dependencies for our React project before we test or build it, we should add npm install as an install script.

Since we also want to test our changes, we should add a npm test as a script.

After testing we can build our react app through npm run build script.

Adding these three changes, our travis.yml file becomes:

language: node_js
node_js:
  - 16
cache: npm
install:
    - npm install
script:
  - npm test
  - npm run build

Using GitHub Pages in `deploy` hook

Lets leverage the deploy hook to deploy our react app to GitHub Pages.

But before that, make sure you have set up and enabled Github pages: Follow this guide!

You also need to create a personal access token from GitHub with the repo scope. We will require this token for authorizing Github Pages deployments from Travis. Copy this token and add it as an environment variable in Travis CI named GITHUB_TOKEN.

Now our resulting .travis.yml file is:

language: node_js
node_js:
  - 16
cache: npm
install:
    - npm install
script:
  - npm test
  - npm run build

deploy:
 provider: pages
 skip_cleanup: true
 github_token: $GITHUB_TOKEN
 local_dir: build
 on:
   branch: master

Setting homepage in `package.json` file

You also need to make a small tweak in package.json file before pushing your code. Make sure you override homepage property in package.json file and set it to the URL where your project is going to be hosted.

If youre deploying to GitHub Pages, then the URL will be https://<YOUR_GITHUB_USERNAME.github.io/<REPO_NAME>

If youre curious as to why we do this, check this out.

Committing changes to Github and triggering a Travis CI build

Lets commit these changes and push them to a GitHub repository.

Travis CI Build Results

If your TravisCI account is linked to your GitHub account, a build automatically gets triggered when you push a .travis.yml file. You can view this in Actions tab.

You can also view the results of any single build by clicking it:

Similarly, you can also head to your TravisCI dashboard and see the build results.

Conclusion

If your build is successful, you can head over to your GitHub Pages URL and see the project deployed!

For example: here is mine: https://itskarad.github.io/travis-ci-react/

Source code of the project

🔗 Source code on GitHub

🔗 Github Page

Some more things

Default commands used by Travis CI

Travis already provides some default scripts:

Travis has a default install script for Nodejs projects as npm install
Travis has a default build script for Nodejs projects as: npm test

Hence we need not add the install: npm install since its automatically run by Travis for NodeJS projects.

Similarly, we need not add the script: npm test as well.

language: node_js
node_js:
  - 16
cache: npm
script:
  - npm run build

Using Notion as a CMS for a blog for free

Aditya Karad — Sat, 21 Jan 2023 03:24:33 +0000

Why to use Notion as your CMS?

Notion is a great tool for writing. It supports markdown, images, layouts, videos, embeds, bookmarks, tables and databases. It’s like the modern day Microsoft Word.

I recently started my blog, and coded it myself. But I soon realised that my CMS lacked many features that Notion had. So I decided to use Notion as my CMS.

Solution

I searched online for solutions and found the following Github repository. It allows direct deployment of a Website to any cloud providers like Heroku, Vercel, Netlify and many others.

https://github.com/craigary/nobelium

Using this repository, I was able to create a blog and deploy it to Vercel.

You don’t need any NextJS experience to do it yourself (because I myself don’t know NextJS!). Just follow the README file steps and you can set it up yourself!

Forem: Aditya Karad

Six ways of dependency injection in Spring Boot — A Deep Dive

Introduction

Pre-requisites

Injection using Annotations

Injection using Annotations and Autowiring

What is Autowiring?

Field Injection

Constructor Injection

Setter Injection

What kind of dependency injection should you use?

What if there are multiple implementations annotated with @Component?

Dependency Injection with XML configuration

Constructor Injection

Setters Injection

Injecting Literal Values through setters

Injecting values from properties file

That's it, folks

ER Model Explained — DBMS Concepts | Coding Chronicles

What is an Entity-Relationship Model (ER Model)

Entity

Attribute

Types of Attributes

Key Attribute

Composite Attribute

Multivalued Attribute

Derived Attribute

Relationship

Relationship Table

Types of Relationships

One-to-One relationship

One-to-Many relationship

Many-to-One relationship

Many-to-Many relationship

That's it, folks!

Coding Chronicles Newsletter

Setting up CI/CD Pipeline for a React app using Travis CI

Introduction

Pre-requisites

Initialize a React app

Adding .travis.yml file

What does .travis.yml file do?

Hooks provided by Travis CI

script and install hooks

Using GitHub Pages in deploy hook

Setting homepage in package.json file

Committing changes to Github and triggering a Travis CI build

Travis CI Build Results

Conclusion

Source code of the project

Some more things

Default commands used by Travis CI

Using Notion as a CMS for a blog for free

Why to use Notion as your CMS?

Solution

What if there are multiple implementations annotated with `@Component`?

Adding `.travis.yml` file

What does `.travis.yml` file do?

`script` and `install` hooks

Using GitHub Pages in `deploy` hook

Setting homepage in `package.json` file