DEV Community: Ajinkya. Shivpure

Building User Authentication in Spring Boot: From Signup to Login

Ajinkya. Shivpure — Tue, 11 Feb 2025 16:49:55 +0000

After setting up our first Spring Boot project (check my previous post!), let's add user authentication. I'll show you how I implemented signup and login functionality using Spring Boot's layered architecture.

Project Structure:

Now , as a beginner even keeping a proper structure for your project can be difficult . create proper packages and classes. here is the project structure you should use :

1.The User Entity:

(we created this earlier as well ):
this user entity class stores all the attributes of a user like name , email and password .

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String name;

    @Column(unique = true, nullable = false)
    private String email;

    @Column(nullable = false)
    private String password;  // Will be stored encoded
}

2. User Repository:

Refer the above diagram for better clarification . the database layer is basically the repository . here , the user repository is responsible for connecting with our my sql database . it has complete access to the user table . we are using the JpaRepository for some built in features .

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
    Boolean existsByEmail(String email);
}

3. DTOs - for request and response

we use this for convenience. you will understand as you proceed.

public class SignupRequest {
    private String name;
    private String email;
    private String password;
    // getters, setters
}

public class LoginRequest {
    private String email;
    private String password;
    // getters, setters
}

4. Auth Service :

the work of the service layer is to receive request from api layer , process that request. the api layer does not communicate with the data access layers directly . see the api controller layer further below , it just contains certain endpoints then in each method , it calls the methods in service layer .
we create a repository object in services and service object in controllers . that's how it works!
I am not explaining much from this code , most of this is basic to moderate Java .

@Service
@Transactional
public class AuthService {
    @Autowired
    private UserRepository userRepository;

    @Autowired
    private PasswordEncoder passwordEncoder;

    public User signup(SignupRequest request) {
        // Check if user exists
        if (userRepository.existsByEmail(request.getEmail())) {
            throw new RuntimeException("Email already registered");
        }

        // Create new user
        User user = new User();
        user.setName(request.getName());
        user.setEmail(request.getEmail());
        user.setPassword(passwordEncoder.encode(request.getPassword()));

        return userRepository.save(user);
    }

    public User login(LoginRequest request) {
        User user = userRepository.findByEmail(request.getEmail())
            .orElseThrow(() -> new RuntimeException("User not found"));

        if (!passwordEncoder.matches(request.getPassword(), user.getPassword())) {
            throw new RuntimeException("Invalid password");
        }

        return user;
    }
}

@ Autowired makes the work easier , instead of initiating the object in constructor just use the annotation @autowired , it automatically tells springboot what we need .

5. Auth Controller :

let me explain the important key components :
@RequestMapping: it tells that all the requests will be sent on "/api/auth" . you can customise it . the default path for requests is
http://localhost:8080/api/auth . by requests , I mean the ones from frontend .
@PostMapping:
it tells that the tor of request is the post request , that is some data is going to be submitted to the repository . now , the complete path becomes
http://localhost:8080/api/auth/signup for sign up and so on

@RestController
@RequestMapping("/api/auth")
public class AuthController {
    @Autowired
    private AuthService authService;

    @PostMapping("/signup")
    public ResponseEntity<?> signup(@RequestBody SignupRequest request) {
        try {
            User user = authService.signup(request);
            return ResponseEntity.ok("User registered successfully");
        } catch (Exception e) {
            return ResponseEntity.badRequest().body(e.getMessage());
        }
    }

    @PostMapping("/login")
    public ResponseEntity<?> login(@RequestBody LoginRequest request) {
        try {
            User user = authService.login(request);
            return ResponseEntity.ok("Login successful");
        } catch (Exception e) {
            return ResponseEntity.badRequest().body(e.getMessage());
        }
    }
}

Key Learning Points:

Always encode passwords before storing.
Use DTOs to handle request/response data.
Implement proper validation and error handling.
Follow separation of concerns (Controller → Service → Repository).

Now , we need to test these apis. I use postman for this purpose . I will recommend for all of you to go with it .

PostMan testing:

the following image should be enough .

Coming Up Next:

Adding JWT token authentication
Implementing role-based authorization

springboot #java #security #authentication #webdev

Getting Started with Spring Boot: A Beginner's Journey

Ajinkya. Shivpure — Sun, 09 Feb 2025 17:43:27 +0000

As a Java developer starting my journey with Spring Boot, I want to share my experience setting up my first project. This guide will walk you through the essential steps, from project creation to implementing your first entity.

Why I Chose Spring Boot?
Spring Boot simplifies the development of stand-alone, production-grade Spring applications. It takes an opinionated view of the Spring platform, which means less boilerplate code and faster development.

Prerequisites:

1.)JDK 23
2.)IntelliJ IDEA Ultimate Edition - I used student membership
3.)Basic understanding of Java like basic syntax, if -else loops,oops concepts..etc
4.)MySQL installed on your system

Creating Your First Project

Step 1: Using Spring Initializer

Navigate to start.spring.io
Configure your project:

Project: Maven
Language: Java
Spring Boot Version: 3.4.2 (Latest Stable Version) as of now .
Group: com.example
Artifact: demo
Packaging: Jar
Java Version: 23

Step 2: Adding Essential Dependencies
I added these dependencies for a basic web application with database support:

Spring Web: For building RESTful applications
Spring Data JPA: For database operations
MySQL Driver: To connect with MySQL database
Spring Security: For authentication and authorization (optional)

Pro tip: Hover over each dependency in Spring Initializer to understand its purpose!

Understanding Project Structure

The pom.xml File
The pom.xml is your project's configuration file. Here's what mine looked like:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0">
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>
</project>

Configuring application.properties

This file contains your application's configuration. Here's my basic setup for MySQL:

spring.datasource.url=jdbc:mysql://localhost:3306/your_database_name
spring.datasource.username=your_username
spring.datasource.password=your_password
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

Creating Your First Entity

I created a simple User entity:

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @Column(unique = true)
    private String email;

    private String password;

    // Getters and Setters
}

Key Points About the Entity:

1.@Entity: Marks this class as a JPA entity.
2.@Table: Specifies the table name in database.
3.@id: Marks the primary key
4.@GeneratedValue: Configures auto-increment
5.@column(unique = true): Ensures email uniqueness

Running the Application:

1.Open the project in IntelliJ IDEA
2.Wait for Maven to download dependencies
3.Run the main application class (has 4.@SpringBootApplication annotation)
5.Check the console for "Started Application" message

Common Issues I Faced:

1.Database connection errors: Double-check your MySQL service is running
2.Port conflicts: Default port is 8080, change it in application.properties if needed
3.Maven dependencies not downloading: Check your internet connection and Maven settings. reload the project . IntelliJ basically will help you in such things .

Next Steps:

Create a Repository interface for database operations
Build REST controllers
Add service layer business logic
Implement basic CRUD operations

Conclusion

Setting up a Spring Boot project might seem overwhelming at first, but once you understand the basic structure, it becomes much clearer. In my next post, I'll cover how to implement CRUD operations with our User entity.
Happy coding!

Follow me for more Spring Boot tutorials and Java development insights!

java #springboot #programming #webdevelopment #tutorial