Forem: DrSimple

Spring Shell

DrSimple — Wed, 25 Mar 2026 15:17:36 +0000

Track my expense using Spring Shell

Spring Shell is a framework for building interactive command-line applications in Spring Boot. It lets you define commands using annotations, process user input, and display results in a structured way. It’s useful for admin tools, automation scripts, and internal developer CLIs with features like tab completion and command history.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.5.12</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.grazaclee</groupId>
    <artifactId>jonzy</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>jonzy</name>
    <description>jonzy</description>
    <url/>
    <licenses>
        <license/>
    </licenses>
    <developers>
        <developer/>
    </developers>
    <scm>
        <connection/>
        <developerConnection/>
        <tag/>
        <url/>
    </scm>
    <properties>
        <java.version>17</java.version>
        <spring-shell.version>3.4.1</spring-shell.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.shell</groupId>
            <artifactId>spring-shell-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.shell</groupId>
            <artifactId>spring-shell-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.shell</groupId>
                <artifactId>spring-shell-dependencies</artifactId>
                <version>${spring-shell.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <annotationProcessorPaths>
                        <path>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </path>
                    </annotationProcessorPaths>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

expense-cli/
├── src/main/java/com/example/expensecli/
│   ├── controller/
│   │   └── ExpenseController.java
│   ├── model/
│   │   └── Expense.java
│   ├── repository/
│   │   └── ExpenseRepository.java
│   ├── service/
│   │   └── ExpenseService.java
│   ├── utils/
│   │   └── DBConnection.java
│   └── ExpenseCliApplication.java
└── pom.xml


<dependencies>
    <!-- Spring Boot -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>

    <!-- Spring Shell -->
    <dependency>
        <groupId>org.springframework.shell</groupId>
        <artifactId>spring-shell-starter</artifactId>
    </dependency>

    <!-- JDBC -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>

    <!-- MySQL Driver -->
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
    </dependency>

    <!-- Lombok (optional) -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

DB Config (application.properties)

spring.datasource.url=jdbc:mysql://localhost:3306/expense_db
spring.datasource.username=root
spring.datasource.password=your_password
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

Model

package com.example.expensecli.model;

public class Expense {
    private int id;
    private String title;
    private double amount;

    public Expense() {}

    public Expense(int id, String title, double amount) {
        this.id = id;
        this.title = title;
        this.amount = amount;
    }

    public Expense(String title, double amount) {
        this.title = title;
        this.amount = amount;
    }

    // getters & setters
}

Repository (JDBC)

package com.example.expensecli.repository;

import com.example.expensecli.model.Expense;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public class ExpenseRepository {

    private final JdbcTemplate jdbc;

    public ExpenseRepository(JdbcTemplate jdbc) {
        this.jdbc = jdbc;
    }

    public void save(Expense expense) {
        jdbc.update("INSERT INTO expenses(title, amount) VALUES (?, ?)",
                expense.getTitle(), expense.getAmount());
    }

    public List<Expense> findAll() {
        return jdbc.query("SELECT * FROM expenses",
                (rs, rowNum) -> new Expense(
                        rs.getInt("id"),
                        rs.getString("title"),
                        rs.getDouble("amount")
                ));
    }

    public Expense findById(int id) {
        return jdbc.queryForObject("SELECT * FROM expenses WHERE id = ?",
                (rs, rowNum) -> new Expense(
                        rs.getInt("id"),
                        rs.getString("title"),
                        rs.getDouble("amount")
                ), id);
    }

    public void update(int id, String title, double amount) {
        jdbc.update("UPDATE expenses SET title=?, amount=? WHERE id=?",
                title, amount, id);
    }

    public void delete(int id) {
        jdbc.update("DELETE FROM expenses WHERE id=?", id);
    }
}

Service

package com.example.expensecli.service;

import com.example.expensecli.model.Expense;
import com.example.expensecli.repository.ExpenseRepository;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class ExpenseService {

    private final ExpenseRepository repo;

    public ExpenseService(ExpenseRepository repo) {
        this.repo = repo;
    }

    public void addExpense(String title, double amount) {
        repo.save(new Expense(title, amount));
    }

    public List<Expense> getAll() {
        return repo.findAll();
    }

    public Expense getById(int id) {
        return repo.findById(id);
    }

    public void updateExpense(int id, String title, double amount) {
        repo.update(id, title, amount);
    }

    public void deleteExpense(int id) {
        repo.delete(id);
    }
}

Controller (Spring Shell CLI)

package com.example.expensecli.controller;

import com.example.expensecli.model.Expense;
import com.example.expensecli.service.ExpenseService;
import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;

import java.util.List;

@ShellComponent
public class ExpenseController {

    private final ExpenseService service;

    public ExpenseController(ExpenseService service) {
        this.service = service;
    }

    @ShellMethod("Add new expense")
    public String add(String title, double amount) {
        service.addExpense(title, amount);
        return "Expense added!";
    }

    @ShellMethod("List all expenses")
    public List<Expense> list() {
        return service.getAll();
    }

    @ShellMethod("Get expense by ID")
    public Expense get(int id) {
        return service.getById(id);
    }

    @ShellMethod("Update expense")
    public String update(int id, String title, double amount) {
        service.updateExpense(id, title, amount);
        return "Updated!";
    }

    @ShellMethod("Delete expense")
    public String delete(int id) {
        service.deleteExpense(id);
        return "Deleted!";
    }
}

Main app

package com.example.expensecli;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

Database Table

CREATE TABLE expenses (
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(255),
    amount DOUBLE
);

CLI Usage

shell:>add "Food" 200
shell:>list
shell:>get 1
shell:>update 1 "Transport" 150
shell:>delete 1

Java Security

DrSimple — Tue, 10 Mar 2026 10:35:39 +0000

JWT json web token - used for authentication
instead of storing login sessions on the server, the client sends token with every request

flow

User Login -> Server verifies credentials -> Server creates JWT -> Clients stores JWT
Client sends JWT in request -> Server verifies and grants access

Authorization: Bearer token

Jwt structure

HEADER.PAYLOAD.SIGNATURE jwt.io

Header contains algorithm:
{
"alg":"HS256"
"typ":"JWT"
}

payload :
{
"sub":"a@c.com",
"iat":"8765456,
"exp":98765456
}

Signature: created using a scret key

Simplified flow in Spring security

SPRING SECURITY + JWT AUTHENTICATION FLOW
=========================================

JWT (JSON Web Token)
Used for authentication in stateless APIs.

Instead of storing login sessions on the server,
the client sends a token with every request.

---------------------------------------------------
1. USER REGISTRATION FLOW
---------------------------------------------------

User
  │
  │ POST /api/auth/register
  │ Sends:
  │ { fullName, email, password, role }
  ▼
AuthController.registerUser()
  │
  ▼
AuthService.registerUser()
  │
  │ Check if user already exists
  │ userRepository.existsByUsername(email)
  │
  │ Encrypt password
  │ passwordEncoder.encode(password)
  │
  │ Create new User entity
  │
  ▼
UserRepository.save(user)
  │
  ▼
Database
(application_user table)

Result:
User is stored with a hashed password (BCrypt)


---------------------------------------------------
2. USER LOGIN FLOW
---------------------------------------------------

User
  │
  │ POST /api/auth/login
  │ Sends:
  │ { username, password }
  ▼
AuthController.login()
  │
  ▼
AuthService.login()
  │
  │ Create authentication request
  │ UsernamePasswordAuthenticationToken
  │
  ▼
AuthenticationManager.authenticate()
  │
  ▼
DaoAuthenticationProvider
  │
  ▼
CustomDetailsService.loadUserByUsername()
  │
  │ Fetch user from database
  │ userRepository.findByEmail(username)
  │
  ▼
Database
  │
  ▼
UserDetails returned to Spring Security
  │
  │ Spring Security compares:
  │ entered password
  │ vs
  │ hashed password in DB
  │ using BCryptPasswordEncoder
  │
  ▼
If credentials are correct
  │
  ▼
Authentication object created
  │
  ▼
SecurityContextHolder
stores authentication

This represents the currently logged-in user.


---------------------------------------------------
3. JWT TOKEN GENERATION
---------------------------------------------------

AuthService.login()
  │
  ▼
JwtService.generateTokenPair(authentication)
  │
  ├─ generateAccessToken()
  │
  └─ generateRefreshToken()
  │
  ▼
JwtService.generateToken()

JWT Structure:

HEADER.PAYLOAD.SIGNATURE


HEADER
{
 "alg": "HS256",
 "typ": "JWT"
}

PAYLOAD (claims)
{
 "sub": "user@email.com",
 "iat": 1710000000,
 "exp": 1710003600
}

SIGNATURE
HMACSHA256(
  base64(header) + "." + base64(payload),
  secret_key
)

Secret key comes from:

application.properties

app.jwt.secret=...
app.jwt.expiration=3600000
app.jwt.refresh-expiration=86400000


Result returned to client:

{
 accessToken: "...",
 refreshToken: "..."
}


---------------------------------------------------
4. CLIENT STORES TOKEN
---------------------------------------------------

Client stores JWT

Possible storage locations:

- LocalStorage
- SessionStorage
- Memory
- Secure cookies

Example header for future requests:

Authorization: Bearer <access_token>


---------------------------------------------------
5. ACCESSING PROTECTED APIs
---------------------------------------------------

Client request

GET /api/orders

Header:
Authorization: Bearer eyJhbGciOiJIUzI1NiIs...


Request enters Spring Security


---------------------------------------------------
6. SPRING SECURITY FILTER CHAIN
---------------------------------------------------

Client Request
   │
   ▼
SecurityFilterChain
   │
   ▼
JwtAuthenticationFilter
   │
   │ Extract token from header
   │ Authorization: Bearer token
   │
   ▼
JwtService.isValidToken(token)
   │
   │ Validate signature using secret key
   │
   ▼
JwtService.extractUsernameFromToken()
   │
   ▼
CustomDetailsService.loadUserByUsername()
   │
   ▼
Database


UserDetails returned
   │
   ▼
Create Authentication object

UsernamePasswordAuthenticationToken
   │
   ▼
SecurityContextHolder.setAuthentication()


Now Spring Security considers the user AUTHENTICATED.


---------------------------------------------------
7. CONTROLLER EXECUTION
---------------------------------------------------

Request continues to controller:

Example:

OrderController.getOrders()

Because authentication exists in SecurityContext,
the endpoint is allowed.


---------------------------------------------------
8. ACCESS TOKEN EXPIRATION
---------------------------------------------------

Access tokens are short-lived.

Example:

app.jwt.expiration=3600000
= 1 hour

If token expires:

Server returns:

401 Unauthorized


---------------------------------------------------
9. REFRESH TOKEN FLOW
---------------------------------------------------

Client sends:

POST /api/auth/refresh-token

Body:
{
 refreshToken: "..."
}


AuthController.refreshToken()
  │
  ▼
AuthService.refreshToken()
  │
  ▼
JwtService.isRefreshToken()
  │
  │ Check claim:
  │ tokenType = refresh
  │
  ▼
JwtService.extractUsernameFromToken()
  │
  ▼
CustomDetailsService.loadUserByUsername()
  │
  ▼
Create Authentication object
  │
  ▼
JwtService.generateAccessToken()
  │
  ▼
Return new access token


Response:

{
 accessToken: "new_access_token",
 refreshToken: "existing_refresh_token"
}


---------------------------------------------------
10. WHY THIS IS STATELESS
---------------------------------------------------

Traditional authentication:

Client
  │
  ▼
Server stores SESSION
  │
  ▼
Client sends SESSION ID cookie


JWT authentication:

Client
  │
  ▼
Server issues TOKEN
  │
  ▼
Client stores token
  │
  ▼
Client sends token in every request
  │
  ▼
Server only verifies token signature


Server does NOT store sessions.


---------------------------------------------------
11. IMPORTANT SPRING SECURITY COMPONENTS
---------------------------------------------------

SecurityFilterChain
Defines security rules for HTTP requests.

AuthenticationManager
Responsible for authenticating users.

DaoAuthenticationProvider
Uses UserDetailsService to load users.

UserDetailsService
Loads users from database.

SecurityContextHolder
Stores authenticated user for current request.

JwtAuthenticationFilter
Intercepts requests and validates JWT tokens.

JwtService
Creates and verifies JWT tokens.

UserRepository
Fetches users from database.

AuthService
Handles login, registration, and refresh token logic.


---------------------------------------------------
12. COMPLETE REQUEST FLOW SUMMARY
---------------------------------------------------

User Login
   │
   ▼
Spring Security authenticates credentials
   │
   ▼
JWT tokens generated
   │
   ▼
Client stores tokens
   │
   ▼
Client sends token with each request
   │
   ▼
JwtAuthenticationFilter validates token
   │
   ▼
SecurityContext updated
   │
   ▼
Controller executes
   │
   ▼
Response returned

Dependecies

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-security</artifactId>
</dependency>

<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-api</artifactId>
<version>0.12.6</version>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-impl</artifactId>
<version>0.12.6</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-jackson</artifactId>
<version>0.12.6</version>
<scope>runtime</scope>
</dependency>

config in properties


# JWT Configuration
app.jwt.secret=856B4FEB2CF84D145A231D7A28B41856B4FEB2CF84D145A231D7A28B41856B4FEB2CF84D145A231D7A28B41
app.jwt.expiration=3600000
app.jwt.refresh-expiration=86400000

Create user

User entity
User.java

package com.grazac.wisdom.user;

import jakarta.persistence.*;
import lombok.*;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;

import java.time.LocalDateTime;

@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@Builder
@Entity
@Table(name = "application_user", indexes = {
        @Index(name = "idx_user_email", columnList = "email")
})
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(
            name = "full_name",
            nullable = false
    )
    private String fullName;


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

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

    @Column(nullable = false)
    private String password;

    @Column(nullable = true)
    private String profilePic;

    @Column(nullable = true)
    private String accountNumber;

    @Enumerated(EnumType.STRING)
    private Role role;

    @CreatedDate
    @Column(name = "created_at", nullable = false, updatable = false)
    private LocalDateTime createdAt;

    @LastModifiedDate
    @Column(name = "updated_at")
    private LocalDateTime updatedAt;

    public User(String fullName, String username, String password, Role role) {
        this.fullName = fullName;
        this.username = username;
        this.password = password;
        this.role = role;
    }
}

Role.enum

package com.grazac.wisdom.user;

public enum Role {
    ROLE_USER,
    ROLE_ADMIN
}

UserRepository

package com.grazac.wisdom.user;

import org.springframework.data.jpa.repository.JpaRepository;

import java.util.Optional;

public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByUsername(String username);
    Boolean existsByUsername(String username);

    Optional<User> findByEmail(String username);
}

CurrentUser

@Component // Marks this class as a Spring Bean so Spring can automatically detect and manage it
public class CurrentUserUtil {

    // Repository used to fetch the User entity from the database
    private final UserRepository userRepository;

    // Constructor injection: Spring automatically injects the UserRepository bean here
    public CurrentUserUtil(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    // Method to get the username of the currently authenticated user
    public String getLoggedInUsername() {

        // SecurityContextHolder stores security information for the current request/thread
        // getContext() returns the current security context
        // getAuthentication() returns the authentication object of the logged-in user
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();

        // getName() returns the username (principal name) of the authenticated user
        return authentication.getName();
    }

    // Method to get the full User entity of the currently logged-in user
    public User getLoggedInUser() {

        // Get the username from the security context
        String username = getLoggedInUsername();

        // Search for the user in the database using the username
        return userRepository.findByUsername(username)

                // If the user is not found, throw a custom exception
                .orElseThrow(() -> new UserNotFoundException("User not found: " + username));
    }
}

in utils
ApiResponse.java



import lombok.Data;

@Data
public class ApiResponse<T> {
    private boolean success;
    private String message;
    private T data;

    private ApiResponse(boolean success, String message, T data) {
        this.success = success;
        this.message = message;
        this.data = data;
    }

    public static <T> ApiResponse<T> success(String message, T data) {
        return new ApiResponse<>(true, message, data);
    }

    public static <T> ApiResponse<T> success(T data) {
        return new ApiResponse<>(true, "Request successful", data);
    }

    public static <T> ApiResponse<T> fail(String message) {
        return new ApiResponse<>(false, message, null);
    }

    public static <T> ApiResponse<T> fail(String message, T data) {
        return new ApiResponse<>(false, message, data);
    }
}

CustomDetailsService.java

package com.grazac.wisdom.user;
// Declares the package where this class belongs

import org.springframework.security.core.GrantedAuthority;
// Represents a permission or role granted to a user

import org.springframework.security.core.authority.SimpleGrantedAuthority;
// A basic implementation of GrantedAuthority used for roles like ROLE_ADMIN

import org.springframework.security.core.userdetails.UserDetails;
// Spring Security interface that represents an authenticated user

import org.springframework.security.core.userdetails.UserDetailsService;
// Interface used by Spring Security to load user-specific data during login

import org.springframework.security.core.userdetails.UsernameNotFoundException;
// Exception thrown when a user cannot be found during authentication

import org.springframework.stereotype.Service;
// Marks this class as a Spring service bean so it can be automatically detected

import java.util.Collection;
// Represents a group of objects (used for authorities)

import java.util.List;
// Used to create a list of authorities


@Service
// Registers this class as a Spring-managed bean so Spring Security can use it
public class CustomDetailsService implements UserDetailsService {

    // Repository used to fetch users from the database
    private final UserRepository userRepository;

    // Constructor injection: Spring automatically injects UserRepository here
    public CustomDetailsService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @Override
    // Method required by UserDetailsService
    // Spring Security calls this method automatically during login
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {

        // Search for the user in the database using email
        // If the user does not exist, throw UsernameNotFoundException
        User user = userRepository.findByEmail(username)
                .orElseThrow(() -> new UsernameNotFoundException("User not found"));

        // Return a Spring Security User object
        // This object contains authentication information used by Spring Security
        return new org.springframework.security.core.userdetails.User(

                // Username used by Spring Security (principal)
                user.getUsername(),

                // Password stored in the database (usually encrypted with BCrypt)
                user.getPassword(),

                // List of roles/authorities granted to the user
                getAuthority(user)
        );
    }

    // Method to convert the user's role into a Spring Security authority
    private Collection<? extends GrantedAuthority> getAuthority(User user) {

        // Create an authority using the role name from the User entity
        // Example: ROLE_ADMIN or ROLE_USER
        GrantedAuthority authority = new SimpleGrantedAuthority(user.getRole().name());

        // Return the authority as a list (Spring expects a collection)
        return List.of(authority);
    }
}

Token Pair


import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class TokenPair {
    private String accessToken;
    private String refreshToken;


    public TokenPair() {
    }

    public TokenPair(String accessToken, String refreshToken) {
        this.accessToken = accessToken;
        this.refreshToken = refreshToken;
    }
}

JwtService.java

package com.grazac.wisdom.user;
// Defines the package where this class belongs

import dto.TokenPair;
// Custom DTO used to return both access token and refresh token together

import io.jsonwebtoken.*;
// JWT library classes for building and parsing tokens

import io.jsonwebtoken.io.Decoders;
// Utility class for decoding Base64 encoded secrets

import io.jsonwebtoken.security.Keys;
// Used to generate cryptographic signing keys

import lombok.extern.slf4j.Slf4j;
// Lombok annotation that automatically creates a logger

import org.springframework.beans.factory.annotation.Value;
// Used to inject values from application.properties or application.yml

import org.springframework.security.core.Authentication;
// Represents the authenticated user in Spring Security

import org.springframework.security.core.userdetails.UserDetails;
// Interface representing user information in Spring Security

import org.springframework.stereotype.Service;
// Marks this class as a Spring service bean

import javax.crypto.SecretKey;
// Represents the secret key used to sign the JWT

import java.util.Date;
// Used for token creation time and expiration time

import java.util.HashMap;
import java.util.Map;

@Service
// Registers this class as a Spring-managed service
@Slf4j
// Adds a logger automatically (log.info(), log.error(), etc.)
public class JwtService {

    // Inject the JWT secret key from application.properties
    @Value("${app.jwt.secret}")
    private String jwtSecret;

    // Access token expiration time (milliseconds)
    @Value("${app.jwt.expiration}")
    private long jwtExpirationMs;

    // Refresh token expiration time (milliseconds)
    @Value("${app.jwt.refresh-expiration}")
    private long refreshExpirationMs;


    // Generates both access and refresh tokens for a user
    public TokenPair generateTokenPair(Authentication authentication) {

        // Create access token
        String accessToken = generateAccessToken(authentication);

        // Create refresh token
        String refreshToken = generateRefreshToken(authentication);

        // Return both tokens wrapped in a DTO
        return new TokenPair(accessToken, refreshToken);
    }

// Authentication here -> refers to Spring authentication object that represents the current authenticated users(an interface). Usually holds
| Field             | Meaning                       |
| ----------------- | ----------------------------- |
| **principal**     | the user (UserDetails object) |
| **credentials**   | password or token             |
| **authorities**   | roles like ROLE_ADMIN         |
| **authenticated** | whether login succeeded       |

    // Generate short-lived access token
    public String generateAccessToken(Authentication authentication) {

        // Calls general token generator with normal expiration
        return generateToken(authentication, jwtExpirationMs, new HashMap<>());
    }

    // Generate refresh token (longer expiration)
    public String generateRefreshToken(Authentication authentication) {

        // Create claims map to store extra data in the token
        Map<String, String> claims = new HashMap<>();

        // Mark token as refresh token
        claims.put("tokenType", "refresh");

        // Generate token with refresh expiration time
        return generateToken(authentication, refreshExpirationMs, claims);
    }

    // Generic method used to generate any token
    public String generateToken(Authentication authentication, long expirationInMs, Map<String, String> claims) {

        // Extract logged-in user from authentication object
        UserDetails userPrincipal = (UserDetails) authentication.getPrincipal();

        // Current time
        Date now = new Date();

        // Token expiration time
        Date expiryDate = new Date(now.getTime() + expirationInMs);

        // Build the JWT token
        return Jwts.builder()

                // Add header information
                .header()
                .add("typ", "JWT")
                .and()

                // Subject is usually the username
                .subject(userPrincipal.getUsername())

                // Add custom claims (e.g. tokenType)
                .claims(claims)

                // Time token was issued
                .issuedAt(now)

                // Expiration time
                .expiration(expiryDate)

                // Sign the token using the secret key
                .signWith(getSignInKey())

                // Build the token string
                .compact();
    }

    // Validate token by checking username matches the user
    public boolean validateTokenForUser(String token, UserDetails userDetails) {

        // Extract username stored in the token
        final String username = extractUsernameFromToken(token);

        // Token is valid if username matches the user
        return username != null
                && username.equals(userDetails.getUsername());
    }

    // Checks if token is valid (not malformed or expired)
    public boolean isValidToken(String token) {

        // If claims can be extracted, token is valid
        return extractAllClaims(token) != null;
    }


    // Extract username from token
    public String extractUsernameFromToken(String token) {

        // Get all token claims
        Claims claims = extractAllClaims(token);

        if(claims != null) {

            // Subject contains the username
            return claims.getSubject();
        }

        return null;
    }

    // Check if token is specifically a refresh token
    public boolean isRefreshToken(String token) {

        Claims claims = extractAllClaims(token);

        if(claims == null) {
            return false;
        }

        // Check custom claim "tokenType"
        return "refresh".equals(claims.get("tokenType"));
    }

    // Extract all claims from the token
    private Claims extractAllClaims(String token) {

        Claims claims = null;

        try {

            // Parse and validate the JWT
            claims = Jwts.parser()
                    .verifyWith(getSignInKey()) // verify using secret key
                    .build()
                    .parseSignedClaims(token) // parse token
                    .getPayload(); // extract claims

        } catch (JwtException | IllegalArgumentException e) {

            // Token invalid or malformed
            throw new RuntimeException(e);
        }

        return claims;
    }

    // Generate signing key from secret
    private SecretKey getSignInKey() {

        // Decode the base64 secret
        byte[] keyBytes = Decoders.BASE64.decode(jwtSecret);

        // Create HMAC SHA signing key
        return Keys.hmacShaKeyFor(keyBytes);
    }

    // Calculate how much time remains before token expires
    public long getRemainingValidity(String token) {

        Claims claims = extractAllClaims(token);

        // Return remaining milliseconds before expiration
        return claims.getExpiration().getTime() - System.currentTimeMillis();
    }
}

RegisterRequest.java

package dto;


import com.grazac.wisdom.user.Role;
import lombok.*;

@Builder
@NoArgsConstructor
@AllArgsConstructor
@Getter
@Setter
public class RegisterRequest {

    private String fullName;
    private String email;
    private String password;
    private Role role;
}

LoginRequest

@Data
@NoArgsConstructor
@AllArgsConstructor
public class LoginRequest {
    private String username;
    private String password;
}

RefreshTokenRequest

@Data
@AllArgsConstructor
public class RefreshTokenRequest {
    private String refreshToken;
}

SecurityConfig.java

package com.grazac.wisdom.utils;

// Import custom JWT filter that reads JWT from incoming requests
import com.grazac.wisdom.filters.JwtAuthenticationFilter;

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

// Spring Security authentication components
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.dao.DaoAuthenticationProvider;

// Provides AuthenticationManager configured by Spring
import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;

// Enables method level security like @PreAuthorize
import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;

// Used to configure HTTP security
import org.springframework.security.config.annotation.web.builders.HttpSecurity;

// Enables Spring Security for the application
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;

// Controls session policy (STATELESS for JWT)
import org.springframework.security.config.http.SessionCreationPolicy;

// Used to load users from database
import org.springframework.security.core.userdetails.UserDetailsService;

// Password hashing using BCrypt
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

// Security filter chain
import org.springframework.security.web.SecurityFilterChain;

// Default authentication filter used by Spring
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

// CORS configuration imports
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.CorsConfigurationSource;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;

import java.util.List;


@Configuration
// Marks this class as a configuration class for Spring
@EnableWebSecurity
// Enables Spring Security in the application
@EnableMethodSecurity
// Allows security annotations like @PreAuthorize
public class SecurityConfig {

    // Service that loads users from the database
    private final UserDetailsService userDetailsService;

    // Custom filter that validates JWT tokens
    private final JwtAuthenticationFilter jwtAuthenticationFilter;

    // Constructor injection
    public SecurityConfig(UserDetailsService userDetailsService,
                          JwtAuthenticationFilter jwtAuthenticationFilter) {
        this.userDetailsService = userDetailsService;
        this.jwtAuthenticationFilter = jwtAuthenticationFilter;
    }

    // List of endpoints that do NOT require authentication
    public static final String[] WHITE_LIST_URL = {

            "/togglz-console", "/togglz-console/**",
            "/api/terminals/**",
            "/api/courses/**",
            "/ws/**",
            "/api/posts",
            "/electronics/**",
            "/activity/**",
            "/actuator/**",
            "/login/**",
            "/booking/**",
            "/login/oauth2/code/google",
            "/api/auth/**",
            "/api/orders/**",
            "/api/sample/**",
            "/api/external/**",
            "/info",
            "/blogs/**",
            "/posts/**",

            // Swagger documentation endpoints
            "/v2/api-docs",
            "/v3/api-docs",
            "/v3/api-docs/**",
            "/swagger-resources",
            "/swagger-resources/**",
            "/configuration/ui",
            "/configuration/security",
            "/swagger-ui/**",
            "/webjars/**",
            "/swagger-ui.html",

            "/error"
    };


    // Password encoder bean
    // BCrypt hashes passwords before saving to the database
    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }


// It connects Spring Security’s login system to your database + password hashing.
    // Authentication provider that uses database users
// DaoAuthenticationProvider → uses your UserDetailsService to load the user from the DB.
// setPasswordEncoder(...) → verifies the hashed password correctly.
// AuthenticationProvider bean → registers this logic so Spring Security can handle login requests.
    @Bean
    public AuthenticationProvider authenticationProvider() {

        // DaoAuthenticationProvider loads user using UserDetailsService
        DaoAuthenticationProvider authProvider =
                new DaoAuthenticationProvider(userDetailsService);

        // Set password encoder for verifying passwords
        authProvider.setPasswordEncoder(passwordEncoder());

        return authProvider;
    }


    // AuthenticationManager used for login authentication
// This exposes **Spring Security’s AuthenticationManager as a bean so you can use it to authenticate login requests manually (e.g., in a login controller).
// so that we can:
// authenticationManager.authenticate(
    new UsernamePasswordAuthenticationToken(username, password)
);
    @Bean
    public AuthenticationManager authenticationManager(AuthenticationConfiguration authConfig) throws Exception {

        // Returns Spring's default AuthenticationManager
        return authConfig.getAuthenticationManager();
    }


    // Main Spring Security configuration
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {

        http

                // Enable CORS using our configuration
// Allows requests from other origins (like your frontend).
// Backend → api.example.com
// Frontend → localhost:3000
                .cors(c -> c.configurationSource(corsConfigurationSource()))

                // Disable CSRF because we are using JWT (stateless authentication)
                .csrf(csrf -> csrf.disable())

                // Authorization rules
                .authorizeHttpRequests(

                        req -> req

                                // Allow all requests to white-listed endpoints
                                .requestMatchers(WHITE_LIST_URL).permitAll()

                                // Any other endpoint requires authentication
                                .anyRequest().authenticated()
                )

                // Configure session management
                .sessionManagement(

                        session -> session

                                // Stateless because JWT handles authentication
                                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                )

                // Add JWT filter before default Spring login filter
                .addFilterBefore(
                        jwtAuthenticationFilter,
                        UsernamePasswordAuthenticationFilter.class
                )

                // Use our custom authentication provider
                .authenticationProvider(authenticationProvider());

        // Build the filter chain
        return http.build();
    }



    // Configure CORS (Cross-Origin Resource Sharing)
    @Bean
    CorsConfigurationSource corsConfigurationSource() {

        CorsConfiguration configuration = new CorsConfiguration();

        // Allowed frontend applications
        configuration.setAllowedOrigins(List.of(
                "http://localhost:63342",
                "http://localhost:3000",
                "https://secsystem-emr.vercel.app",
                "https://emr-sigma-ten.vercel.app",
                "Postman"
        ));

        // Allowed HTTP methods
        configuration.setAllowedMethods(List.of(
                "GET",
                "POST",
                "PUT",
                "DELETE",
                "OPTIONS"
        ));

        // Allowed request headers
        configuration.setAllowedHeaders(List.of(
                "Authorization",
                "Content-Type"
        ));

        // Allow sending Authorization header or cookies
        configuration.setAllowCredentials(true);

        // Apply this CORS config to all endpoints
        UrlBasedCorsConfigurationSource source =
                new UrlBasedCorsConfigurationSource();

        source.registerCorsConfiguration("/**", configuration);

        return source;
    }

}

JwtAuthenticationFilter.java

package com.grazac.wisdom.filters;

import com.grazac.wisdom.user.JwtService;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.http.HttpStatus;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;
import tools.jackson.databind.ObjectMapper;

import java.io.IOException;
import java.time.LocalDateTime;
import java.util.Map;

@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {
    private final JwtService jwtService;
    private final UserDetailsService userDetailsService;

    public JwtAuthenticationFilter(JwtService jwtService, UserDetailsService userDetailsService) {
        this.jwtService = jwtService;
        this.userDetailsService = userDetailsService;
    }

    @Override
    protected void doFilterInternal
            (HttpServletRequest request,
             HttpServletResponse response,
             FilterChain filterChain) throws ServletException, IOException {

        final String authHeader = request.getHeader("Authorization");
        final String jwt;
        final String username;

        if (authHeader == null || !authHeader.startsWith("Bearer ")) {
            filterChain.doFilter(request, response);
            return; // stop here
        }

        jwt = getJwtFromRequest(request);

        if (!jwtService.isValidToken(jwt)) {
            filterChain.doFilter(request, response);
            return;
        }

        try {
            username = jwtService.extractUsernameFromToken(jwt);

            if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
                UserDetails userDetails = userDetailsService.loadUserByUsername(username);

                if (jwtService.validateTokenForUser(jwt, userDetails)) {
                    UsernamePasswordAuthenticationToken authToken =
                            new UsernamePasswordAuthenticationToken(
                                    userDetails,
                                    null,
                                    userDetails.getAuthorities()
                            );
                    authToken.setDetails(
                            new WebAuthenticationDetailsSource().buildDetails(request)
                    );
                    SecurityContextHolder.getContext().setAuthentication(authToken);
                }
            }

            filterChain.doFilter(request, response);

        } catch (UsernameNotFoundException ex) {
            sendErrorResponse(response, "Unauthorized", HttpStatus.UNAUTHORIZED);
        } catch (Exception ex) {
            sendErrorResponse(response, "Authentication error: " + ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    private String getJwtFromRequest(HttpServletRequest request) {
        final String authHeader = request.getHeader("Authorization");
        return authHeader.substring(7); // Remove "Bearer "
    }

    private void sendErrorResponse(HttpServletResponse response, String message, HttpStatus status) throws IOException {
        response.setStatus(status.value());
        response.setContentType("application/json");
        Map<String, Object> body = Map.of(
                "timestamp", LocalDateTime.now().toString(),
                "status", status.value(),
                "error", message
        );
        new ObjectMapper().writeValue(response.getWriter(), body);
    }
}

AuthService

package com.grazac.wisdom.service;


import com.grazac.wisdom.exceptions.ConflictException;
import com.grazac.wisdom.user.CurrentUserUtil;
import com.grazac.wisdom.user.JwtService;
import com.grazac.wisdom.user.User;
import com.grazac.wisdom.user.UserRepository;
import dto.LoginRequest;
import dto.RefreshTokenRequest;
import dto.RegisterRequest;
import dto.TokenPair;
import jakarta.transaction.Transactional;
import lombok.AllArgsConstructor;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.Map;

@Service
@AllArgsConstructor
public class AuthService {

    private final UserRepository userRepository;
    private final PasswordEncoder passwordEncoder;
    private final AuthenticationManager authenticationManager;
    private final JwtService jwtService;
    private final UserDetailsService userDetailsService;
    private final CurrentUserUtil currentUserUtil;


    @Transactional
    public void registerUser(RegisterRequest registerRequest) {
        // Check if user with the same username already exist
        if(userRepository.existsByUsername(registerRequest.getEmail())) {
            throw new ConflictException("Username is already in use");
        }

        // Create new user
        User user = User
                .builder()
                .createdAt(LocalDateTime.now())
                .fullName(registerRequest.getFullName())
                .username(registerRequest.getEmail())
                .email(registerRequest.getEmail())
                .password(passwordEncoder.encode(registerRequest.getPassword()))
                .role(registerRequest.getRole())
                .build();

        userRepository.save(user);

    }

    public TokenPair login(LoginRequest loginRequest) {

        // Ask Spring Security to authenticate the user
        Authentication authentication = authenticationManager.authenticate(

                // Create an authentication request object containing username and password
                new UsernamePasswordAuthenticationToken(

                        // Username from the login request
                        loginRequest.getUsername(),

                        // Password from the login request
                        loginRequest.getPassword()
                )
        );

        // If authentication succeeds, store the authentication object
        // in Spring Security's SecurityContext (represents the logged-in user)
        SecurityContextHolder.getContext().setAuthentication(authentication);

        // Generate both Access Token and Refresh Token for the authenticated user
        return jwtService.generateTokenPair(authentication);
    }


    public TokenPair refreshToken(RefreshTokenRequest request) {

        // Extract the refresh token sent by the client
        String refreshToken = request.getRefreshToken();

        // Check if the token is actually a refresh token
        // (your JwtService checks the claim "tokenType = refresh")
        if(!jwtService.isRefreshToken(refreshToken)) {

            // If not a refresh token, reject the request
            throw new IllegalArgumentException("Invalid refresh token");
        }

        // Extract the username stored inside the token
        String user = jwtService.extractUsernameFromToken(refreshToken);

        // Load the user details from the database
        UserDetails userDetails = userDetailsService.loadUserByUsername(user);

        // If user cannot be found, stop the process
        if (userDetails == null) {
            throw new IllegalArgumentException("User not found");
        }

        // Create an authentication object manually
        // (this represents an authenticated user without needing password)
        UsernamePasswordAuthenticationToken authentication =
                new UsernamePasswordAuthenticationToken(

                        // Authenticated user
                        userDetails,

                        // No password required since token already verified
                        null,

                        // User roles/authorities
                        userDetails.getAuthorities()
                );

        // Generate a new access token using the authenticated user
        String accessToken = jwtService.generateAccessToken(authentication);

        // Return the new access token and the existing refresh token
        return new TokenPair(accessToken, refreshToken);
    }
}

AuthController

package com.grazac.wisdom;


import com.grazac.wisdom.service.AuthService;
import com.grazac.wisdom.utils.ApiResponse;
import dto.LoginRequest;
import dto.RefreshTokenRequest;
import dto.RegisterRequest;
import dto.TokenPair;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/auth")
public class AuthController {

    private final AuthService authService;

    public AuthController(AuthService authService) {
        this.authService = authService;
    }



    @PostMapping("/register")
    public ResponseEntity<ApiResponse<String>> registerUser(@RequestBody RegisterRequest request)  {
        // Save the new user to the database and return success response.
        authService.registerUser(request);
        return ResponseEntity.ok(ApiResponse.success("User registered successfully"));
    }

    @PostMapping("/login")
    public ResponseEntity<ApiResponse<Object>> login(@RequestBody LoginRequest loginRequest) {
        TokenPair tokenPair = authService.login(loginRequest);
        return ResponseEntity.ok(ApiResponse.success(tokenPair));
    }

    @PostMapping("/refresh-token")
    public ResponseEntity<?> refreshToken( @RequestBody RefreshTokenRequest request) {
        TokenPair tokenPair = authService.refreshToken(request);
        return ResponseEntity.ok(tokenPair);
    }

}

C notes

DrSimple — Fri, 13 Feb 2026 10:59:44 +0000


// # == preprocessor are used for include directives or macro
// definitions#include "math_utils.h"#include <inttypes.h> // for portable int64
// printing
#include "math_utils.h" // custom header (must exist)
#include <inttypes.h>
#include <stdbool.h>
#include <stdint.h> // use this instead of the primitives inbuilt types
#include <stdio.h>
#include <stdlib.h>
#include <time.h> // for time()

// signed int
typedef int8_t i8;
typedef int16_t i16;
typedef int32_t i32;
typedef int64_t i64;

// unsigned int
typedef uint8_t u8;
typedef uint16_t u16;
typedef uint32_t u32;
typedef uint64_t u64;

// fractions
typedef float f32;
typedef double f64;

// bools
typedef i8 b8;
typedef i32 b32;

// struct
struct vec2f {
  f32 x;
  f64 y;
};

// typedef with struct
typedef struct {
  i8 a;
  i16 b;
} vec1f;

typedef enum { TYPE_INT, TYPE_FLOAT } Type;

typedef struct {
  Type type;
  union {
    int i;
    float f;
  } value;
} Variant;

// c contract -> function prototype
void greet();

#define PI 3.14
#define MAX(x, y) (x > y ? x : y)

typedef enum { POSITION_LOW = 0, POSITION_MID = 1, POSITION_HIGH = 2 } Position;

union Data {
  int i;
  float f;
};

int main() {

  // primitives
  int my_age = 19;
  char grade = 'A';

  i32 age = 90;
  i64 weight = 909;

  // using macros
  // the preprocessor will run and insert the actual value
  f32 actual_age = PI;
  printf("Using Macros: %f\n", actual_age);

  i32 num1 = 6;
  i32 num2 = 8;
  printf("max of num1 and num2 is: %d\n", MAX(num1, num2));

  bool is_tall = true;
  printf("tall: %d\n", is_tall);
  b8 is_short = true;

  // Print boolean (C prints as integer 0 or 1)
  printf("short: %d\n", is_short);

  // enums
  printf("\n--- Enums ---\n");

  Position pos;

  // assign using enum constant
  pos = POSITION_HIGH;

  if (pos == POSITION_HIGH) {
    printf("Position is HIGH (%d)\n", pos);
  } else if (pos == POSITION_MID) {
    printf("Position is MID (%d)\n", pos);
  } else if (pos == POSITION_LOW) {
    printf("Position is LOW (%d)\n", pos);
  }

  // random number using the stdlib.h and time
  // Seed random number generator (do this once)
  srand((unsigned int)time(NULL));

  // Generate random numbers
  int random_number = rand();            // 0 to RAND_MAX
  i32 random_0_9 = rand() % 10;          // 0 - 9
  i32 random_1_100 = (rand() % 100) + 1; // 1 - 100

  printf("Random number (0 - RAND_MAX): %d\n", random_number);
  printf("Random number (0 - 9): %d\n", random_0_9);
  printf("Random number (1 - 100): %d\n", random_1_100);
  // struct
  struct vec2f v;
  v.x = 18.0f;
  v.y = 19.0;

  // struct with typedef
  // Designated initializer
  vec1f v1 = {13, 14};
  printf("v1 vector is %d, %d \n", v1.a, v1.b);
  printf("Size of struct: %zu bytes\n", sizeof(v1));
  // x (4 bytes)
  //  y (4 bytes)

  vec1f v3 = {
      .a = 89, // if a is not set it becomes zero automatically
      .b = 89  // positional arguements
  };
  printf("Vector v3= < %d, %d > \n", v3.a, v3.b);

  // Compound literal (NOT a cast)
  v3 = (vec1f){.a = 9, .b = 10};
  printf("Vector v3 after casting= < %d, %d > \n", v3.a, v3.b);

  // Print struct members individually
  printf("vector is (%.2f, %.2lf)\n", v.x, v.y);
  printf("Vector v1 = < %d, %d > \n", v1.a, v1.b);

  printf("age is: %d\n", age);
  printf("Weight is: %" PRId64 "\n", weight);
  // PRId64 expands to either "lld" or "ld" depending on the
  // platform
  // so when you write printf("%" PRId64 "\n", value); the
  // preprocessor changes it to printf("%lld\n", value); or
  // printf("%ld\n", value); PRI → Print d → signed decimal 64 →
  // 64-bit
  //
  //

  // Unions
  union Data d;

  d.i = 10;
  printf("i = %d\n", d.i);

  d.f = 3.14f; // overwrites same memory
  printf("f = %f\n", d.f);

  printf("Size of union: %zu bytes\n", sizeof(d));

  Variant va;

  va.type = TYPE_INT;
  va.value.i = 42;

  if (va.type == TYPE_INT)
    printf("int = %d\n", va.value.i);

  // pointers
  i32 xx = 89; // this has place in memory in the program in your physical ram
               // pointer is a number that points to the address of the variable
  i32 *pxx = &xx; // the * can be close to i32 like i32* or *pxx or i32 * pxx
  printf("memory address of xx is %p and the real value is %d \n", pxx, xx);

  // set another value to the address
  *pxx = 130; // go to where pxx is in memory and override this value of 130
  printf("memory address of xx is %p and the real value is %d \n", pxx, xx);

  // pointer to struct
  vec1f v4 = {.a = 19, .b = 23};
  vec1f *pv4 = &v4;
  // dereference the pointer to get the real value
  printf("initial vector before pointer %d %d\n", v4.a, v4.b);

  // method 1 to dereference and access the member
  // explicit dereference
  // arrow operator
  (*pv4).a = 20;
  (*pv4).b = 16;
  printf("initial vector after pointer %d %d\n", v4.a, v4.b);

  // method 2 to dereference and access the member
  pv4->a = 25;
  pv4->b = 16;
  printf("initial vector after pointer using -> %d %d\n", v4.a, v4.b);

  // arrays
  // here we are allocating memories that we know at compile time
  // stack memory
  i32 numbers[] = {1, 2, 3, 4};
  printf("index 0 is: %d \n", numbers[0]);
  // loop through an array
  for (i32 i = 0; i < 3; i++) {
    printf("%d ", numbers[i]);
  }
  printf("\n");

  // in C
  // therefore: *numbers == numbers[0]
  // Is exactly the same as: numbers[0] = 6;
  // Now array becomes: 6 2 3 4
  // array name == pointer to first element
  // Array decay & pointer arithmetic
  *numbers = 6;
  // Pointer Arithmetic
  // numbers + 1   → move 1 element forward
  // Now array becomes: 6 90 3 4
  *(numbers + 1) = 90;

  for (i32 i = 0; i < sizeof(numbers) / sizeof(numbers[0]);
       i++) { // better practice
    printf("%d ", numbers[i]);
  }
  printf("\n");

  // allocating dynamic memory using stdlib.h
  // heap memory
  // dynamic memory allocation (heap) using:
  // malloc
  // calloc
  // realloc
  // free

  printf("\n--- Dynamic Memory (malloc) ---\n");

  i32 count = 4;

  // allocate memory for 4 i32 elements
  i32 *dyn_numbers = malloc(count * sizeof(i32));
  // If i32 = 4 bytes and count = 4
  // malloc(4 * 4) = malloc(16 bytes)

  if (dyn_numbers == NULL) {
    printf("Memory allocation failed!\n");
    return 1;
  }

  // assign values
  for (i32 i = 0; i < count; i++) {
    dyn_numbers[i] = (i + 1) * 10;
  }

  // print values
  for (i32 i = 0; i < count; i++) {
    printf("%d ", dyn_numbers[i]);
  }
  printf("\n");

  // always free heap memory
  free(dyn_numbers);
  dyn_numbers = NULL; // good practice
                      //
                      //
                      // Using calloc (zero-initialized)
  printf("\n--- Dynamic Memory (calloc) ---\n");

  i32 *zero_numbers = calloc(4, sizeof(i32));

  if (!zero_numbers) {
    printf("Calloc failed!\n");
    return 1; // or return EXIT_FAILURE
  }

  for (i32 i = 0; i < 4; i++) {
    printf("%d ", zero_numbers[i]); // prints 0 0 0 0
  }
  printf("\n");

  free(zero_numbers);
  zero_numbers = NULL;

  // realloc (resize memory)
  printf("\n--- Realloc Example ---\n");

  i32 *resize_array = malloc(2 * sizeof(i32));

  resize_array[0] = 1;
  resize_array[1] = 2;

  // increase size to 4 elements
  resize_array = realloc(resize_array, 4 * sizeof(i32));

  resize_array[2] = 3;
  resize_array[3] = 4;

  for (i32 i = 0; i < 4; i++) {
    printf("%d ", resize_array[i]);
  }
  printf("\n");

  free(resize_array);
  resize_array = NULL;

  /* ---------------- Functions ---------------- */
  greet();

  // import files from different source
  i32 res = add(2, 5);
  printf("Imported math utility function result: %d\n", res);
  // so in math_utils.h
  // #ifndef MATH_UTILS_H // Include guard (prevents double inclusion)
  // #define MATH_UTILS_H
  //
  // // Function declarations (prototypes)
  // int add(int a, int b);
  // int multiply(int a, int b);
  //
  // #endif
  // and in math_utils.c
  // #include "math_utils.h"

  // Function definitions
  // int add(int a, int b) { return a + b; }
  //
  // int multiply(int a, int b) { return a * b; }
  // run with: gcc main.c math_utils.c -o program && ./program

  return 0;
}

// c processes files from top to bottom, you need a contract to tell c this
// function :    Function Definitions
void greet() { printf("hello there"); }

// run with:
//  gcc -Wall -Wextra -g -fsanitize=address -o main main.c && ./main
// What each flag does:
// -Wall → enable common warnings
// -Wextra → more warnings
// -g → include debug symbols
// -fsanitize=address → enable AddressSanitizer
//
// for learning and debugging
// gcc -Wall -Wextra -Werror -O0 -g -fsanitize=address -o main main.c

// Specifiers
// %d → int
// %p → pointer
// %f → float
// %lf → double
// %lld → long long
//
//
// gcc main.c math_utils.c -o program && ./program
// gcc main.c math_utils.c -o -Wall -Wextra -pedantic program && ./program

// struct vs union
// A structure creates a single, cohesive unit where each member has its own
// dedicated and independent memory location. Memory Allocation: Memory is
// allocated for all members, one after another, in contiguous memory.
// Size: The total size of a structure is the sum of the sizes of all its
// members, plus any potential padding the compiler adds for memory alignment.
// Usage: All members of a structure can be accessed simultaneously, making them
// ideal for data records where all properties are needed at once (e.g., student
// details, an employee record, or a point in 2D space).
//
// Union
// A union allows multiple data types to share the same memory location, meaning
// only one member can store a valid value at any given time. Memory Allocation:
// All members share the same starting address in memory. Size: The total size
// of a union is equal to the size of its largest member. Usage: They are useful
// for memory-saving, especially in memory-constrained systems (like embedded
// systems), or when you have a variable that can hold one of several types but
// never more than one at once. Writing to one member will overwrite the value
// of any other previously stored member.

Generating and Using a New PEM Key for EC2

DrSimple — Tue, 09 Sep 2025 09:09:30 +0000

🔑 Generating and Using a New PEM Key for EC2

1. Create a New Key Pair

In the AWS Console:

Navigate to EC2 → Key Pairs.
Create a new key pair and download the .pem file to your computer. (e.g., new_pemkey.pem)

2. Secure the Key

Run this command to set the correct permissions:

chmod 400 new_pemkey.pem

Generate the Public Key Use ssh-keygen to generate the public key from the .pem file:

ssh-keygen -y -f new_pemkey.pem

Copy the output — this is your public SSH key.

Add the Public Key in the EC2 Instance Open the EC2 instance in the AWS browser console.

Connect via the browser-based SSH client.

Inside the instance, open the authorized_keys file:

vi ~/.ssh/authorized_keys

Paste the public key you generated in Step 3.

Save and exit.

Connect Using the New Key Now you can connect to your EC2 instance from your local terminal:

ssh -i new_pemkey.pem ec2-user@<your-ec2-public-ip>

✅ You’ve successfully created, secured, and configured a new PEM key for your EC2 instance!

Java Notes

DrSimple — Thu, 26 Jun 2025 07:49:19 +0000

Run Java from terminal

javac App.java
java App

Hello World

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

Variables

public class Main {
    public static void main(String[] args) {
        int number = 90;
        double number2 = 90.90;
        float number3 = 90.90F;
        String name = "joe";
        boolean isTall = true;
        char grade = 'A';
        long myId = 90987654345678L;
        byte a = 1;

        System.out.println(a);
        System.out.println(grade);
        System.out.println(myId);
        System.out.println(number);
        System.out.println(number2);
        System.out.println(number3);
        System.out.println(name);
        System.out.println(isTall);

        System.out.println(((Object) number3).getClass().getSimpleName());
        System.out.println(((Object) isTall).getClass().getSimpleName());
    }
}

String Methods

public class Main {
    public static void main(String[] args) {

      String name = "HOLY Spirit";
        System.out.println(name.toLowerCase());
        System.out.println(name.toUpperCase());
    }

}

Enum

public class Main {
    public static void main(String[] args) {

        LEVEL levelHigh = LEVEL.HIGH;
        System.out.println(levelHigh);
        System.out.println(levelHigh.compareTo(LEVEL.LOW));
    }

    enum LEVEL{
        LOW,
        MEDIUM,
        HIGH
    }
}

Condition

public class Main {
    public static void main(String[] args) {
        int age = 90;

        if (age < 18) {
            System.out.println("Underage");
        } else if (age >= 18 && age <= 65) {
            System.out.println("Adult");
        } else {
            System.out.println("Senior");
        }
    }
}

Switch

public class Main {
    public static void main(String[] args) {

        int age = 0;
        switch (age) {
            case 1 -> System.out.println("very young");
            case 2 -> System.out.println("still too young");
            case 9 -> System.out.println("reasonable");
            default -> System.out.println("no age range selected");
        }
    }
}

For Loop

public class Main {
    public static void main(String[] args) {
       int number = 10;

       for(int i = 0; i < number; i++){
           System.out.println("Number is " + i);
       }
    }
}

While Loop

public class Main {
    public static void main(String[] args) {
       int number = 10;

       while(number < 15){
           System.out.println("incrementing with 1: " + number);
           number++;
       }
    }
}

Function

public class Main {
    public static void main(String[] args) {
        int response = addSum(2, 3);
        System.out.println(response);
        System.out.println(((Object) response).getClass().getSimpleName());
    }


    public static int addSum(int a, int b) {
        return a + b;
    }
}

Atomicity

AtomicInteger atomicInt = new AtomicInteger(0);

atomicInt.incrementAndGet(); // ++count
atomicInt.getAndIncrement(); // count++

atomicInt.decrementAndGet(); // --count

atomicInt.addAndGet(5);      // count += 5

int value = atomicInt.get(); // get the current value

boolean updated = atomicInt.compareAndSet(5, 10); 
// if current value == 5, update to 10

Array

public class Main {
    public static void main(String[] args) {

        int[] arrays = {1, 2, 3, 4};
        for (int item : arrays) {
            System.out.println("Item :" + item);
        }
    }

}

Class and Object

public class Main {
    public static void main(String[] args) {

        Person personOne =new Person("joe", 78);
        personOne.speak();
    }

}


 class Person{
    private final String name;
    private final int age;

     public Person(String name, int age) {
         this.name = name;
         this.age = age;
     }

     void speak (){
        System.out.println("Name is " + name + " and age is " + age);
    }
}

Inheritance

public class Main {
    public static void main(String[] args) {

        Person personOne =new Person("joe", 78);
        personOne.speak();
        personOne.scream();
    }

}

class Scream {
    void scream(){
        System.out.println("Ahhhhhhh!");
    }
}

 class Person extends Scream{
    private final String name;
    private final int age;

     public Person(String name, int age) {
         this.name = name;
         this.age = age;
     }

     void speak (){
        System.out.println("Name is " + name + " and age is " + age);
    }
}

Interface

public class Main {
    public static void main(String[] args) {

        Person personOne = new Person("joe");
        personOne.scream();
    }

}

interface Scream {
    void scream();
}

class Person implements Scream {

    private final String name;

    public Person(String name) {
        this.name = name;
    }

    @Override
    public void scream() {
        System.out.println(name + " screamed, Ahhhhh!!!");
    }
}

Static Method

public class Main {
    public static void main(String[] args) {
        double pi = Utils.PI;
        int square = Utils.square(3);
        System.out.println(pi);
        System.out.println(square);

    }

}


class Utils {
    static final double PI = 3.14;

    static int square(int x) {
        return x * x;
    }
}

This

public class Main {
    public static void main(String[] args) {
        Bark dog = new Bark("woof");
        System.out.println(dog.action);
        System.out.println(dog.play());

    }

}

class Bark{
    String action;

    public Bark(String action) {
        this.action = action; // refers to Bark
    }

    boolean play(){
        System.out.println("Joe is " + this.action);
        return false;
    }
}

Constructor Overloading

public class Main {
    public static void main(String[] args) {
        Bark dog = new Bark("woof");

    }

}

class Bark {
    String name;
    String color;

    public Bark(String name, String color) {
        this.name = name;
        this.color = color;
    }

    public Bark(String name){
        this.name = name;
    }
}

Override (Polymorphism)

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.sound();

    }

}

class Animal {
    void sound(){
        System.out.println("woof");
    }
}

class Dog extends Animal{
    @Override
    void sound(){
        System.out.println("Barking...");
    }
}

Abstract

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.sound();

        Animal n = new Animal(); // abstract class cannot be instantiated
    }

}

abstract class Animal {
    void sound(){
        System.out.println("woof");
    }
}

class Dog extends Animal{
    @Override
    void sound(){
        System.out.println("Barking...");
    }
}

super()

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
    }

}


class Animal {
    Animal() {
        System.out.println("Animal created");
    }
}

class Dog extends Animal {
    Dog() {
        super(); // calls Animal constructor
        System.out.println("Dog created");
    }
}

Wrapper Class

public class Main {
    public static void main(String[] args) {
        Integer num = 90;
        Float f1 = 90.90F;      //use wrapper class if you are working with collections, JSON serialization, null-checking
        System.out.println(num.equals(90)); //stick with primitives if you need performance and don't need object features.
    }
//  Wrapper classes provide helper methods (e.g., Integer.parseInt(), Double.compare()).
}

String Builder

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hi");
        sb.append(" there!");
        System.out.println(sb.toString());
    }
}

Null Pointer

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

import static java.lang.Character.getName;

public class Main {
    public static void main(String[] args) {

        try {
            //Avoiding null NPE
            String myName = "";
            int[] myNumbers = new int[10];
            List<String> items = new ArrayList<>();
            System.out.println(myName);
            System.out.println(myNumbers);
            System.out.println(items);

            if (myName != null) {
                System.out.println("printing this");
            }

            String possiblyNullName = "";
            String nullName = possiblyNullName != null ? possiblyNullName : "Unknown";
            System.out.println(nullName);


            String name = null;
            System.out.println(name.length()); //💥 NullPointerException

            int[] numbers = null;
            System.out.println(numbers.length); // 💥 NPE
        } catch (NullPointerException e) {
            System.out.println(e.getMessage());
        }

    }

}

List

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> animals = new ArrayList<>(); //List<Object>
        animals.add("monkey");
        animals.add("lion");
        System.out.println(animals);
        for (String animal: animals){
            System.out.println("I am a/an " + animal);
        }
    }

}

HashMap

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<String, String> response = new HashMap<>();
        response.put("message", "success");
        response.put("status", "ongoing");
        System.out.println(response);
        System.out.println(((Object) response).getClass().getSimpleName());
    }

}

LinkedMap

import java.util.LinkedHashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        // Create a LinkedHashMap
        LinkedHashMap<String, String> capitals = new LinkedHashMap<>();

        // Add key-value pairs
        capitals.put("Nigeria", "Abuja");
        capitals.put("USA", "Washington D.C.");
        capitals.put("France", "Paris");
        capitals.put("Japan", "Tokyo");

        // Iterate in insertion order
        System.out.println("Countries and their Capitals (in insertion order):");
        for (Map.Entry<String, String> entry : capitals.entrySet()) {
            System.out.println(entry.getKey() + " → " + entry.getValue());
        }

        // Access a value
        System.out.println("\nCapital of Japan is: " + capitals.get("Japan"));

        // Check if a key exists
        if (capitals.containsKey("France")) {
            System.out.println("France is in the map.");
        }

        // Remove an entry
        capitals.remove("USA");
        System.out.println("\nAfter removing USA:");
        System.out.println(capitals);
    }
}

Stream

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);

        List<Integer> response = numbers.stream()
                .filter(i -> i % 2 == 0)
                .toList();

        System.out.println(response);
    }

}

Stream

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        List<Integer> response = numbers.stream()
                .filter(i -> i % 2 == 0)
                .toList();

        System.out.println(response);
    }

}

Exception

public class Main {
    public static void main(String[] args) {

        try {
            int response = 10 / 0;
            System.out.println(response);
        }catch (ArithmeticException e){
            System.out.println("Oops!, Error");
        }
    }

}

I/O

import java.io.*;

public class Main {
    public static void main(String[] args) {
        try {
            BufferedReader reader = new BufferedReader(new FileReader("C:\\Users\\CAPTAIN ENJOY\\Downloads\\JavaNote\\src\\text.txt"));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();

            BufferedWriter writer = new BufferedWriter(new FileWriter("C:\\Users\\CAPTAIN ENJOY\\Downloads\\JavaNote\\src\\text.txt"));
            writer.write("ner");
            writer.close();
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }
}

Lambda

import java.io.*;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {

        List<String> names = Arrays.asList("john", "wick", "doe");
        names.forEach(name -> System.out.println("my name is " + name));
    }
}

Constants

public class Main {
    public static void main(String[] args) {

        final int MAX_ATTEMPTS = 909090;
        // MAX_ATTEMPTS = 200; // ❌ Will cause error
        System.out.println(MAX_ATTEMPTS);
    }
}

SOLID

SOLID Principles (OOP Best Practices) S — Single Responsibility Principle (SRP) Each class should have one job. Example: A UserService should only handle user logic, not email sending.

class UserService {
    void registerUser(User user) { /* ... */ }
}

class EmailService {
    void sendWelcomeEmail(User user) { /* ... */ }
}

O — Open/Closed Principle (OCP)
Classes should be open for extension, but closed for modification.
Example:
Instead of modifying payment logic, extend it:

interface Payment {
    void pay();
}

class CreditCardPayment implements Payment {
    public void pay() { /* ... */ }
}

class UpiPayment implements Payment {
    public void pay() { /* ... */ }
}

L — Liskov Substitution Principle (LSP)
Subclasses should replace base classes without breaking behavior.
Example:
If Bird can fly, then Penguin shouldn't extend Bird if it can't fly.

I — Interface Segregation Principle (ISP)
Don’t force classes to implement unnecessary methods.
Bad:

interface Animal {
    void fly(); // forces Dog to implement this unnecessarily
}

Good:

interface Bird { void fly(); }
interface Dog { void bark(); }

D — Dependency Inversion Principle (DIP)
Depend on abstractions, not concrete classes.

class NotificationService {
    private MessageSender sender;

    NotificationService(MessageSender sender) {
        this.sender = sender;
    }

    void notify(String msg) {
        sender.send(msg);
    }
}

SpringBoot Environment Variable

DrSimple — Mon, 16 Jun 2025 07:01:31 +0000

🌱 How to Use Environment Variables in Spring Boot

Spring Boot makes it easy to load and use environment variables securely and cleanly. Whether you're building a local app or deploying to production, managing secrets and configs via environment variables is a best practice.

In this guide, you'll learn how to:

Read environment variables in application.properties
Use .env files (locally)
Inject variables into Java code
Use Spring profiles for different environments

📦 1. Using Environment Variables in `application.properties`

Spring Boot automatically maps environment variables to properties.

# src/main/resources/application.properties
server.port=${PORT:8080}
spring.datasource.url=${DB_URL}
spring.datasource.username=${DB_USER}
spring.datasource.password=${DB_PASSWORD}

Note:

${PORT:8080} — Uses the PORT environment variable or defaults to 8080.
${DB_URL} — Fails to start if DB_URL is not set.

🌍 2. Setting Environment Variables

✅ Unix/macOS

export PORT=8081
export DB_URL=jdbc:mysql://localhost:3306/mydb
export DB_USER=root
export DB_PASSWORD=secret

✅ Windows (CMD)

set PORT=8081
set DB_URL=jdbc:mysql://localhost:3306/mydb
set DB_USER=root
set DB_PASSWORD=secret

You can also set these in Docker Compose, Kubernetes, or your cloud platform settings.

📄 3. Using a .env File Locally (Optional)

Spring Boot doesn't load .env by default, but you can use dotenv-java or configure your IDE to do so.

Using dotenv-java:

# .env
PORT=8082
DB_URL=jdbc:mysql://localhost:3306/mydb
DB_USER=root
DB_PASSWORD=secret

Add dependency to pom.xml:

<dependency>
  <groupId>io.github.cdimascio</groupId>
  <artifactId>dotenv-java</artifactId>
  <version>3.0.0</version>
</dependency>

Load in your main():

import io.github.cdimascio.dotenv.Dotenv;

@SpringBootApplication
public class MainApp {
    public static void main(String[] args) {
        Dotenv dotenv = Dotenv.load();
        SpringApplication.run(MainApp.class, args);
    }
}

🔁 4. Accessing Environment Variables in Java Code
Spring allows you to inject values using @Value:

@Value("${DB_USER}")
private String dbUser;

Or use Environment:

@Autowired
private Environment env;

public void printEnv() {
    System.out.println(env.getProperty("DB_USER"));
}

🎯 5. Use Spring Profiles for Environments

Create different config files for dev, test, and prod:

Set active profile
export SPRING_PROFILES_ACTIVE=dev


# application-dev.properties
logging.level.root=DEBUG

# application-prod.properties
logging.level.root=ERROR

Spring will automatically load the file that matches the active profile.

📦 6. Using Environment Variables in application.yml

If you use YAML instead of .properties:

server:
  port: ${PORT:8080}

spring:
  datasource:
    url: ${DB_URL}
    username: ${DB_USER}
    password: ${DB_PASSWORD}

✅ Summary
✅ You can use environment variables in Spring Boot via:

${ENV_VAR} in application.properties or application.yml
@Value or Environment in code
Profiles for multiple environments
.env support with a helper library

🎯 Keep your apps secure, portable, and environment-agnostic by externalizing your configuration.

What Does Jackson Do in a Spring Boot Application?

DrSimple — Mon, 16 Jun 2025 06:56:48 +0000

➤ Serialization:

Converts Java objects → JSON
Used when sending responses from controllers.

@GetMapping("/user")
public User getUser() {
    return new User("John", 25);  // 👈 Spring uses Jackson to convert this to JSON
}

Result:

{
  "name": "John",
  "age": 25
}

➤ Deserialization:

Converts JSON → Java objects
Used when receiving data in request bodies.

@PostMapping("/user")
public ResponseEntity<?> createUser(@RequestBody User user) {
    // 👈 Jackson maps incoming JSON into a User object
    return ResponseEntity.ok("User created");
}

📦 Where Is Jackson in Spring Boot?

You don’t have to manually add Jackson — it’s included automatically with:

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId> ✅ includes Jackson
</dependency>

Under the hood, Spring Boot uses:

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
</dependency>

⚙️ Customizing Jackson (Optional)

You can customize how JSON is handled:

@Bean
public ObjectMapper objectMapper() {
    ObjectMapper mapper = new ObjectMapper();
    mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    return mapper;
}

Or use annotations:

@JsonProperty("user_name")
private String name;

@JsonIgnore
private String password;

✅ Summary

Feature	Handled by Jackson in Spring Boot
Return JSON from controller	✅ Serialize Java → JSON
Accept JSON in request	✅ Deserialize JSON → Java
Customize format	✅ With annotations or config
Built-in with Spring Boot	✅ via `spring-boot-starter-web`

Spring Boot Annotation Guide

DrSimple — Fri, 13 Jun 2025 07:47:58 +0000

🌱 Spring Boot Core Annotations Guide

This guide explains the most commonly used annotations in Spring Boot. Each annotation is presented with a clear definition, usage example, explanation, and tips on when to use it.

🔧 `@Bean`

📝 Definition:

Marks a method that returns a Spring-managed object (bean), also known as a Spring Managed Bean — an object created, configured, and managed by the Spring IoC container.

📌 Usage:

Used inside a @Configuration class to define custom beans manually.

@Bean
public RestTemplate restTemplate() {
    return new RestTemplate();
}

💡 Explanation:

The @Bean tells Spring:

“Please call this method, and register the returned object (RestTemplate) as a bean in the application context.”
Anywhere you @Autowired RestTemplate, Spring will inject this same instance.

🧠 Why use it?

Use @Bean when:

You want full control over how the object is created.
You need to configure third-party classes (e.g., RestTemplate, ObjectMapper, etc.) that you can’t annotate with @Component.

🏗️ `@Configuration`

📝 Definition:

Marks a class that defines one or more @Bean methods. It tells Spring this class contains bean definitions to be managed by the Spring container.

📌 Usage:

Used to centralize bean creation using methods annotated with @Bean.

@Configuration
public class AppConfig {
    @Bean
    public MyService myService() {
        return new MyService();
    }
}

💡 Explanation:

Acts as a configuration blueprint for Spring.
Helps Spring manage lifecycle and dependencies of beans.

🧠 Why use it?

Use @Configuration when:

You want to define multiple beans manually.
You prefer Java-based configuration over XML.
You need conditional or advanced bean setup logic.

🧱 `@Component`

📝 Definition:

Generic annotation to mark a class as a Spring-managed bean.

📌 Usage:

Used on utility or helper classes that don’t fit into other stereotypes like @Service or @Repository.

@Component
public class EmailValidator {
    public boolean isValid(String email) {
        return email.contains("@");
    }
}

💡 Explanation:

Automatically detected by Spring during component scanning.
Registered as a singleton bean in the context.

🧠 Why use it?

Use @Component when:

You want Spring to detect and manage a class automatically.
It’s a utility, config helper, or shared logic class.

🧠 `@Service`

📝 Definition:

Specialization of @Component used to mark service-layer classes that contain business logic.

📌 Usage:

Used for classes that implement business operations or domain logic.

@Service
public class PaymentService {
    public void processPayment() {
        // business logic
    }
}

💡 Explanation:

Discovered by Spring during scanning.
Injected where needed for business operations.

🧠 Why use it?

Use @Service when:

The class holds core business logic.
You want clear separation between business and infrastructure layers.

🗄️ `@Repository`

📝 Definition:

Specialization of @Component for data access logic (DAO layer). Enables Spring's automatic exception translation.

📌 Usage:

Used on classes or interfaces that interact with the database.

@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {}

💡 Explanation:

Handles low-level persistence exceptions.
Translates JDBC/ORM exceptions to Spring's DataAccessException.

🧠 Why use it?

Use @Repository when:

You interact with the database.
You want Spring to handle exception translation.

🌐 `@Controller`

📝 Definition:

Marks a class as a Spring MVC controller responsible for handling web requests and returning views.

📌 Usage:

Used in MVC-based applications to return HTML (e.g., Thymeleaf, JSP).

@Controller
public class WebController {
    @GetMapping("/")
    public String home() {
        return "index"; // returns index.html
    }
}

💡 Explanation:

Maps HTTP requests to methods.
Returns view names for rendering.

🧠 Why use it?

Use @Controller when:

Building a server-side rendered web app.
Returning HTML templates.

📡 `@RestController`

📝 Definition:

A convenience annotation that combines @Controller and @ResponseBody. Returns data (e.g., JSON) instead of views.

📌 Usage:

Used for building RESTful API endpoints.

@RestController
public class ApiController {
    @GetMapping("/status")
    public String status() {
        return "OK";
    }
}

💡 Explanation:

Treats all methods as if they had @ResponseBody.
Automatically serializes return values to JSON or XML.

🧠 Why use it?

Use @RestController when:

Building REST APIs.
Returning data instead of HTML.

🧾 Tip: @Component, @Service, @Repository, and @Controller are auto-detected via component scanning.

@Bean and @Configuration are used for manual bean definitions.

📋 Spring Boot Annotations Summary

Annotation	Layer/Type	Purpose	Auto-Detected	Returns Data	Usage Context
`@Bean`	Configuration	Declares a manually created Spring bean	❌ No	✅ Yes	Used in `@Configuration` classes
`@Configuration`	Configuration	Declares a class containing `@Bean` definitions	✅ Yes	❌ No	Java-based configuration
`@Component`	Generic Bean	Generic stereotype for any Spring-managed class	✅ Yes	❌ No	Utility classes, general-purpose
`@Service`	Service Layer	Marks a class that holds business logic	✅ Yes	❌ No	Business logic layer
`@Repository`	Data Access	DAO layer, adds exception translation for persistence	✅ Yes	❌ No	Database access classes
`@Controller`	Web MVC	Handles web requests and returns HTML views	✅ Yes	❌ No	Server-side rendered web apps
`@RestController`	Web API (REST)	Combines `@Controller` + `@ResponseBody` to return JSON/XML	✅ Yes	✅ Yes	REST API endpoints

Just Enough Linux

DrSimple — Tue, 22 Apr 2025 18:05:55 +0000

sudo apt update           # updates the package list from repositories (does not install)
sudo apt upgrade -y       # upgrades all upgradable packages (-y auto-confirms)

Install utility


sudo apt install open-vm-tools           # installs essential VMware guest utilities
sudo apt install open-vm-tools-desktop   # installs GUI support for VMware tools

linux boot process

BIOS       # Basic Input/Output System: performs hardware checks (POST), then hands off to bootloader
BOOTLOADER # e.g., GRUB: loads the kernel into memory
KERNEL     # Core of the OS: manages hardware, memory, processes, and drivers
INIT       # Initializes system processes (now typically systemd)
LOGIN      # User authentication screen or shell prompt

Check the shell you are using

which $SHELL

Writing script

create a script file called test.bash

touch test.sh

And paste:

echo "hello world"

Run by typing

zsh test.sh

Or run with

./test.sh

You can write any linux command

echo "hello world"
ls
date

Linux command

pwd - print working directory
whoami - display current username
history - show all commands that have been used 
date - current date time 
man - manual (man pwd, man date) 
who - shows who is logged in 
w - same as who
sudo su - login as a super user

Variable

NB: ensure no space between the var and equal to sign

var="abayomi"
echo $var

mathematical operation

for operations use (())

num1=8
num2=9
num3=$((num1 + num2))
echo $num3

Take input from users

echo "enter first number: "
read var1
echo "enter second number: "
read var2

answer=$((var1 + var2))
echo $answer

Shell scripting

if you don write the shell to use your os will take the default

#!/bin/zsh   
echo "hello james"

to give it executabel rights

chmod 755 test.sh

A script to create a nodejs app

#!/bin/zsh

echo "🚀 Creating a new production-grade TypeScript Node.js project..."

# Set your project name
PROJECT_NAME="npmproj"

# Create project directory
mkdir $PROJECT_NAME && cd $PROJECT_NAME


if [ -z "$PROJECT_NAME" ]; then
  echo "❌ Error: Project name not provided."
  echo "Usage: ./create-ts-node-project.sh <project-name>"
  exit 1
fi

# Initialize npm
npm init -y

echo "📦 Installing production dependencies..."
npm install express bcryptjs jsonwebtoken nodemailer cors helmet compression

echo "🛠️ Installing dev dependencies..."
npm install -D typescript ts-node-dev @types/node @types/express @types/bcryptjs @types/jsonwebtoken @types/cors dotenv

# Initialize TypeScript project
npx tsc --init

# Create tsconfig.json modifications (replace content)
cat > tsconfig.json <<EOF
{
  "compilerOptions": {
    "target": "ES2020",
    "module": "CommonJS",
    "rootDir": "src",
    "outDir": "dist",
    "strict": true,
    "esModuleInterop": true,
    "forceConsistentCasingInFileNames": true,
    "skipLibCheck": true
  },
  "include": ["src"],
  "exclude": ["node_modules"]
}
EOF

# Create project structure
mkdir -p src/{controllers,routes,services,models,config,utils,middlewares}
touch src/index.ts

# Create .env file
cat > .env <<EOF
PORT=5000
JWT_SECRET=your_jwt_secret
EOF

# Create .gitignore
cat > .gitignore <<EOF
node_modules
dist
.env
EOF

# Add a start script to package.json
npx json -I -f package.json -e 'this.scripts={
  "dev": "ts-node-dev --respawn src/index.ts",
  "build": "tsc",
  "start": "node dist/index.js"
}'

echo "✅ Project setup complete!"
echo "📂 Structure:"
tree src

# Run:
chmod +x create-ts-node-project.sh
./create-ts-node-project.sh my-new-app

Getting help command line

e.g for ls
ls --help

You can use the man

man ls
info ls # this is another way of getting help

Remove directory

rmdir <directory name>
rm -rf <directory name> # removing directory which is not empty

Finding files

find . -name "*.txt"  # finds all .txt files in current directory and subdirs
find  <filename>
find test.sh
find ~/Downloads/ -name app.ts
find ~/Downloads/ -iname app.ts # iname will ignore case sensitivity
find ~/Downloads/ -mtime -30 #find files that have been created in the last 30 days
find /mnt/c/Users/CAPTAIN\ ENJOY/Downloads -mtime -30
find /mnt/c/Users/CAPTAIN\ ENJOY/Downloads -mtime -30 -size -10M # shows files with size less than 10 created in the last 30 days
find /mnt/c/Users/CAPTAIN\ ENJOY/Downloads -mtime -30 -size +10M # shows files with size less than 10 created in the last 30 days

List files

ls -lh #shows files with the size
ls -lt #shows files based on the last modified date
ls -ls #sort files based on their sizes
ls -lra #reverse the order sorting

Edit files

cat >test.md
then write your content here
then click enter and press control c

Number Permission Type Symbol

Value	Permission Name	Symbol
0	No Permission	---
1	Execute	--x
2	Write	-w-
3	Write & Execute	-wx
4	Read	r--
5	Read & Execute	r-x
6	Read & Write	rw-
7	Read, Write & Execute	rwx

Read write execute

chmod 777 test.sh # This gives read, write, and execute permissions to everyone (owner, group, others)

When dealing with Linux file permissions using chmod, you can modify read (r), write (w), and execute (x) permissions for:

u – user (owner)

g – group

o – others

a – all (user + group + others)

And you use operators like:

– add permission
– remove permission

= – set exact permission (removes others)

Command | Meaning

chmod u+x file | Add execute to user
chmod g-w file | Remove write from group
chmod o=r file | Set others to read only
chmod a+rw file | Add read and write to everyone
chmod ug+x file | Add execute to user and group
chmod u=rwx file | Give user full permissions (read, write, execute)
chmod g=rw file | Set group permissions to read and write
chmod o= file | Remove all permissions from others
chmod a-x file | Remove execute from everyone
chmod ugo=r file | Set read-only for all (user, group, others)

remove command

rm file.sh
unlink file.sh

Rename

mv fileone.sh filetwo.sh

copy command

cp main.go test.go

diff space

diff a.sh b.sh
diff -y -W 60 a.sh b.sh
diff -q a.sh b.sh

pipes

touch abacus shubacus lidacus xyx bingo
ls | grep "cus" # find all files that have the name cus in them

You should have

abacus
lidacus
shubacu

 find -name '*.txt' | xargs cat #find all files with name .txt and read

input output redirection

cat > file.txt
                     #this will open the edit command to write

write into a file

ls -al > test.md

Count number of lines

wc -l test.md # count the number of lines  i.e word count
wc -l < test.md # count the number of lines and redirect the output

Redirect command

program 2> abc # i,e program is not valid command line, so it will redirect the error into the abc file

So this will create the abc file and then put the error message there

zsh: command not found: program

append

cat >> hello.txt

Shell aliases

alias e="echo"

NB: the session will not be saved, to save, go to your shell like the bashrc or the zshrc and save it there

for bash vim .bashrc if zsh vim ~/.zshrc

alias v="nvim"

To unalias

unalias v

Environment variable

echo $PATH
echo $USER
printenv $HOME #prints a particular one 
printenv #prints all

Create new variable (Local variables)

NEWVARIABLE=xyborg_key
echo $NEWVARIABLE
unset NEWVARIABLE

Global variables

export VAR=linux
echo $VAR

Shell history

echo $HISTFILESIZE #means we have capacity to store the output amount of commands 
echo $HISTSIZE # this is the capacity per session
history # shows the history
history 10 # shows last 10 commands
history | tail -10 # show last 10 commands
history | more #shows full screen command
Ctrl r #looks for all the commands you have type in a greplike way

history and execute

history # shows all commands used
!233 #the number of the command you want to target
!-5 #shows and list the last 5 commands

Processing and job scheduling

crontab -l ### checks if there is any cron job for the user
#you should get
no crontab for xybor

Create a cron

sudo crontab -e

Then you will be given options to select as your editor

no crontab for root - using an empty one

Select an editor.  To change later, run 'select-editor'.
  1. /bin/nano        <---- easiest
  2. /usr/bin/vim.basic
  3. /usr/bin/vim.tiny
  4. /bin/ed

Choose 1-4 [1]:

#i chose 2

Then in the opened file, put your cron there

* * * * * <cmd here>
* * * * * ls

Disk and file

df
df -h
df -a

package manager

sudo apt install htop 
sudo apt remove htop

Process Management

ps aux         # show all running processes
top            # interactive view of system processes
htop           # improved interactive process viewer (if installed)
kill PID       # send signal (default SIGTERM) to a process
kill -9 PID    # force kill a process

File Permissions (Symbolic notation)

chmod u+x file     # add execute for user
chmod g-w file     # remove write for group
chmod o=r file     # set read-only for others
chmod a+x file     # add execute for all

User Management (Basic)

adduser newuser     # create a new user
passwd newuser      # set password for user
su - newuser        # switch user
id                  # display user ID and group info
groups              # show groups current user belongs to

Network Commands

ip a             # show IP addresses
ping google.com  # test connectivity
netstat -tuln    # show all listening ports
ss -tuln         # more modern alternative to netstat

File Compression

tar -czvf archive.tar.gz folder/   # compress
tar -xzvf archive.tar.gz           # extract
zip archive.zip file               # zip
unzip archive.zip                  # unzip

Grep and Search

grep "pattern" file         # find pattern in file
grep -r "pattern" folder/   # recursively grep in directory

System Information

uname -a         # kernel and architecture info
uptime           # system uptime
free -h          # memory usage
lscpu            # CPU architecture info
lsblk            # list block devices

APT Utilities

apt search <pkg>    # search for a package
apt show <pkg>      # show package details
apt list --installed # list all installed packages

awk and sed Basics (Text Processing Tools)

# awk for column/line processing
awk '{print $1}' file.txt         # Print first column
awk -F':' '{print $1}' /etc/passwd

# sed for text replacement
sed 's/old/new/' file.txt         # Replace first match per line
sed 's/old/new/g' file.txt        # Replace all matches per line

User Management

whoami                         # Current user (already listed)
id                             # Show current UID, GID, and groups
adduser newuser                # Add a new user
passwd newuser                 # Set password
deluser newuser                # Delete user
usermod -aG group user         # Add user to group
groups                         # Show groups of current user

Group Management

groupadd devs                  # Create group
groupdel devs                  # Delete group
gpasswd -a user devs           # Add user to group
gpasswd -d user devs           # Remove user from group

File Permissions Advanced (Ownership)

chown user:group file          # Change owner and group
chown -R user:group dir/       # Recursively change ownership

Networking Commands

ip a                          # Show IP addresses (modern replacement for ifconfig)
ifconfig                      # Deprecated but common
ping google.com               # Check network connection
netstat -tulnp                # Show ports/services listening
ss -tulwn                     # Faster alternative to netstat
curl https://example.com      # Make HTTP request
wget https://example.com      # Download file from URL

Process Management

ps aux                        # View running processes
top                           # Real-time process viewer
htop                          # Better version of top (already mentioned)
kill <PID>                    # Kill a process by PID
killall <name>                # Kill all by name
nice -n 10 command            # Run command with adjusted priority

System Info

uname -a                      # Kernel and architecture info
uptime                        # System uptime
hostname                      # Machine name
lsb_release -a                # OS version info
free -h                       # Memory usage

Permissions: Sticky, SUID, SGID

chmod +t dir/                 # Sticky bit (like /tmp)
chmod u+s file                # SUID - run as file owner
chmod g+s file                # SGID - run as group owner

Scheduling Jobs with at

at now + 5 minutes
> echo "echo Hello" >> ~/message.txt
> <Ctrl+D> to save

Systemctl / Services (for systemd systems)

systemctl start nginx
systemctl stop nginx
systemctl restart nginx
systemctl status nginx
systemctl enable nginx        # Enable on boot
systemctl disable nginx       # Disable on boot

Open command

open t.sh # mac specific

Head

head readme.md # reads the first first ten
tail readme.md #reads last ten
less readme.md # opens file for scrolling and viewing one screen at a time
sort file.txt #sorts lines in a file alphabetically

word count

wc readme.md  # counts lines, words, and bytes in file.txt
cat readme.md | wc -l #counts the number of lines in file.txt using a pipe

disk usage

du -h  # shows disk usage of files and folders in human-readable format
df -h  # shows disk space usage of mounted filesystems
ps aux  # displays all running processes with detailed info
top  # shows real-time system resource usagetop  # shows real-time system resource usage
kill 1234  # sends a signal (default: TERM) to process ID 1234
killall firefox  # kills all processes named firefox

compress

gzip file.txt  # compresses file.txt to file.txt.gz
gunzip file.txt.gz  # decompresses a .gz file

tar

tar -cvf archive.tar files/  # creates a tar archive
tar -xvf archive.tar         # extracts a tar archive

xargs

echo "file1 file2" | xargs rm  # removes file1 and file2 using xargs

link

ln -s target link  # creates a symbolic link (shortcut) to target

Install psql in WSL

DrSimple — Sun, 30 Mar 2025 21:14:47 +0000

Remove old postgres

sudo apt remove --purge postgresql\* -y

Remove binary if exist

sudo rm -f /usr/bin/psql
sudo rm -f /usr/share/postgresql-common
sudo rm -rf /usr/lib/postgresql

Clear dependencies if exist

sudo apt autoremove -y
sudo apt autoclean

which psql

which psql

This should return not found

Install new postgres

sudo apt update
sudo apt install postgresql postgresql-contrib libpq-dev
sudo service postgresql start

psql --version

Set new user and role

sudo -u postgres createuser -s xyborg -P

login as xyborg

psql -U xyborg -d postgres

create db

create database lilo

connect db

\c lilo

Google Sheets as a Database with Node.js and Google APIs

DrSimple — Fri, 07 Mar 2025 07:42:32 +0000

Google Sheets can be a simple and effective way to store structured data. In this guide, you'll learn how to integrate Google Sheets with a Node.js (TypeScript) application using the googleapis package.

🚀 Step 1: Create a New Google Cloud Project

Go to Google Cloud Console
Click New Project

🔍 Step 2: Enable Google Sheets API

Search for Google Sheets API

Click Enable

🔑 Step 3: Create Credentials

Navigate to the Credentials tab
Click Create Credentials → Service Account

Select Application Data → Click Next

Click Create and Continue, then Done

🔐 Step 4: Generate JSON Key

Go to Credentials → Select the service account you created

Navigate to Keys → Click Add Key → Create New Key

A JSON file will be downloaded. Keep it safe!

📄 Step 5: Share Google Sheet Access

Create a new Google Sheet
Click Share

Open the downloaded JSON file and find client_email

Paste the copied email in the Share section and give Editor access.

⚙️ Step 6: Set Up Node.js Project

1️⃣ Install Dependencies

npm init -y
npm install googleapis dotenv

2️⃣ Write Code to Save Data to Google Sheets

import { google } from "googleapis";
import fs from "fs";
import dotenv from "dotenv";

dotenv.config();

const credentials = JSON.parse(fs.readFileSync("path-to-downloaded-json-key.json", "utf8"));

const auth = new google.auth.GoogleAuth({
  credentials,
  scopes: ["https://www.googleapis.com/auth/spreadsheets"],
});

async function saveToGoogleSheet(data: any[]) {
  const sheets = google.sheets({ version: "v4", auth });

  const values = data.map((item) => [
    item.firstName,
    item.lastName,
    item.email,
    item.phone,
    item.plan,
    item.premium_amount,
    item.start_policy_date,
    item.end_policy_date,
  ]);

  await sheets.spreadsheets.values.append({
    spreadsheetId: process.env.GOOGLE_SHEET_ID!,
    range: "Sheet1!A2", // Adjust based on your sheet structure
    valueInputOption: "RAW",
    requestBody: { values },
  });

  console.log("Data saved successfully!");
}

const exampleData = [
  {
    firstName: "John",
    lastName: "Doe",
    email: "johndoe@example.com",
    phone: "+1234567890",
    plan: "Gold Plan",
    premium_amount: 50000,
    start_policy_date: "2025-01-01",
    end_policy_date: "2026-01-01",
  },
];

saveToGoogleSheet(exampleData).catch(console.error);

🔍 Step 7: Get Your Google Sheet ID

To find your Sheet ID, look at the URL of your Google Sheet.

Copy this ID and set it in your .env file:

GOOGLE_SHEET_ID=your-google-sheet-id

✅ Step 8: Test Your Code

Run your script and check your Google Sheet. You should see something like this:

🎯 Conclusion

You’ve successfully integrated Google Sheets with Node.js using the Google Sheets API! 🎉

This method is great for small projects, logging data, or quickly storing structured records without setting up a database. If you need more complex features, consider using a dedicated database like Firebase, PostgreSQL, or MongoDB.

Got questions? Drop them in the comments below! 🚀

Flask rest api

DrSimple — Sun, 12 Jan 2025 07:51:12 +0000

Forem: DrSimple

Spring Shell

Track my expense using Spring Shell

Repository (JDBC)

Service

Controller (Spring Shell CLI)

Main app

Java Security

flow

Jwt structure

Simplified flow in Spring security

Dependecies

config in properties

Create user

AuthService

AuthController

C notes

Generating and Using a New PEM Key for EC2

🔑 Generating and Using a New PEM Key for EC2

1. Create a New Key Pair

2. Secure the Key

Java Notes

Run Java from terminal

Hello World

Variables

String Methods

Enum

Condition

Switch

For Loop

While Loop

Function

Atomicity

Array

Class and Object

Inheritance

Interface

Static Method

This

Constructor Overloading

Override (Polymorphism)

Abstract

super()

Wrapper Class

String Builder

Null Pointer

List

HashMap

LinkedMap

Stream

Stream

Exception

I/O

Lambda

Constants

SOLID

SpringBoot Environment Variable

🌱 How to Use Environment Variables in Spring Boot

📦 1. Using Environment Variables in application.properties

Note:

🌍 2. Setting Environment Variables

✅ Windows (CMD)

📄 3. Using a .env File Locally (Optional)

Load in your main():

🎯 5. Use Spring Profiles for Environments

📦 6. Using Environment Variables in application.yml

What Does Jackson Do in a Spring Boot Application?

➤ Serialization:

➤ Deserialization:

📦 Where Is Jackson in Spring Boot?

⚙️ Customizing Jackson (Optional)

Or use annotations:

✅ Summary

Spring Boot Annotation Guide

🌱 Spring Boot Core Annotations Guide

🔧 @Bean

🏗️ @Configuration

🧱 @Component

🧠 @Service

🗄️ @Repository

📦 1. Using Environment Variables in `application.properties`

🔧 `@Bean`

🏗️ `@Configuration`

🧱 `@Component`

🧠 `@Service`

🗄️ `@Repository`

🌐 `@Controller`

📡 `@RestController`