DEV Community: Ashutosh Dubey

Java Factory Pattern with example Explained

Ashutosh Dubey — Sat, 17 Dec 2022 12:53:02 +0000

Introduction

The factory pattern is a creational design pattern in Java that provides an interface for creating objects in a super class, but allows subclasses to alter the type of objects that will be created.

One of the main benefits of using the factory pattern is that it allows for the creation of objects without the client specifying the exact class of object that will be created. This is useful when the client does not need to know the implementation details of the objects being created, or when there is the possibility of adding new types of objects in the future.

To implement the factory pattern in Java, you need to create a factory interface and concrete classes that implement the interface. The factory interface should have a method for creating objects, which will be implemented by the concrete classes.

Example

For example, consider a simple application that allows users to create and customize their own cars. The application has three types of cars: sedan, hatchback, and SUV. We can implement the factory pattern by creating a CarFactory interface with a createCar() method, and concrete classes SedanFactory, HatchbackFactory, and SUVFactory that implement the CarFactory interface and create specific types of cars.

public interface CarFactory {
    public Car createCar();
}

public class SedanFactory implements CarFactory {
    public Car createCar() {
        return new Sedan();
    }
}

public class HatchbackFactory implements CarFactory {
    public Car createCar() {
        return new Hatchback();
    }
}

public class SUVFactory implements CarFactory {
    public Car createCar() {
        return new SUV();
    }
}

To use the factory pattern, the client can simply create an instance of the appropriate factory and call the createCar() method to create a new car. For example:

CarFactory factory = new SedanFactory();
Car car = factory.createCar();

This allows the client to create a sedan without having to specify the exact class of the object that will be created. If the application needs to support additional types of cars in the future, all that is required is to create a new factory class that implements the CarFactory interface.

Conclusion

The factory pattern is a useful way to create objects in a flexible and extensible manner, and is particularly useful when the exact type of object to be created is not known at compile-time. It can also help to reduce the coupling between the client and the implementation classes of the objects being created.

What is singleton class in Java and how to implement it?

Ashutosh Dubey — Tue, 13 Dec 2022 06:52:10 +0000

Introduction

A singleton class in Java is a type of class that can have only one instance at any given time. This is useful in ensuring that only one object of a particular class is ever created and used in an application, avoiding duplication of resources and improving performance.

How to Implement Singleton Class??

To implement a singleton class in Java, you need to make the class constructor private, so that no other class can create its own instance. You also need to declare a static instance of the class and initialize it in a static block. Finally, you need to create a public static method that returns the singleton instance.

To illustrate this, let's say we want to create a singleton class called Logger that logs messages to the console.
First, we'll make the class constructor private so that no other class can create its own instance:

private Logger() {

}

Next, we'll declare a static instance of the class and initialize it in a static block:

private static Logger instance = null;

static {
    instance = new Logger();
}

Finally, we'll create a public static method that returns the singleton instance:

public static Logger getInstance() {
    return instance;
}

Now we can use the Logger class to log messages to the console. All other classes will be able to access the same instance of the Logger class, ensuring that no duplicate instances are created.

Conclusion

By using the singleton pattern, developers can ensure that only one instance of a particular class is ever created and used in an application, avoiding duplication of resources and improving performance.

Creating a simple CRUD app on Spring Boot using H2, Hibernate

Ashutosh Dubey — Mon, 12 Dec 2022 20:48:30 +0000

Introduction

Creating a CRUD (Create, Read, Update, Delete) application on Spring Boot using H2, Hibernate is a great way to quickly develop a powerful and efficient web application. In this tutorial, we will walk through the steps of creating a simple CRUD application on Spring Boot using H2, Hibernate.

Prerequisites

Before starting this tutorial, you should have the following installed:

Java 8 or higher
Apache Maven 3.x
Eclipse IDE

You should also have a basic understanding of the Spring Boot framework and the H2 and Hibernate databases.

Step 1: Create a Spring Boot Project

The first step to creating a CRUD application on Spring Boot using H2, Hibernate is to create a Spring Boot project. To do this, open the Eclipse IDE and select “File > New > Spring Starter Project” from the menu bar.

In the next window, enter a project name, choose the language as Java, and select the Spring Boot version. Then, click “Next”.

On the next screen, select the dependencies for your project. For this tutorial, we will choose “Web”, “H2 Database”, and “JPA (Hibernate)”. Click “Finish” to create the project.

Step 2: Create the Database Tables

Now that we have our project created, we need to create the database tables. To do this, open the “application.properties” file located in the “src/main/resources” folder.

In this file, we will set the database URL, username, and password. For this tutorial, we will use “jdbc:h2:mem:testdb” as the database URL. Set the username and password as “sa”.

Next, we will create the database tables. To do this, create a new file called “schema.sql” in the “src/main/resources” folder. In this file, we will write the SQL code to create the database tables. For example:

CREATE TABLE users ( 
  id INTEGER PRIMARY KEY, 
  name VARCHAR(255), 
  email VARCHAR(255)
);

CREATE TABLE posts ( 
  id INTEGER PRIMARY KEY, 
  title VARCHAR(255), 
  content VARCHAR(255)
);

Step 3: Create the Entity Classes

The next step is to create the entity classes. These classes will be used to map the database tables to Java objects.

Create a new package called “entities” in the “src/main/java” folder. In this package, create two classes called “User” and “Post”.

For the User class, add the following code:

@Entity
public class User {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  private String name;
  private String email;

  // Getters and setters

}

For the Post class, add the following code:

@Entity
public class Post {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  private String title;
  private String content;

  // Getters and setters

}

Step 4: Create the Repository Classes

The next step is to create the repository classes. These classes will be used to access the database and perform CRUD operations.

Create a new package called “repositories” in the “src/main/java” folder. In this package, create two classes called “UserRepository” and “PostRepository”.

For the UserRepository class, add the following code:

@Repository
public interface UserRepository extends JpaRepository<User, Long> {

}

For the PostRepository class, add the following code:

@Repository
public interface PostRepository extends JpaRepository<Post, Long> {

}

Step 5: Create the Service Classes

The next step is to create the service classes. These classes will be used to manage the data and perform operations.

Create a new package called “services” in the “src/main/java” folder. In this package, create two classes called “UserService” and “PostService”.

For the UserService class, add the following code:

@Service
public class UserService {

  @Autowired
  private UserRepository userRepository;

  public List<User> getAllUsers() {
    return userRepository.findAll();
  }

  public User getUserById(Long id) {
    return userRepository.findById(id).get();
  }

  public User createUser(String name, String email) {
    User user = new User();
    user.setName(name);
    user.setEmail(email);
    return userRepository.save(user);
  }

  public User updateUser(Long id, String name, String email) {
    User user = userRepository.findById(id).get();
    user.setName(name);
    user.setEmail(email);
    return userRepository.save(user);
  }

  public void deleteUser(Long id) {
    userRepository.deleteById(id);
  }

}

For the PostService class, add the following code:

@Service
public class PostService {

  @Autowired
  private PostRepository postRepository;

  public List<Post> getAllPosts() {
    return postRepository.findAll();
  }

  public Post getPostById(Long id) {
    return postRepository.findById(id).get();
  }

  public Post createPost(String title, String content) {
    Post post = new Post();
    post.setTitle(title);
    post.setContent(content);
    return postRepository.save(post);
  }

  public Post updatePost(Long id, String title, String content) {
    Post post = postRepository.findById(id).get();
    post.setTitle(title);
    post.setContent(content);
    return postRepository.save(post);
  }

  public void deletePost(Long id) {
    postRepository.deleteById(id);
  }

}

Step 6: Create the Controller Classes

The final step is to create the controller classes. These classes will be used to map the requests to the service classes.

Create a new package called “controllers” in the “src/main/java” folder. In this package, create two classes called “UserController” and “PostController”.

For the UserController class, add the following code:

@RestController
@RequestMapping("/users")
public class UserController {

  @Autowired
  private UserService userService;

  @GetMapping
  public List<User> getAllUsers() {
    return userService.getAllUsers();
  }

  @GetMapping("/{id}")
  public User getUserById(@PathVariable Long id) {
    return userService.getUserById(id);
  }

  @PostMapping
  public User createUser(@RequestBody User user) {
    return userService.createUser(user.getName(), user.getEmail());
  }

  @PutMapping("/{id}")
  public User updateUser(@PathVariable Long id, @RequestBody User user) {
    return userService.updateUser(id, user.getName(), user.getEmail());
  }

  @DeleteMapping("/{id}")
  public void deleteUser(@PathVariable Long id) {
    userService.deleteUser(id);
  }

}

For the PostController class, add the following code:

`@RestController
@RequestMapping("/posts")
public class PostController {

  @Autowired
  private PostService postService;

  @GetMapping
  public List<Post> getAllPosts() {
    return postService.getAllPosts();
  }

  @GetMapping("/{id}")
  public Post getPostById(@PathVariable Long id) {
    return postService.getPostById(id);
  }

  @PostMapping
  public Post createPost(@RequestBody Post post) {
    return postService.createPost(post.getTitle(), post.getContent());
  }

  @PutMapping("/{id}")
  public Post updatePost(@PathVariable Long id, @RequestBody Post post) {
    return postService.updatePost(id, post.getTitle(), post.getContent());
  }

  @DeleteMapping("/{id}")
  public void deletePost(@PathVariable Long id) {
    postService.deletePost(id);
  }

}`

Conclusion

In this tutorial, we have walked through the steps of creating a simple CRUD application on Spring Boot using H2, Hibernate. We have created our project, created the database tables, created the entity classes, created the repository classes, created the service classes, and created the controller classes.

With this application, we can now easily create, read, update, and delete data using the H2 and Hibernate databases.

5 projects to learn Spring Boot as a Beginner

Ashutosh Dubey — Mon, 12 Dec 2022 20:38:48 +0000

Are you a budding coder interested in learning the beloved Spring Boot? It’s a great idea to learn the popular framework that is used by many large enterprises today. It’s a particularly useful framework for Java developers and can help you create stand-alone applications quickly and easily.

If you’re a beginner to Spring Boot, there are some great projects that you can take on to help you become more familiar with the framework. Here are five great projects to get you started:

1. Create a Simple Spring Boot Application. This is a great project for beginners to start with as it will help you get familiar with the basics of the framework. You’ll be able to learn the basics such as setting up a web application, configuring databases and more.

2. Build a RESTful Web Service. This project will teach you how to create a web service using the Spring Boot framework. You’ll learn how to define endpoints and how to communicate with them using the HTTP protocol.

3. Work with Spring Boot Security. This project will help you learn how to secure your application using Spring Boot. You’ll learn how to configure authentication and authorization, as well as how to use Spring Security to protect your application.

4. Create a Spring Boot Microservice. This project will introduce you to the world of microservices and how to use them in your application. You’ll learn how to build a simple microservice using the Spring Boot framework, as well as how to deploy it to a cloud provider.

5. Build an Event-Driven Application. This project will teach you the basics of event-driven architecture and how to use it with Spring Boot. You’ll learn how to create an event-driven application that can respond to events and take appropriate actions.

These five projects are great for getting started with Spring Boot. They will help you become more familiar with the framework and get you ready to start building real-world applications with it. Good luck on your coding journey!

No, File Name and Class Name do NOT need to be same in Java. Here’s How.

Ashutosh Dubey — Thu, 05 Aug 2021 08:27:08 +0000

The very first thing I was told in my java class was that the names of the .java file and the Class in java need to be same. But soon I learned it is actually a good practice to do so, but not mandatory at all.
Let us create a simple Hello world Java program.

class Main{
    public static void main(String[] args){
        System.out.println("Hello World");
        }
}

Save the file as “Hello.java” (Class name is Main).
Now, open your terminal and give command to compile as you would normally:
javac Hello.java
and then when you want to execute, instead of typing:
java Hello
we need to type:
java Main
As you would see, our program got executed easily.

🔴🚫EDIT🔴🚫 - As mentioned by @wldomiciano, if you declare the class as public, then it is mandatory to name both the class and file name exactly same.

Conclusion

At the time of execution, we just need to mention class name. Therefore, it is always advised to name the file and class alike, to not create any confusion. But as you saw, it is not a mandatory thing.

Answer Questions and Earn Money on Chegg

Ashutosh Dubey — Thu, 24 Dec 2020 18:54:47 +0000

In this article I will show you how to apply for a Q&A expert on Chegg and start earning some money.
This article is about how you your knowledge in a subject can lead you to earn some money.

What is Chegg?

Chegg is an website where students can ask questions and get their answers written by an expert. This is where we come in.
We have to answer the question and can make money for each question that we answer.
The money per question can vary, but in India on an average you can get around ₹150 for each question, which is around 2$.

How To Apply

Prerequisite -

You should be a undergraduate student or have a undergraduate degree.
Should have intermediate knowledge of the subject.

Step 1: Go to experthiring.cheggindia.com

Step 2: Signup and accept the guidelines.

Step 3: Now proceed for Registration.

Note:
The subject you choose in registration is final
and cannot be changed, and you will be asked questions on that subject.
So makeup your mind in advance,
and then head for registration.

Step 4: After completing registration, attempt the test.
Some Notes about the test:

It has no time limit. Take your time and complete it.
They will e-mail you the passing criteria.(It was 50% for me).
There are around 10-12 questions in the test.
The questions are not very hard, but they do test your basic understanding.

Step 5: After the test, DO READ THE GUIDELINES. And only then attempt the guidelines test. It is an easy one but do read the guidelines once. Around 20 questions were asked from me.

Conclusion

After completing the guidelines test, submit all the asked documents and then wait for their email. I got it in 1 day. It will mention the date you can start answering the questions. I applied on December and got the date for February.
So apply fast, because the seats are limited.