Forem: Nilanchal

Working with XML-Based REST API with Spring Boot

Nilanchal — Sat, 07 Sep 2024 22:04:45 +0000

The @RestController annotation in Spring boot is designed to automatically serializes Java objects into JSON or XML, based on the content negotiation strategy defined in your controller.

It combines the @Controller and @ResponseBody annotations. It tells Spring that this class is a controller where every method returns a domain object instead of a view.

The payload is automatically converted to JSON or XML based on the value defined in the Accept header.
Similarly, the response object is automatically converted to JSON or XML-based Content-type header defined in your controller configuration.

Spring uses the Jackson library internally so we don't need to serialise or deserialise to convert Java objects manually.

Watch the full video walkthrough.

For example in the following controller class:

It has 3 controller methods; two GET endpoints that return the movie data
A POST endpoint that adds a new movie to the MongoDB
By default, the controller class will accept the JSON request and produce the JSON response.

@RestController
@RequestMapping(value = "/api/1.0/movies")
public class MoviesController {

    private final MovieService movieService;

    public MoviesController(MovieService movieService) {
        this.movieService = movieService;
    }

    @GetMapping
    public ResponseEntity<List<Movie>> getMovies() {
        return ResponseEntity.ok(movieService.getMovies());
    }

    @PostMapping
    public Movie createMovie(@RequestBody MovieDto movieDto) {
        return movieService.createMovie(movieDto);
    }

    @GetMapping(path = "/{movieId}")
    public Movie getMovie(@PathVariable String movieId) {
        return movieService.getMovie(movieId);
    }
}

Let us change the MovieController to accept XML content type in the request body and produce the XML response.

Jackson XML Dependency

First, We need to add Jackson XML dependency for reading and writing XML data.

For the Gradle project, add the following dependency to your build.gradle file:

implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-xml'

For a maven-based project, you can add the following to your pom.xml file.

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
</dependency>

We need to annotate our controller mapping to match the application/xml media type. This is done using the Content-Type and Accept media type to our controller mapping.

This can be done by defining the appropriate MediaType using the produces and consumes property of RequestMapping annotation.

@RestController  
@RequestMapping(value = "/api/1.0/movies",  
        consumes = {MediaType.APPLICATION_XML_VALUE}, # Content-Type
        produces = {MediaType.APPLICATION_XML_VALUE}  # Accept
)  
public class MoviesController {  

    private final MovieService movieService;  

    public MoviesController(MovieService movieService) {  
        this.movieService = movieService;  
    }  

    @GetMapping
    public ResponseEntity<List<Movie>> getMovies() {  
        return ResponseEntity.ok(movieService.getMovies());  
    }  

    @PostMapping
    public Movie createMovie(@RequestBody MovieDto movieDto) {  
        return movieService.createMovie(movieDto);  
    }  

    @GetMapping(path = "/{movieId}")  
    public Movie getMovie(@PathVariable String movieId) {  
        return movieService.getMovie(movieId);  
    }  

}

In the above code snippet, we have set the MediaType configuration to the controller level, which means all controller methods will now consume and produce XML output. We can also do the same to the individual methods by using produces and consumes property on HTTP method mapping annotation.

That is all, now our controller will handle the XML request and produce the application/xml media type. Let us test our /movies endpoint

curl --location 'http://localhost:8080/api/1.0/movies' \
    --header 'Content-type: application/xml' \
    --header 'Accept: application/xml'

Now it will produce XML output

<List>
    <item>
        <id>65c4092af4ba290f3c55cd06</id>
        <title>Iron Man &amp; Captain America: Heroes United</title>
        <headline>Iron Man (Adrian Pasdar) and Captain America (Roger Craig Smith) must prevent Red Skull (Liam O'Brien) and Taskmaster (Clancy Brown) from destroying the world.</headline>
        <language>EN</language>
        <region>USA</region>
        <actors>
            <actors>David Kaye</actors>
            <actors>Ian McKellen</actors>
            <actors>Adrian Pasdar</actors>
        </actors>
        <genres>
            <genres>Action</genres>
            <genres>Adventure</genres>
            <genres>Sci-fi</genres>
        </genres>
    </item>
    <item>
        <id>65c4092af4ba290f3c55cd07</id>
        <title>Iron Man &amp; Captain America: Heroes United</title>
        <headline>Iron Man (Adrian Pasdar) and Captain America (Roger Craig Smith) must prevent Red Skull (Liam O'Brien) and Taskmaster (Clancy Brown) from destroying the world.</headline>
        <language>EN</language>
        <region>USA</region>
        <actors>
            <actors>David Kaye</actors>
            <actors>Ian McKellen</actors>
            <actors>Adrian Pasdar</actors>
        </actors>
        <genres>
            <genres>Action</genres>
            <genres>Adventure</genres>
            <genres>Sci-fi</genres>
        </genres>
    </item>
</List>

Configure Default Content Negotiation

The above method works fine but the configuration is now at controller level. The default media type remains JSON for all other controllers.

We can override this by setting the default content negotiation for all controllers thought the project by implementing the WebMvcConfigurer configuration.

@Configuration  
public class AppConfig implements WebMvcConfigurer {  

    @Override  
    public void configureContentNegotiation(ContentNegotiationConfigurer configurer) { 
        configurer.defaultContentType(MediaType.APPLICATION_XML);  
    }  
}

Wrapping XML Response

Notice the above XML response, the result is wrapped inside <List><item><item></List> tag. This is not very pretty.

We can make the following changes to wrap the response <movies><movie></movie></movies> tag.

Create a wrapper class for Movies.
The @JacksonXmlRootElement annotation can be used to define the name of the root element used for the root-level object when serialized, which normally uses the name of the type (class).
The @JacksonXmlElementWrapper annotation is used to specify XML elements to use for wrapping List and Map properties.
From the controller, instead of returning ResponseEntity<List<Movie>>, we will return the ResponseEntity<Movies>> type.

@Getter
@Setter
@RequiredArgsConstructor
@JacksonXmlRootElement(localName = "movies")
public class Movies {

    @JacksonXmlProperty(localName = "movie")
    @JacksonXmlElementWrapper(useWrapping = false)
    private final List<Movie> moviesList;

}

@Getter
@Setter
@JacksonXmlRootElement(localName = "Movie")
public class Movie {
    private String id;
    private String title;
    private String headline;
    private String language;
    private String region;
    private List<String> actors;
    private List<String> genres;
}

And, update the controller to return the ResponseEntity<Movies>> type.

@GetMapping  
public ResponseEntity<Movies> getMovies() {  
    Movies movies = new Movies(movieService.getMovies());  
    return ResponseEntity.ok(movies);  
}

Now this will produce,

<movies>
    <movie>
        <id>65c4092af4ba290f3c55cd06</id>
        <title>Iron Man &amp; Captain America: Heroes United</title>
        <headline>Iron Man (Adrian Pasdar) and Captain America (Roger Craig Smith) must prevent Red Skull (Liam O'Brien) and Taskmaster (Clancy Brown) from destroying the world.</headline>
        <language>EN</language>
        <region>USA</region>
        <actors>
            <actors>David Kaye</actors>
            <actors>Ian McKellen</actors>
            <actors>Adrian Pasdar</actors>
        </actors>
        <genres>
            <genres>Action</genres>
            <genres>Adventure</genres>
            <genres>Sci-fi</genres>
        </genres>
    </movie>
    <movie>
        <id>65c4092af4ba290f3c55cd07</id>
        <title>Iron Man &amp; Captain America: Heroes United</title>
        <headline>Iron Man (Adrian Pasdar) and Captain America (Roger Craig Smith) must prevent Red Skull (Liam O'Brien) and Taskmaster (Clancy Brown) from destroying the world.</headline>
        <language>EN</language>
        <region>USA</region>
        <actors>
            <actors>David Kaye</actors>
            <actors>Ian McKellen</actors>
            <actors>Adrian Pasdar</actors>
        </actors>
        <genres>
            <genres>Action</genres>
            <genres>Adventure</genres>
            <genres>Sci-fi</genres>
        </genres>
    </movie>
</movies>

Importing CSV Data into PostgreSQL using Spring Batch

Nilanchal — Tue, 21 May 2024 10:25:29 +0000

Spring Batch is a powerful module of the Spring framework that provides out-of-the-box implementation for batch processing tasks.

It is used in scenarios where data needs to be processed in multiple batches, for example, generating daily reports, periodic import of data into a database, or for any complex calculations and transformations of your data.

A typical batch-processing application involves the following steps:

Why Spring Batch?

All the above steps can be achieved without using the spring batch. However, the spring batch provides the following benefits which makes a strong case for the framework.

You do not need to reinvent the wheel
Seamless integration with Spring ecosystem
Chunk-based processing
Includes I/O capabilities such as support for a wide range of data sources and targets, including databases, XML, JSON, and flat files.
Detailed monitoring and logging: Allows tracking of job and step execution, making it easier to understand the status and performance of batch jobs.

Spring Batch provides two different ways to implement a job. We can process data using Tasklets and Chunks.

A Tasklet is a single task within a step. The Tasklet interface defines a single method execute(), called once during the step execution.

A Chunk-based approach is more suitable for processing large datasets where data can be read, processed, and written in smaller, manageable chunks. This is typically used for reading data from a database or a file and processing it record by record. The chunk model is built around three main components; Reader, Writer and Processor

Spring Boot Batch Chunk Processing

The key components of a Spring boot batch application include: - Job

Step
Readers, Writers, Processors
Job Repository
Job Launcher

The primary components of the Spring Batch and overall process flow are shown in the figure below.

JobLauncher:
The JobLauncher is an interface that represents the component responsible for running the jobs. It takes care of receiving job parameters and launching a job with those parameters. It's typically used to start a job from different triggers such as an application event, a REST API call, or from scheduler.

Job:
A Job in a Spring Batch is an entity that encapsulates an entire batch process and is defined by a series of steps.

Step:
A single job may have one or more steps, where each step typically involves reading data, processing it, and writing the processed data to the output source.

ItemReader:
The ItemReader is responsible for reading data from different sources such as databases or files. The ItemReader has a read() method, every time this method is invoked, it will return one item. If there are no more items to read, it returns null to indicate the end of the data input.

The FlatFileItemReader can be used for reading data from flat files (like CSV), JdbcCursorItemReader for reading from databases using a JDBC cursor, and JpaPagingItemReader can be used for reading database records using JPA pagination.

ItemProcessor:
The ItemProcessor is completely optional. It is used to validate, transform, or filter the items before passing them to the ItemWriter.

ItemWriter:
The ItemWriter takes processed items and writes them to a database or a file. The FlatFileItemWriter can be used for writing data to flat files, JdbcBatchItemWriter for batching database operations through JDBC, and JpaItemWriter for handling database operations using JPA.

Job Repository:
The JobRepository does all the hard work such as recording the status of jobs in a database. It keeps track of which jobs are running, which have been completed, and if a job fails, what step it failed at. This is critical for jobs that need to be restarted after a failure, ensuring that the job can pick up where it left off.

Load CSV Data to Postgres SQL using Spring Batch

This example uses chunk-based processing for reading CSV files, processing it and then storing it in Postgres SQL. For managing the database migrations we will use Flyway.

Use Spring Initializr to bootstrap a spring boot project by selecting the required dependencies. This example uses Java 17 and Spring Boot 3.2.4 and has the following dependencies.

Spring Batch
Spring Data JPA
PostgreSQL Driver
Lombok - completely optional for reducing boilerplate code.
Flyway - Database migration

Watch the step-by-step guide here

Find the full blog post and source code here at stacktips.com

Validating Configuration Properties in Spring Boot Application Startup

Nilanchal — Tue, 07 May 2024 18:20:35 +0000

The @ConfigurationProperties annotation in Spring Boot is used to bind configuration parameters typically from properties or YAML files to a Java class.

But, did you know you also can validate configuration properties at spring application startup with the @ConfigurationProperties annotation? Let's dive in!

Let's say we have a Spring boot importer service that imports customer data from a CSV file to the database periodically. For the importer to work we have the following configurations:

importer:  
  service:  
    filePath: '/nfs/files'
    fileType: '.xslx'
    threadPoolSize: 3

These properties can be mapped to a Java class automatically using @ConfigurationProperties annotation as follows:

@Getter 
@Setter
@Component
@ConfigurationProperties(prefix = "importer.service")
public class ImporterConfig {  
    String filePath;
    String fileType;
    int threadPoolSize;
}

Now let's say, we want to ensure the importer configuration is provided and meets the validation criteria when the application starts. If any of the validation fails, then the application should fail during startup.

For this validation to work, we need to have a JSR-380 implementation like Hibernate Validator on your classpath.

implementation 'org.springframework.boot:spring-boot-starter-validation'

Once we have a validator in the classpath, we need to explicitly enable the configuration properties validation using @Validated annotation.

For example,

@Getter  
@Setter  
@Component  
@Validated  
@ConfigurationProperties(prefix = "importer.service")  
public class ImporterConfig {  

    @NotNull  
    String filePath;  

    @NotNull  
    @Pattern(regexp = "\\.csv$|\\.txt$")  
    String fileType;  

    @Positive  
    @Max(10)  
    int threadPoolSize;  
}

This can validate properties on application startup when used in conjunction with JSR-380 bean validation annotations such as @Max, and @NotNull. Here are some of the common annotations used for bean validation:

@NotNull: specifies that a property must be not null
@NotEmpty: specifies that a property must be not null or not empty
@Size: ensure that a property size is between attributes min and max
@Email: specifies that a property must be a valid email address
@AssertTrue / @AssertFalse: ensure that a property value is true/false
@Positive / @Negative: ensure that a property is positive/negative
@Past / @Future: specifies that the date must be in the past/ future
@Max / @Min: specifies that a property has a value not greater/not smaller than the value attribute

A full list of built-in validation constraints in JSR 380 can be found here.

Now, Run the application and notice that it will bind these properties from application.yaml to the ImporterConfig object and validate them at application startup, thus ensuring the application doesn't run with invalid configurations.

If the validation fails it will result in BindException as shown below:

***************************
APPLICATION FAILED TO START
***************************

Description:

Binding to target com.stacktips.app.config.ImporterConfig failed:

    Property: importer.service.fileType
    Value: ".xlsx"
    Origin: class path resource [application.yaml] - 8:15
    Reason: must match "\.csv$|\.txt$"


Action:

Update your application's configuration

Now you update the fileType: .csv and the application will start as expected.

Considerations for Using Records

Starting with Spring Boot 2.6 and Java 16 you can use record classes with @ConfigurationProperties. But there are a few things you need to consider when using records.

@Validated  
@ConfigurationProperties(prefix = "importer.service")  
public record ImporterProperties(  
        @NotNull String filePath,  
        @Min(3) int threadPoolSize) {  
}

The @Componenet annotation cannot be used with records. Your IDE will show an annotated with @ConstructorBinding but defined as a Spring component error.

This is because the @Component annotation is generally used to define a bean that the Spring container will automatically detect and manage. As Java records are immutable, it conflicts with the way Spring manages beans, which involves proxying, intercepting, and potentially altering object states or behaviour.

To fix this, we need to remove the @Component annotation and explicitly define the bean registration. We can either use @EnableConfigurationProperties or define the @Bean annotation in one of the @Configuration classes.

For example:

@EnableConfigurationProperties(ImporterProperties.class)  
@SpringBootApplication  
public class MyApplication {  

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

}

Task Execution and Scheduling in Spring Boot

Nilanchal — Sat, 20 Apr 2024 12:35:56 +0000

Spring Scheduler is used for running repetitive tasks or to automate tasks that need to run at specific times or at specific intervals. For example such as sending our email newsletters to your customers, generating daily reports, or updating a database periodically.

In this crash course, we will cover everything you need to know about Spring Scheduler – including the annotations, examples, and other things to consider.

Enable Scheduling

To enable Spring's scheduled task execution capability, just annotate any of your @Configuration classes with @EnableScheduling annotation.

Example:

@Configuration
@EnableScheduling
public class SchedulerConfig {
    //TODO Here it goes your configuration
}

Cron expression

A Cron expression consists of six sequential fields and is declared as second, minute, hour, day of the month, month, day(s) of the week.

┌───────────── second (0-59)
│ ┌───────────── minute (0 - 59)
│ │ ┌───────────── hour (0 - 23)
│ │ │ ┌───────────── day of the month (1 - 31)
│ │ │ │ ┌───────────── month (1 - 12) (or JAN-DEC)
│ │ │ │ │ ┌───────────── day of the week (0 - 7)
│ │ │ │ │ │              (0 or 7 is Sunday or MON-SUN)
│ │ │ │ │ │
* * * * * *

Ref: https://crontab.guru/

And is declared as follows:

@Slf4j
@Component
public class MyScheduler {

    private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");

    @Scheduled(cron = "*/5 * * * * *")
    public void currentTime() {
        log.info("Current Time = {}", dateFormat.format(new Date()));
    }

}

We can also set the timezone as: https://docs.oracle.com/cd/B13866_04/webconf.904/b10877/timezone.htm

@Scheduled(cron="* * * * * *", zone="Europe/London")

Fixed delay

The fixedDelay property makes sure that there is a delay of n milliseconds between the finish time of an execution of a task and the start time of the next execution of the task.

@Component
public class MyScheduler {

    @Scheduled(fixedDelay=5000) 
    public void doSomething() {
       //This will execute periodically, after the one before finishes
    } 

}

By default, milliseconds will be used as the time unit for fixed delay, fixed rate, and initial delay values. If you would like to use a different time unit such as seconds or minutes, you can configure this via the timeUnit attribute in @Scheduled.

For example, the previous example can also be written as follows.

@Component
public class MyScheduler {

    @Scheduled(fixedDelay=5, timeUnit = TimeUnit.SECONDS) 
    public void doSomething() {
       //This will execute periodically, after the one before finishes
    } 

}

Fixed Rate

The fixedRate is used when we want to execute a task periodically at every n millisecond without checking for any previous executions of the task.

@Component
public class MyScheduler {

    @Scheduled(fixedRate=5000)
    public void doSomething() {
       //This will execute periodically
    } 
}

For both fixedDelay and fixedRate tasks, you can specify an intialDelay by indicating the amount of time to wait before the first execution of the method.

@Component
public class MyScheduler {

    @Scheduled(initailDelay=1000, fixedRate=5000)
    public void doSomething() {
      //This will execute periodically
    } 
}

Schedule Tasks and Concurrency

Spring Boot uses a ThreadPoolTaskScheduler to execute scheduled tasks. By default, this thread pool has a single thread. This means that only one scheduled task can be executed at a time.

If you need to execute multiple tasks concurrently, then you need to configure the ThreadPoolTaskScheduler to have the required thread pool size.

@Bean
public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
    ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
    threadPoolTaskScheduler.setPoolSize(5);
    return threadPoolTaskScheduler;
}

Also, we need to use the @Async annotation to mark the scheduled task as asynchronous. This will make Spring Boot execute the tasks in separate threads.

@Async
    @Scheduled(fixedDelay = 1000)
    public void startUsingFixedDelay() {
        log.info("startUsingFixedDelay:: Task started at {}", DATE_FORMAT.format(new Date()));
    }

Aggregate Scheduled annotations

The @Schedules annotation is a container annotation that aggregates several Scheduled annotations.

@Schedules({
   @Scheduled(fixedRate = 10000),
   @Scheduled(cron = "0 * * * * MON-FRI")
})
public void doSomething() {
    //This will execute periodically
}

Before Java 8, a wrapper/container annotation was required to use multiple instances of the same annotation. But Java 8 supports repeatable annotations so wrapper annotation is no longer necessary. Multiple annotations can be used without a wrapper.

@Scheduled(fixedRate = 10000)
@Scheduled(cron = "0 * * * * MON-FRI")
public void doSomethingElse4() {
    //This will execute periodically
}

This rule is automatically disabled when the project’s sonar.java.source is lower than 8 as repeating annotations were introduced in Java 8.

Testing the Scheduler using Awaitility

Testing the scheduler can be a little tricky. We can test this by manually waiting for x number of minutes using Thread.sleep() , but for complex scenarios, this will be hard to scale.

This is where we can use a framework like Awaitility to wait for a certain condition to be met while running your test. In this case, we want to wait for 1000 milliseconds before we assess the test results.

Let's first add the awaitility test dependency on your build.gradle file.

testImplementation 'org.awaitility:awaitility:3.1.2'

Now,

@SpringJUnitConfig(SchedulerConfig.class)
class MySchedulerTest {

    @SpyBean
    MyScheduler scheduler;

    @Test
    void givenSleepBy1000ms_whenStartTask1() {

        Awaitility.await()
                .atMost(1000, TimeUnit.MILLISECONDS)
                .untilAsserted(() -> {
                    verify(scheduler, atLeast(1)).startUsingFixedDelay();
                });
    }

}

Task Monitoring:

Spring boot actuators provides the /scheduledtasks endpoint to monitor the list of tasks scheduled and their configurations. To enable this we need to add the actuator starter dependencies.

implementation 'org.springframework.boot:spring-boot-starter-actuator'

Once Actuator dependencies is added, we need to explicitly include the scheduledtasks endpoint by using the following property

management.endpoints.web.exposure.include=scheduledtasks

Did you know?

What happens if a scheduled task throws an exception?
If any exception is encountered during the scheduled task execution and if it is not handled gracefully using a try-catch block then the Spring Logging Error Handler will handle the exception and log the error details.

The next instances of that task will continue to execute as per the schedule.

What happens if a scheduled task takes longer than its scheduled interval?
In the case of a fixed rate, if a scheduled task takes longer than its scheduled interval, the Spring Scheduler will start the next execution of the task immediately after the previous one is completed.

This can cause tasks to overlap, which may impact performance.

Limitations of Spring Scheduler

No support for dynamic Scheduling: The @Scheduled annotations are typically configured at application startup and do not support dynamic scheduling without redeploying the application.
No support for Job Persistence: It does not offer built-in support for Job persistence, as a result, job recovery in the event of an application restart is not possible.
No clustering, load balancing: It does not support clustering and load balancing, The tasks are typically run on a single node.
Limited control: It does not allow fine-grained control over managing the tasks. For example, we cannot pause, resume, and unscheduled jobs individually.

Spring Scheduler is sufficient for many simple scheduling tasks, but if you have complex scheduling requirements, job management, and monitoring, then you would need another framework like Quartz.

What is Project Lombok? Is it still relevant in 2023?

Nilanchal — Sat, 30 Mar 2024 07:16:17 +0000

What is Project Lombok? Have you used this magical library? With the new Java Records feature, you might wonder if Lombok is still relevant. Let's weigh the pros and cons and see if this is suitable for you.

What is Project Lombok?

Project Lombok is a popular Java library, used to remove the boilerplate code with the intent to save development time.

It replaces the boilerplate code such as getters, setters, constructors, toString, equals, and builders with a set of annotations. This means less code, saves time, and reduces verbosity, making your codebase cleaner, readable, and more maintainable.

It also includes utilities such as delombok checking null values and @Slf4j for logging support.

For example, traditionally a class declaration looks something like this;

public class Car {
    private String model;
    private int year;
    private String fuelType;

    public Car() {
    }

    public Car(String model, int year, String fuelType) {
        this.model = model;
        this.year = year;
        this.fuelType = fuelType;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Car car = (Car) o;
        return year == car.year && Objects.equals(model, car.model) && Objects.equals(fuelType, car.fuelType);
    }

    @Override
    public String toString() {
        return "Car{" +
                "model='" + model + '\'' +
                ", year=" + year +
                ", fuelType='" + fuelType + '\'' +
                '}';
    }

    @Override
    public int hashCode() {
        return Objects.hash(model, year, fuelType);
    }

    public String getModel() {
        return model;
    }

    public void setModel(String model) {
        this.model = model;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public String getFuelType() {
        return fuelType;
    }

    public void setFuelType(String fuelType) {
        this.fuelType = fuelType;
    }
}

But with Lombok, we can write the same code using a bunch of annotations.

@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@ToString
@EqualsAndHashCode
public class Car {
    String model;
    int year;
    String fuelType;
}

Alternatively, you can also replace all the above annotations with just one @Data annotation.

How it works?

It works by using an annotation processor to modify the abstract syntax tree (AST) of your code during compilation. The annotation processor reads annotations defined in your class and adds required methods to the AST. The compiler then uses the modified AST to produce the bytecode.

Lombok Annotations

@Getter, @Setter : Generates getters and setter methods for the field.
@NoArgsConstructor, @AllArgsConstructor, @RequiredArgsConstructor : Generates constructors for your class
@Builder: Provides a builder pattern interface for the annotated class.
@Data : Equivalent to adding the annotations @Getter,@Setter, @RequiredArgsConstructor, @ToString, @EqualsAndHashCode to your class
@Value: Makes the class instances immutable
@NonNull: Null check
@SneakyThrows : Could be added to a method that throws a checked exception
@ToString : Generates a toString() method
@EqualsAndHashCode : Generates an .equals(..) and a hashCode() methods

Check out the official documentation for all Lombok annotations and their usage. https://t.co/HoiMNzPm4k

Things to consider

While it promotes simplicity and clean code, it does too much magic in the background, and for newbie developers, it can be quite confusing.

Find usage problem

When using Lombok you don't see the generated getter, setter, constructor, builder methods, etc. So, if you want to want to find out where these methods are being used in your project, you can't do this without being dependent on IDE plugins.

Misuse of `@Builder`

With Lombok, a builder is so easy to create that even when a class has only two parameters the developers prefer to use @builder instead of a constructor or a static constructor method. Doing so makes it more harm than good.

The `@Value` annotation and final class

The @Value annotations make the class Final. It is the immutable variant of @Data annotation.

All fields are made private and final by default and this does not generate any setter methods. If you want to make your class extendable, then you cannot use the @Value annotation.

@Value
public class Car {
    String model;
    int year;
    String fuelType;
}

The same behaviour for a class can be achievable natively in Java using Java 16 records. With records, you can define the data fields in one line of code, instead of having to define a constructor and getter/setter methods for each field in a class.

Records also have a built-in equals() and hashCode() method and they are _ immutable _ by default. It makes your code shorter, easier to read, and less prone to errors.

public record Car(String model, int year, String fuelType) {

}

With the inclusion of records in Java, one would wonder if you need Lombok at all.

Using `@Data` on Entities

You need to use the @Data annotation very cautiously. It can cause serious serialization issues with ORMs like Hibernate and serializer engines like Gson.

Do yourself a favour and read this article by Thorben Janssen

Verdict

Lombok is just one tool in the toolbox. You need to understand the trade-offs and consider team expertise before considering this. Lombok makes a lot of sense in Greenfield and small projects to get off the ground. Introducing larger projects has mixed benefits at bestIf you using an IDE such as IntelliJ, it is pretty easy to generate these boilerplate codes, and enabling the code folding can help to make your code more readable.

Unless you know what you're doing, I suggest holding back on your temptation to use Lombok.

What is your experience? Do you use Lombok for your projects? Would love you hear your experience.

Originally published at http://stacktips.com

Introducing Bloggy: The Open-Source Blogging Platform Built with Python and Django

Nilanchal — Sun, 22 Oct 2023 09:55:16 +0000

Today, I am excited to take a giant leap forward in my journey by open-source the codebase of my blog stacktips is now available on GitHub.

Check out the codebase here.
https://github.com/StackTipsLab/bloggy

It is built using Python and the latest version of the Django framework. I am no expert in Python, but this is my attempt to master the language and framework.

Key Features

Along with tons of features aimed at enhancing the development and blogging experience.

1. Signup and Login: Seamlessly create your account and log in to access exclusive content.

2. Magic Link Sign-In: Forget passwords! We've streamlined the login process with magic link sign-in.

3. Create and Publish: Share your knowledge with the world by creating and publishing articles, courses, and quizzes effortlessly.

4. Customized Admin Dashboard: Manage your content efficiently with a user-friendly admin dashboard designed with you in mind.

5. Sitemaps: Enhance discoverability with built-in sitemaps that improve search engine ranking.

6. Webmaster Notifications: Get noticed! StackTips automates Google and Bing webmaster notifications to ensure your content reaches a wider audience.

Why Open-Source StackTips?

I believe in the power of collaboration. By open-sourcing my blog codebase, I invite the developer community to contribute, improve, and build upon our platform.

This isn't just a blog; it's a collective effort to create a resource that truly serves developers.

Get Involved!

Are you a developer looking to enhance your skills, share your knowledge, or simply be curious about the inner workings of a developer-centric blog platform? Now's your chance!

Want to contribute right away? Check out the issues section.
https://github.com/StackTipsLab/bloggy/issues

Join us on GitHub and contribute to the Bloggy project: https://github.com/StackTipsLab/bloggy

Let's shape the future of developer blogging together.

Happy Coding!

Replace Embedded Tomcat Server with Jetty or Undertow in Spring Boot3

Nilanchal — Sat, 07 Oct 2023 01:06:27 +0000

One of the key features of the Spring Boot framework is the built-in support for embedded servers. It includes support for embedded Tomcat, Jetty, and Undertow servers. This means you don’t need any external web servers and no need to deploy WAR files anymore.

The embedded Tomcat server is available through the spring-boot-starter-web dependency.

However, if you want Jetty or Undertow servers then you can include spring-boot-starter-jetty or spring-boot-starter-undertow dependencies.

This video tutorial explains how to replace the default embedded Tomcat with Jetty or Undertow servers in your Maven or Gradle project.

Happy Learning!

Popular Java Interview Questions and Answers

Nilanchal — Mon, 02 Oct 2023 00:02:35 +0000

What is the difference between comparison done by equals method and == operator?

In Java, equals() method is used to compare the contents of two string objects and returns true if the two have the same value while == operator compares the references of two string objects.

In the following example, equals() returns true as the two string objects have the same values. However == operator returns false as both string objects are referencing to different objects:

public class EqualsTest {

    public static void main(String args[]) {
        String str1 = new String("Hello World");
        String str2 = new String("Hello World");

        //Reference comparison
        System.out.println(s1 == s2);

        //Content comparison
        System.out.println(s1.equals(s2));

        // integer-type
        System.out.println(10 == 10);

        // char-type
        System.out.println('a' == 'a');
    }

}

Output

false
true
true
true

How is an infinite loop declared in Java?

Infinite loops are those loops that run infinitely without any breaking conditions. Some examples of consciously declaring an infinite loop are:

Using For Loop:

for (;;)
{
   // Business logic
   // Any break logic
}

Using while loop:

while(true){
   // Business logic
   // Any break logic
}

Using do-while loop:

do{
   // Business logic
   // Any break logic
} while(true);

Why is the main method static in Java?

The main method is always static because static members are those methods that belong to the classes, not to an individual object. So if the main method will not be static then for every object, It is available. And that is not acceptable by JVM. JVM calls the main method based on the class name itself. Not by creating the object.

Because there must be only 1 main method in the java program as the execution starts from the main method. So for this reason the main method is static.

How would you differentiate between a String, StringBuffer, and a StringBuilder?

Storage area: In string, the String pool serves as the storage area. For StringBuilder and StringBuffer, heap memory is the storage area.

Mutability: A String is immutable, whereas both the StringBuilder and StringBuffer are mutable.

Efficiency: It is quite slow to work with a String. However, StringBuilder is the fastest in performing operations. The speed of a StringBuffer is more than a String and less than a StringBuilder. (For example appending a character is fastest in StringBuilder and very slow in String because a new memory is required for the new String with appended character.)

Thread-safty: In the case of a threaded environment, StringBuilder and StringBuffer are used whereas a String is not used. However, StringBuilder is suitable for an environment with a single thread, and a StringBuffer is suitable for multiple threads.

Syntax:

// String
String first = "InterviewBit";
String second = new String("InterviewBit");

// StringBuffer
StringBuffer third = new StringBuffer("InterviewBit");

// StringBuilder
StringBuilder fourth = new StringBuilder("InterviewBit");

What is a Comparator in java?

Consider the example where we have an ArrayList of employees like( EId, Ename, Salary), etc. Now if we want to sort this list of employees based on the names of employees. Then that is not possible to sort using the Collections.sort() method. We need to provide something to the sort() function depending on what values we have to perform sorting. Then in that case a comparator is used.

Comparator is the interface in java that contains the compare method. And by overloading the compare method, we can define that on what basis we need to compare the values.

What makes a HashSet different from a TreeSet?

Although both HashSet and TreeSet are not synchronized and ensure that duplicates are not present, there are certain properties that distinguish a HashSet from a TreeSet.

Implementation: For a HashSet, the hash table is utilized for storing the elements in an unordered manner. However, TreeSet makes use of the red-black tree to store the elements in a sorted manner.

Complexity/ Performance: For adding, retrieving, and deleting elements, the time amortized complexity is O(1) for a HashSet. The time complexity for performing the same operations is a bit higher for TreeSet and is equal to O(log n). Overall, the performance of HashSet is faster in comparison to TreeSet.

Methods: hashCode() and equals() are the methods utilized by HashSet for making comparisons between the objects. Conversely, compareTo() and compare() methods are utilized by TreeSet to facilitate object comparisons.

Objects type: Heterogeneous and null objects can be stored with the help of HashSet. In the case of a TreeSet, runtime exception occurs while inserting heterogeneous objects or null objects.

What are the differences between HashMap and HashTable in Java?

HashMap	HashTable
HashMap is not synchronized thereby making it better for non-threaded applications.	HashTable is synchronized and hence it is suitable for threaded applications.
Allows only one null key but any number of null in the values.	This does not allow null in both keys or values.
Supports order of insertion by making use of its subclass LinkedHashMap.	Order of insertion is not guaranteed in HashTable.

What are the different ways to create threads in Java?

We can define and implement a thread in java using two ways: Extending the Thread class

class ThreadExample extends Thread {  
   public void run(){  
       System.out.println("Thread runs...");  
   }  
   public static void main(String args[]){  
       ThreadExample ib = new ThreadExample();  
       ib.start();  
   }  
}

Implementing the Runnable interface

class ThreadExample implements Runnable {  
   public void run(){  
       System.out.println("Thread runs...");  
   }  
   public static void main(String args[]){  
       Thread ib = new Thread(new ThreadExample()); 
       ib.start();  
   }  
}

Implementing a thread using the method of Runnable interface is more preferred and advantageous as Java does not have support for multiple inheritances of classes. start() method is used for creating a separate call stack for the thread execution. Once the call stack is created, JVM calls the run() method for executing the thread in that call stack.

What is difference between thread and process?

A thread is a class in java that belongs to java.lang package. A thread is an lightweight process and has its own call stack. In Java, you can run multiple threads parallely. A thread is used to perform long running jobs dedicated without disturbing to the other part of program. Even if you don't create any new threads in your program, there is at least one thread i.e. main thread() which runs the application.

Threads share the address space of the process that created it; processes have their own address.
Threads have direct access to the data segment of its process; processes have their own copy of the data segment of the parent process.
Threads can directly communicate with other threads of its process; processes must use interprocess communication to communicate with sibling processes.
Threads have almost no overhead; processes have considerable overhead.
New threads are easily created; new processes require duplication of the parent process.
Threads can exercise considerable control over threads of the same process; processes can only exercise control over child processes.
Changes to the main thread (cancellation, priority change, etc.) may affect the behavior of the other threads of the process; changes to the parent process do not affect child processes.

What are the different states of a thread's life cycle?

New - When a thread is instantiated it is in New state until the start() method is called on the thread instance. In this state the thread is not considered to be alive.
Runnable - The thread enters into this state after the start method is called in the thread instance. The thread may enter into the Runnable state from Running state. In this state the thread is considered to be alive.
Running - When the thread scheduler picks up the thread from the Runnable thread's pool, the thread starts running and the thread is said to be in Running state.
Waiting/Blocked/Sleeping - In these states the thread is said to be alive but not runnable. The thread switches to this state because of reasons like wait method called or sleep method has been called on the running thread or thread might be waiting for some i/o resource so blocked. Dead - When the thread finishes its execution i.e. the run() method execution completes, it is said to be in dead state. A dead state can not be started again. If a start() method is invoked on a dead thread a runtime exception will occur.

What are different ways in which a thread can enter the waiting state?

A thread can enter the waiting state by the following ways:

Invoking its sleep() method,
By blocking on I/O
By unsuccessfully attempting to acquire an object's lock
By invoking an object's wait() method.
It can also enter the waiting state by invoking its (deprecated) suspend() method.

What is the difference between yield and sleep?

When a task invokes its yield() method, it returns to the ready state, either from waiting, running or after its creation. When a task invokes its sleep() method, it returns to the waiting state from a running state.

Extending Thread class or implementing Runnable Interface. Which is better?

You have two ways to create a thread in Java. First, making your class "extends" Thread class. The other way is making your class implement "Runnable" interface.

The latter is more advantageous, cause when you are going for multiple inheritance, then only interface can help. If you are already inheriting a different class, then you have to go for Runnable Interface. Also, if you are implementing interface, it means you have to implement all methods in the interface.

Both Thread class and Runnable interface are provided for convenience and use them as per the requirement. But if you are not extending any class, better extend Thread class as it will save few lines of coding. Otherwise performance wise, there is no distinguishable difference. A thread is in the ready state after it has been created and started.

What is mutual exclusion? How can you take care of mutual exclusion using Java threads?

Mutual exclusion in Java is a mechanism that allows only one thread to access a shared resource or critical section of code at a time, preventing race conditions where multiple threads can access and modify the same resource simultaneously.

For mutual exclusion, you can simply use the synchronized keyword, which can be applied to a method or a block of code to ensure that only one thread can access the synchronized code at a time.

Java offers different options to achieve mutual exclusion, such as the Semaphore class, the ReadWriteLock interface, the AtomicInteger class, and the StampedLock class. The choice of implementation depends on the specific requirements and constraints of the application.

Semaphore: The Semaphore class can be used to implement mutual exclusion. It allows a limited number of threads to access a critical section at the same time.
ReadWriteLock: The ReadWriteLock interface can be used to implement mutual exclusion for read and write operations. It allows multiple threads to read a shared resource simultaneously, but only one thread can write to the resource at a time.
AtomicInteger: The AtomicInteger class can be used to implement mutual exclusion for integer values. It provides atomic operations such as incrementAndGet() and decrementAndGet(), which ensures that only one thread can modify the value at a time.
StampedLock: The StampedLock class can be used to implement mutual exclusion for read and write operations. It provides optimistic read locks, which allows multiple threads to read a shared resource simultaneously, and a write lock, which allows only one thread to write to the resource at a time.

What is the difference between preemptive scheduling and time slicing?

Under preemptive scheduling, the highest priority task executes until it enters the waiting or dead states or a higher priority task comes into existence. Under time slicing, a task executes for a predefined slice of time and then re-enters the pool of ready tasks. The scheduler then determines which task should execute next, based on priority and other factors.

What is deadlock?

When two threads are waiting for each other and can't proceed until the first thread obtains a lock on the other thread or vice versa, the program is said to be in a deadlock.

What are synchronized methods and synchronized statements?

Synchronized methods are methods that are used to control access to an object. A thread only executes a synchronized method after it has acquired the lock for the method's object or class. Synchronized statements are similar to synchronized methods. A synchronized statement can only be executed after a thread has acquired the lock for the object or class referenced in the synchronized statement.

What is a volatile keyword?

In general, each thread has its own copy of the variable, such that one thread is not concerned with the value of the same variable in the other thread. But sometime this may not be the case. Consider a scenario in which the count variable is holding the number of times a method is called for a given class irrespective of any thread calling, in this case, irrespective of thread access the count has to be increased so the count variable is declared as volatile.

The copy of the volatile variable is stored in the main memory, so every time a thread access the variable even for reading purpose the local copy is updated each time from the main memory. The volatile variable also has performance issues.

What is Serializable?

Serializable is a marker interface. When an object has to be transferred over a network ( typically through RMI or EJB) or persists the state of an object to a file, the object Class needs to implement a Serializable interface. Implementing this interface will allow the object converted into a byte stream and transfer over a network.

What is use of serialVersionUID?

During object serialization, the default Java serialization mechanism writes the metadata about the object, which includes the class name, field names, types, and superclass. This class definition is stored as a part of the serialized object. This stored metadata enables the deserialization process to reconstitute the objects and map the stream data into the class attributes with the appropriate type every time an object is serialized the java serialization mechanism automatically computes a hash value.

ObjectStreamClass’s computeSerialVersionUID() method passes the class name, sorted member names, modifiers, and interfaces to the secure hash algorithm (SHA), which returns a hash value. The serialVersionUID is also called suid.

So when the serialized object is retrieved, the JVM first evaluates the suid of the serialized class and compares the suid value with the one of the objects. If the suid values match then the object is said to be compatible with the class and hence it is de-serialized. If not InvalidClassException exception is thrown.

Changes to a serializable class can be compatible or incompatible.

What is difference between ArrayList and Vector?

Synchronization – ArrayList is not thread-safe whereas Vector is thread-safe. In Vector class each method like add(), get(int i) is surrounded with a synchronized block and thus making Vector class thread-safe.
Data growth – Internally, both the ArrayList and Vector hold onto their contents using an Array. When an element is inserted into an ArrayList or a Vector, the object will need to expand its internal array if it runs out of room. A Vector defaults to doubling the size of its array, while the ArrayList increases its array size by 50 percent.

What is difference between HashMap and HashTable?

Both collections implement Map. Both collections store value as key-value pairs. The key differences between the two are

1. Hashmap is not synchronized in nature but HashTable is.
2. Another difference is that the iterator in the HashMap is fail-safe while the enumerator for the HashTable isn’t. Fail-safe – if the HashTable is structurally modified at any time after the iterator is created, in any way except through the iterator’s own remove method, the iterator will throw a ConcurrentModificationException
3. HashMap permits null values and only one null key, while Hashtable doesn’t allow key or value as null.

When to use ArrayList or LinkedList?

For the ArrayList, doing random lookup using get() is fast, but for LinkedList, it’s slow. It’s slow because there’s no efficient way to index into the middle of a linked list.
When removing elements, using ArrayList is slow. This is because all remaining elements in the underlying array of Object instances must be shifted down for each remove operation. But here LinkedList is fast because deletion can be done simply by changing a couple of links.
So an ArrayList works best for cases where you’re doing random access on the list, and a LinkedList works better if you’re doing a lot of editing in the middle of the list.

What is final, finalize() and finally? What does it mean that a class or member is final?

final – Variables defined in an interface are implicitly final. A final class can’t be extended i.e., the final class may not be subclassed. This is done for security reasons with basic classes like String and Integer. It also allows the compiler to make some optimizations and makes thread safety a little easier to achieve. A final method can’t be overridden when its class is inherited. You can’t change the value of a final variable (which is a constant)
finally – a keyword used in exception handling will be executed whether or not an exception is thrown. For example, the closing of open connections is done in the final method.
finalize – helps in garbage collection. finalize() method is used just before an object is destroyed and garbage collected.

What is Method Overriding? What restrictions are placed on method overriding?

When a class defines a method using the same name, return type, and argument list as that of a method in its superclass, the method in the subclass is said to override the method present in the Superclass. When the method is invoked for an object of the class, it is the new definition of the method that is called and not the method definition from the superclass. Restrictions placed on method overriding

Overridden methods must have the same name, argument list, and return type.
The overriding method may not limit the access of the method it overrides. Methods may be overridden to be more public, not more private.
The overriding method may not throw any exceptions that may not be thrown by the overridden method.

What is the difference between an Inner Class and a Sub-Class?

An Inner class is a class that is nested within another class. An Inner class has access rights to the class which is nesting it and it can access all variables and methods defined in the outer class.

A sub-class is a class that inherits from another class called a super class. Sub-class can access all public and protected methods and fields of its super class.

What are the various access specifiers for Java classes?

In Java, access specifiers are the keywords used before a class name that defines the access scope. The types of access specifiers for classes are:

Public: Class, Method, Field is accessible from anywhere.
Protected: Method, Field can be accessed from the same class to which they belong or from the sub-classes, and from the class of the same package, but not from outside.
Default: Method, Field, and class can be accessed only from the same package and not from outside of its native package.
Private: Method, Field can be accessed from the same class to which they belong.

What?s the purpose of Static methods and static variables?

When there is a requirement to share a method or a variable between multiple objects of a class instead of creating separate copies for each object, we use static keywords to make a method or variable shared for all objects.

What is data encapsulation and what?s its significance?

Encapsulation is a concept in Object Oriented Programming for combining properties and methods in a single unit.

Encapsulation helps programmers to follow a modular approach for software development as each object has its own set of methods and variables and serves its functions independent of other objects. Encapsulation also serves the data hiding purpose.

What is a singleton class? Give a practical example of its usage.

Singleton design pattern belongs to the creational family of patterns that governs the instantiation process. This pattern ensures at most one instance of a particular class is ever created in your application. Examples such as:

Project Configuration: A class that reads your project configuration can be made Singleton. By making this singleton, you are allowing global access for all classes in your application. If the project configs are stored in a file, it just reads once and holds on the application cache. You don’t have to read the file multiple times.
Application Log: Logger will be used everywhere in your application. It must be initialized once and used everywhere.
Analytics and Reporting: If you are using some kind of data analysis tool like Google Analytics, you will notice that they are designed to be a singleton. It initializes once and is used everywhere for each user action.

Read more about singleton implementation here.

What is the difference between a continue and break statement?

The break and continue are two important keywords used in the loops. When a break keyword is used in a loop, the loop is broken instantly while when the continue keyword is used, the current iteration is broken and the loop continues with the next iteration.

In the below example, the Loop is broken when the counter reaches 4.

for (counter = 0; counter< 10; counter++)
    system.out.println(counter);

    if (counter == 4) {
        break;
    }
}

In the below example when the counter reaches 4, the loop jumps to the next iteration and any statements after the continue keyword are skipped for the current iteration.

for (counter = 0; counter < 10; counter++)
    system.out.println(counter);
    if (counter == 4) {
        continue;
    }
}

What is the difference between double and float variables in Java?

In java, float takes 4 bytes in memory while Double takes 8 bytes in memory. Float is single-precision floating-point decimal number while Double is a double-precision decimal number.

What is the Final Keyword in Java?

A variable declared with the final keyword is a constant in Java. Value can be assigned only once and after the assignment, the value of a constant can’t be changed.

For example, a constant with the name MAX_LIMIT is declared and assigned value:

private final int MAX_LIMIT=100

When a method is declared as final, it can NOT be overridden by the subclasses. This method is faster than any other method because they are resolved at the complie time.

When a class is declared as final, it cannot be inherited. Example String, Integer, and other wrapper classes.

Can we declare a class as Abstract without having any abstract method?

Yes, we can create an abstract class by using the abstract keywords before the class names even if it doesn’t have any abstract method. However, if a class has even one abstract method, it must be declared as abstract otherwise it will give an error.

What's the difference between an Abstract Class and an Interface in Java?

The primary difference between an abstract class and an interface is that an interface can only possess a declaration of public static methods with no concrete implementation while an abstract class can have members with any access specifiers (public, private, etc) with or without a concrete implementation.

Another key difference in the use of abstract classes and interfaces is that a class that implements an interface must implement all the methods of the interface while a class that inherits from an abstract class doesn’t require the implementation of all the methods of its super class.

A class can implement multiple interfaces but it can extend only one abstract class.

Can we declare the main method of our class as private?

In Java, the main method must be public static in order to run any application correctly. If the main method is declared as private, the developer won’t get any compilation error however, it will not get executed and will give a runtime error.

How we can execute any code even before main method?

If we want to execute any statements before even the creation of objects at the load time of class, we can use a static block of code in the class. Any statements inside this static block of code will get executed once at the time of loading the class even before the creation of objects in the main method.

Originally published at stacktips.com

7 Blogging Mistakes I Wish I Had Known Before I Started

Nilanchal — Sat, 30 Sep 2023 17:12:12 +0000

My personal journey in tech blogging has been a roller coaster ride. I have been blogging ever since I entered the IT industry as a new entrant in 2008. It was driven by the passion for learning new technology and exploring stuff that is contrary to my regular day-to-day job.

So when I was working as an Android application developer, in my personal time I was trying to learn J2EE and Apache Struts. And, I love taking notes along the way while doing small and simple POCs.

At that time there was no application like Notion, so I decided to create a website using Google Blogspot and started capturing all my notes there. Those notes mainly served as a bookmark, so I could refresh my memory whenever I wanted.

Slowly, I started to like writing detailed tutorials and sharing my knowledge which some of my friends, and colleagues loved to read.

And that is how I was introduced to blogging.

But, I never wanted to be a full-time blogger. I never believed I had that spark, which would make my livelihood out of it. That made me a passive blogger.

Now I am running this blog stacktips.com. It is a custom-built site, using Python, Django, and VueJS.

7 Blogging Mistakes I wish I had Known Before

Over the years, I've had my fair share of experiences as a passive blogger, and through trial and error, I've learned valuable lessons that I wish I had known earlier.

In this blog post, I'll share these insights with you, in the hope that they'll help you on your own blogging journey.

This post is probably too long for you. You don't need to spend all your time reading this unless you really want to hear my story.

Let’s cut to the chase:

Content is the king, but consistency is the key to success!
Building a distribution channel is more important than building a great site.
You don't need a perfect domain or perfect site design. No one gives a shit about your domain name or site design as long as you have the X factor in your content.
Understand your niche. Don't try to be a jack of all, you may appear as a jackass.
SEO is the secret weapon. The earlier you realize the better for your site growth.
Engagements are more important than having a larger number of subscribers/followers.
Social media can help you to create the hype but a simple mistake can fuck up your whole strategy. So use it cautiously.

Only, for not-so-busy people:

Nothing new here, but I expand on these above topics.

1. Content is the King, but Consistency is the Key to Success!

Great content is essential for any successful blog, this is a must-have. However, consistency is equally important. You need to strike the right balance between quality and quantity.

As a lone worrier, I used to dedicate a few hours over a weekend to produce 2/3 articles for my blog. But I never realized that we need to be consistent in publishing stories. I used to publish 3/4 articles in a day and then nothing for the rest of the month.

Publishing many articles a day, makes your readers overwhelmed with content so it is very unlikely that all your stories will be read by everyone. But publishing a story on a regular interval, let’s say every Sunday, will definitely drive more engagement, and your readers will love to spend a few minutes reading a story per week.

2. Building a Distribution Channel is More Important than Building a Great Site

Great content is like a hidden treasure, it is worth only when discovered by your readers. Without having an effective distribution strategy no one will ever find what you write.

You need to plan your distribution strategy including content syndication, building email lists, social media groups, etc.

3. You Don't Need a Perfect Domain or Perfect Site Design

Many aspiring bloggers get caught up in the quest for the perfect domain name or website design. While these factors are important, they are not as critical as the quality and uniqueness of your content.

4. Understand Your Niche

Trying to cover too many topics can dilute your blog's identity and make you appear unfocused. Find out why it's crucial to understand your niche and become an authority in it.

5. SEO is the Secret Weapon

Search Engine Optimization (SEO) can be a game-changer for your blog's growth and to drive organic traffic to your blog. While SEO strategy might sound easy when you Google these topics, there is a vast amount of science behind it.

Some of these include:

Having a catchy page title (not clickbait) and page description.
Maintain a structural hierarchy of your content on the page
Canonical and SEO-friendly page links
Backlinks and building trustworthiness
Page loading speed
Image and video annotations and structured content markup
Submit the site to search engines

These are just a few of these SEO strategies to start with.

6. Engagements are More Important than a Large Number of Subscribers/Followers

It's not just about the numbers. Don't always throw your stuff, expand your social posts to other stuff including a photo from your pub night or day out with your kids. People love to connect with humans more than a BOT🤖.

Engaging with your audience, building a community, and nurturing relationships can be more valuable than having a massive but passive following.

7. Social Media: Hype and Caution

Social media can be a double-edged sword. Learn how to leverage its potential to create excitement around your blog while avoiding common pitfalls that can harm your strategy.
In Summary,

I am not a very successful blogger. I never made direct money out of my blogging. However, blogging enabled me to expand my horizons and build connections. Using my blogging connections I have published books, built projects, and earned sufficient money to call out “My Blogging Journey has been Worthwhile!”.

Happy blogging!

Getting Started with Spring Boot: A Beginner’s Guide

Nilanchal — Mon, 18 Sep 2023 14:06:16 +0000

What is Spring Boot?

Spring Boot is a popular, open-source, enterprise-level framework for creating standalone, production-grade applications that run on the Java Virtual Machine (JVM).

It requires minimal or zero configuration and is easy to get started. It is a widely popular choice among Java developers for developing MicroServices and web applications.

Spring boot is built on top of the popular Spring Framework and inherits features like dependency injection(DI) or Inversion of Control (IoC) from the Spring.

It offers built-in support for typical tasks that an application needs to perform, such as data binding, type conversion, validation, exception handling, resource and event management, internationalization, and more.

👇Chapter-1 video course(more chapters dropping)👇

What we can do with Spring Boot?

Spring Boot framework provides several features that make it ideal for building a variety of applications, including:

Web applications: You can create simple to complex multi-tier web applications
RESTful APIs: Spring Boot makes it easy to create RESTful APIs to expose your data and functionality to other applications.
Microservices: Widely used choice for building small, independent services that can be easily scaled and deployed.
Batch processing: You can build a Spring batch application that can process large volumes of data in a scheduled or event-driven manner.
Command line applications: Spring Boot also can be used to build applications that run on the command line.

Key Features of Spring Boot

Some of the key features of the Spring Boot framework are:

Auto-configuration
Dependency Injection (DI)
Spring Boot Starter Dependencies
Embedded Server
Production-ready features

Auto Configuration

Spring Boot applications are initialized with pre-set dependencies so you don’t have to configure the underlying Spring Framework and third-party packages manually for your application.

This helps developers to reduce the number of errors caused due to misconfiguration and makes them more productive.

Dependency Injection

Dependency Injection is one of the core features of the Spring framework. This allows developers to write loosely coupled code that is easy to maintain and test.

Dependency Injection (DI) is a software design pattern used in object-oriented programming, where the dependencies of a class are provided by an external entity rather than being created within the class itself.

In other words, instead of a class creating its dependencies, those dependencies are "injected" into the class from outside.

Spring Boot Starter Dependencies

Dependency management is one of the critical parts of any project development. Managing this manually is very cumbersome and error-prone. Spring Boot provides us with several Spring Boot starter packages to address this problem.

There are two types of dependencies:

Direct: These are dependencies defined in your pom.xml or build.gradle file under the dependencies section.
Transitive: These are dependencies that are dependencies of your direct dependencies.

For example, if we add the spring-boot-starter-web as a dependency to your pom.xml file then will download spring-boot-starter-tomcat as the direct dependency and with that, it will also download the other transitive dependencies like tomcat-embedded-core and tomcat-embedded-el and tomcat-embedded-websocket

If you’re managing the dependencies manually, then you must be very careful about the specific version of the dependency you are using and also need to worry about their compatibility with each other.

The built-in Spring Boot starters help you to simplify the build configuration and make the development very rapid and easy.

Starter dependencies are a set of convenient dependency descriptors that we can use to bootstrap our Spring boot applications. The Spring Boot starters contain a lot of pre-defined dependencies with a supported set of transitive dependencies.

Spring Boot starters follow a similar naming pattern, e.g. spring-boot-starter-XYZ, where XYZ denotes a particular type of application.

Here are some of the popular Spring Boot starter packages:

spring-boot-starter-web: It is used for building web applications, including RESTful applications using Spring MVC. It uses Tomcat as the default embedded container.
spring-boot-starter-activemq: It is used in JMS messaging using Apache ActiveMQ.
spring-boot-starter-actuator: Provides production-ready features such as health checks, monitoring, and other application management features.
spring-boot-starter-batch: It is used for the Spring Batch.
spring-boot-starter-cache: It is used for Spring Framework's caching support.
spring-boot-starter-data-jpa: It is used for Spring Data JPA with Hibernate.
spring-boot-starter-data-mongodb: It is used for MongoDB document-oriented database and Spring Data MongoDB.
spring-boot-starter-mail: It is used to support Java Mail and Spring Framework's email sending.

Embedded Servers

Spring Boot includes support for embedded Tomcat, Jetty and Undertow servers. This means you don’t need any external web servers and no need to deploy WAR files anymore.

The embedded Tomcat server is available through the spring-boot-starter-web dependency.

However, if you want Jetty or Undertow servers then you can include spring-boot-starter-jetty or spring-boot-starter-undertow dependencies.

Production Ready Features

Spring Boot Framework includes production-ready features such as metrics, health checks, and external configuration management. Spring Boot also provides integration with various enterprise technologies such as RMI, JPA and JMS, AMQP, etc.

RMI
Hibernate
WebSocket API (JSR 356)
AMQP - Advanced Message Queuing Protocol
Java Web Services
JPA () - Java Persistence API
JMS

Spring also provides a Model-View-Controller (MVC) framework that simplifies the development of web applications by separating the presentation layer from the business logic.

It also provides a number of tools and frameworks for testing applications, including the Spring Test Framework and the Spring MVC Test Framework.

Spring Boot vs. Spring: What Works for You?

Ultimately, the best framework for you will depend on your specific requirements. If you are not sure which framework to choose, I recommend starting with Spring Boot.

Features	Spring	Spring Boot
Source type	It is an open-source framework.	It is built on top of a spring.
Core features	Dependency injection	Auto-configuration is an essential feature.
Deployment	The server is set explicitly for spring. The deployment descriptor is required.	Embedded servers are provided. The deployment descriptor is not required.
Use cases	Good for complex applications.	Good for rapid application development
Setup time	It takes more time to set up.	Faster to set up.

Spring Boot is a great choice to get started with Spring development without having to worry about the complexities of the Spring Framework. Once you understand Spring better, you can decide if you need the additional features and flexibility of the Spring Framework.

Originally published at stacktips.com

Hit 1000 followers on DEV 🎉 🎉 🎉

Nilanchal — Wed, 23 Aug 2023 15:53:52 +0000

Woohoo!

I have hit 1000 followers in DEV.to today 🎉. Thank you for your interest in my articles!

I will try to write more articles, tutorials in dev.to and add value to the community.

Thank you all💖🙏

Getting Started with Maven: A Beginner's Guide to Java Build Automation

Nilanchal — Mon, 21 Aug 2023 22:39:41 +0000

Maven is a popular build automation tool used primarily for Java projects. It is designed to manage a project's build process, including the managing dependencies, packaging, deployment and generating reports.

Maven uses an XML file called a Project Object Model pom.xml to define the project's configuration, including its dependencies, plugins, and other settings.

The POM file is typically stored in the project's root directory.

Why Use Maven?

Maven is a popular build tool for Java projects that provides a number of benefits, including:

Dependency management: Maven makes it easy to manage dependencies for your project, including downloading and including libraries from remote repositories.
Build automation: Maven automates the build process, including compiling the code, running tests, and packaging the application into a distributable format.
Consistent project structure: Maven provides a standard project structure that makes it easy to organize your code and resources.
Plugin system: Maven has a powerful plugin system that can be used to extend the functionality of the build process, such as generating documentation or deploying the application to a server.
Easy project setup: Maven provides archetypes that can be used to quickly set up a new project with a predefined structure and dependencies.
Reproducible builds: Maven provides a way to create reproducible builds, which means that the build process is consistent across different machines and environments.
Integration with IDEs: Maven integrates with popular Java IDEs, such as Eclipse and IntelliJ, making it easy to import and work with Maven projects.

Overall, Maven can help improve the productivity of developers and make it easier to manage complex Java projects by automating common tasks and providing a standardized way to structure and build projects.

Project Identifiers in Maven?

Maven projects are identified by 3 main identifiers/coordinates:

Group Id: Unique identifier for the organization. Typically, this is a reversed domain name.
Artifact Id: Used to generate the build (JAR /WAR) files.
Version: A version number e.g 1.0.0

Maven Repositories

Maven uses a centralised repository to manage project dependencies. The Maven Repository is divided into three types: Local, Central and Remote.

1. Maven Local Repository
The local repository is a directory on the developer's machine where all the dependencies for a specific project are stored.

The local repository in Maven is usually located in the user's home directory under the .m2 folder.

2. Central Maven Repository
The Central Repository is the default remote repository used by Maven.

It contains a vast collection of open-source libraries and dependencies, making it a one-stop shop for most projects. When Maven needs to download a dependency, it first looks in the local repository and then in the Central Repository.

The central maven repository is managed by Sonatype. There are almost all java libraries that exist in it.

When building a project, if it can not find any dependent jars in the local maven repository it will search in the central maven repository and download those JARs if found. You can also search for an artifact in central.sonatype.com if you want to download the artifact’s pom or jars.

To search/browse in the central repository you can use: central.sonatype.com

3. Remote Repository is a repository of dependencies located on a remote server, typically managed by third party organizations.

Here's an example of how to use a remote Maven repository in a Java project:

<repositories>
    <repository>
        <id>reporitory-id</id>
        <name>Repository Name</name>
        <url>your remote repository url</url>
    </repository>
</repositories>

For every dependency defined in pom.xml file, it first search dependency in the local repository, followed by the remote repositories in the same order as defined in the pom.xml file.

If the dependency is not found in any of the remote repositories, Maven reports a build error.

Creating Maven Java Project using CommandLine

Create a new project directory: Create a new directory for your project. For example, you can create a directory called "my-maven-project".

mkdir my-maven-project

Navigate to the project directory: Navigate to the newly created directory.

cd my-maven-project

Create a new Maven project: Create a new Maven project using the mvn archetype:generate command. This command generates a new Maven project based on a template or archetype.

mvn archetype:generate 
    -DgroupId=com.example.app 
    -DartifactId=my-app 
    -DarchetypeArtifactId=maven-archetype-quickstart 
    -DinteractiveMode=false

By the way, you don’t have to remember each of these parameters provided above. Just use the interactiveMode=true, so that Maven asks for all the required parameters.

In this command, the groupId and artifactId are the unique identifiers for your project. The archetypeArtifactId specifies the archetype to use, which in this case is the maven-archetype-quickstart archetype, which creates a simple Java project with a main class.

Learn more about Maven build process, repository and build profiling here.

c01-Introduction to Maven

c02-Install and configure Maven on Windows

c03-Install and configure Maven on macOS?

c04-Maven Repository Introduction

c05-Creating Maven Java Project using CommandLine

c06-Understanding Maven Project and Dependencies

c07-Maven Build Lifecycles

c08-Popular Maven Commands

c09-Working with Profiles in Maven

Conclusion and Wrap Up

Whether you're a beginner or an experienced developer, this articles will help you to up to speed with Maven.