Spring Boot Tutorial

Su Suriya Ravichandran Updated 18 Nov 2026
12 min read ·Lesson 278 of 306

Spring Boot is a layer on top of the Spring Framework that turns a few lines of code into a running, production-ready application. It picks sensible defaults, configures beans automatically based on the libraries you add, and starts an embedded Tomcat server, so there is no WAR to build and no server to install. This Spring Boot tutorial builds a CourseHub REST service from an empty folder to an executable JAR.

The examples use Spring Boot 4.1.2 (Spring Framework 7) with Java 25. Spring Boot 4 needs Java 17 or newer.


What Spring Boot Adds to Spring

FeatureWhat it does for you
StartersOne dependency per feature (spring-boot-starter-webmvc) brings every library it needs, in compatible versions
Auto-configurationCreates beans such as the DispatcherServlet, JSON converter and DataSource when the right classes are on the classpath
Embedded serverTomcat runs inside your application; java -jar starts everything
Externalized configurationapplication.properties, environment variables and command-line arguments set values without code changes
ProfilesSeparate settings for dev, test and prod
ActuatorReady-made health, info and metrics endpoints

How it works:

  • Everything from Spring Framework Basics still applies: beans, constructor injection, @Component, @Value and profiles. Spring Boot simply creates the ApplicationContext and much of the configuration for you.
  • In the Java Web Application lesson you wrote a WAR and deployed it to a separate Tomcat. With Spring Boot, Tomcat is a library inside your JAR.

Create a Project With Spring Initializr

Open start.spring.io, choose Maven, Java, Spring Boot 4.1.2 and Java 25, set the group to com.gocourse and artifact to coursehub, and add the Spring Web and Spring Boot Actuator dependencies. The same project can be downloaded from the command line:

curl https://start.spring.io/starter.zip \
  -d type=maven-project -d language=java \
  -d bootVersion=4.1.2 -d javaVersion=25 \
  -d groupId=com.gocourse -d artifactId=coursehub -d name=CourseHub \
  -d packageName=com.gocourse.coursehub \
  -d dependencies=web,actuator \
  -o coursehub.zip
unzip coursehub.zip -d coursehub && cd coursehub
coursehub/
├── mvnw, mvnw.cmd                  Maven wrapper (no Maven install needed)
├── pom.xml
└── src/
    ├── main/
    │   ├── java/com/gocourse/coursehub/CourseHubApplication.java
    │   └── resources/
    │       ├── application.properties
    │       ├── static/             CSS, JS, images served as-is
    │       └── templates/          server-side HTML templates
    └── test/java/com/gocourse/coursehub/CourseHubApplicationTests.java

How it works:

  • The Maven wrapper (./mvnw) downloads the right Maven version on first use, so every developer builds the same way.
  • static/ files are served directly at the site root. templates/ is used by template engines such as Thymeleaf in the Spring MVC lesson.

The pom.xml: Parent, Starters and Plugin

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>4.1.2</version>
    <relativePath/>
</parent>

<groupId>com.gocourse</groupId>
<artifactId>coursehub</artifactId>
<version>0.0.1-SNAPSHOT</version>

<properties>
    <java.version>25</java.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-webmvc</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-webmvc-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

How it works:

  • The parent POM manages versions of hundreds of libraries, which is why the starters have no <version>. Upgrading Spring Boot upgrades all of them together.
  • spring-boot-starter-webmvc brings Spring MVC, embedded Tomcat and Jackson for JSON. In Spring Boot 3 this starter was called spring-boot-starter-web.
  • spring-boot-maven-plugin adds the spring-boot:run goal and repackages the build into an executable JAR.

The Main Class and @SpringBootApplication

package com.gocourse.coursehub;

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

@SpringBootApplication
public class CourseHubApplication {
    public static void main(String[] args) {
        SpringApplication.run(CourseHubApplication.class, args);
    }
}
./mvnw spring-boot:run

Output (shortened):

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v4.1.2)

INFO  Starting CourseHubApplication using Java 25 with PID 41872
INFO  No active profile set, falling back to 1 default profile: "default"
INFO  Tomcat initialized with port 8080 (http)
INFO  Tomcat started on port 8080 (http) with context path '/'
INFO  Started CourseHubApplication in 1.6 seconds (process running for 1.9)
@SpringBootApplication combinesPurpose
@SpringBootConfigurationMarks the class as a @Configuration source
@EnableAutoConfigurationTurns on auto-configuration
@ComponentScanScans com.gocourse.coursehub and all sub-packages

How it works:

  • SpringApplication.run creates the application context, runs auto-configuration, starts Tomcat and keeps the JVM alive until you press Ctrl+C.
  • Keep the main class in the root package. Classes outside com.gocourse.coursehub are not scanned and silently ignored.

Build Your First REST Endpoint

package com.gocourse.coursehub;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello(@RequestParam(defaultValue = "student") String name) {
        return "Hello, " + name + "! Welcome to CourseHub.";
    }
}
curl http://localhost:8080/hello
curl "http://localhost:8080/hello?name=Asha"

Output:

Hello, student! Welcome to CourseHub.
Hello, Asha! Welcome to CourseHub.

How it works:

  • @RestController is a @Component, so component scanning finds it. Its return values are written straight into the response body.
  • @GetMapping("/hello") maps HTTP GET /hello to the method, and @RequestParam reads ?name= with a default when it is missing.
  • Compare this with a servlet: no doGet, no getWriter(), no URL mapping in web.xml. Spring MVC's DispatcherServlet, created by auto-configuration, does the routing.

Return JSON From a Service and Controller

Records returned from a controller become JSON automatically.

package com.gocourse.coursehub.course;

public record Course(String code, String title, int feeInr) {}
package com.gocourse.coursehub.course;

import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import org.springframework.stereotype.Service;

@Service
public class CourseService {

    private final Map<String, Course> courses = new ConcurrentHashMap<>();

    public CourseService() {
        save(new Course("java", "Java Programming", 4999));
        save(new Course("go", "Go Language", 2999));
    }

    public List<Course> findAll() {
        return courses.values().stream().sorted(Comparator.comparing(Course::code)).toList();
    }

    public Optional<Course> findByCode(String code) {
        return Optional.ofNullable(courses.get(code));
    }

    public Course save(Course course) {
        courses.put(course.code(), course);
        return course;
    }
}
package com.gocourse.coursehub.course;

import java.net.URI;
import java.util.List;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.server.ResponseStatusException;

@RestController
@RequestMapping("/api/courses")
public class CourseController {

    private final CourseService courseService;

    public CourseController(CourseService courseService) {
        this.courseService = courseService;
    }

    @GetMapping
    public List<Course> all() {
        return courseService.findAll();
    }

    @GetMapping("/{code}")
    public Course one(@PathVariable String code) {
        return courseService.findByCode(code)
                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "No course " + code));
    }

    @PostMapping
    public ResponseEntity<Course> create(@RequestBody Course course) {
        Course saved = courseService.save(course);
        return ResponseEntity.created(URI.create("/api/courses/" + saved.code())).body(saved);
    }
}
curl http://localhost:8080/api/courses
curl -i -X POST http://localhost:8080/api/courses \
     -H "Content-Type: application/json" \
     -d '{"code":"docker","title":"Docker Essentials","feeInr":1999}'
curl -i http://localhost:8080/api/courses/rust

Output:

[{"code":"go","title":"Go Language","feeInr":2999},{"code":"java","title":"Java Programming","feeInr":4999}]

HTTP/1.1 201
Location: /api/courses/docker
Content-Type: application/json

{"code":"docker","title":"Docker Essentials","feeInr":1999}

HTTP/1.1 404
Content-Type: application/json

{"timestamp":"2026-11-18T05:42:10.512Z","status":404,"error":"Not Found","path":"/api/courses/rust"}

How it works:

  • Spring injects CourseService into the controller's constructor exactly as in plain Spring.
  • Jackson, added by the web starter, turns the List<Course> into a JSON array and turns the request body into a Course record for @RequestBody.
  • ResponseEntity.created(...) sets status 201 and the Location header. ResponseStatusException produces Spring Boot's standard JSON error with the right status code. The design rules behind these status codes are covered in REST API in Java.

Configure the App With application.properties

# src/main/resources/application.properties
spring.application.name=coursehub
server.port=8080

# Our own settings
coursehub.platform-name=GOCOURSE
coursehub.max-courses-per-student=3
coursehub.support-email=support@gocourse.example
package com.gocourse.coursehub;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "coursehub")
public record CourseHubProperties(String platformName, int maxCoursesPerStudent, String supportEmail) {}
package com.gocourse.coursehub;

import com.gocourse.coursehub.course.CourseService;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.ConfigurationPropertiesScan;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
@ConfigurationPropertiesScan // finds @ConfigurationProperties records
public class CourseHubApplication {

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

    @Bean
    CommandLineRunner startupReport(CourseHubProperties props, CourseService courseService) {
        return args -> System.out.printf("%s ready: %d courses, max %d per student, help: %s%n",
                props.platformName(), courseService.findAll().size(),
                props.maxCoursesPerStudent(), props.supportEmail());
    }
}

Output (at the end of startup):

INFO  Started CourseHubApplication in 1.7 seconds (process running for 2.0)
GOCOURSE ready: 2 courses, max 3 per student, help: support@gocourse.example

How it works:

  • @ConfigurationProperties(prefix = "coursehub") binds every coursehub.* key to the record. Relaxed binding maps max-courses-per-student to maxCoursesPerStudent and converts the text to int.
  • Grouping settings in one typed record is safer than many @Value strings: one place to look, and a typo in a type fails at startup.
  • A CommandLineRunner bean runs once after the application has fully started. Use it for startup checks, data loading or reports.

Override Settings With Profiles and Command-Line Arguments

# src/main/resources/application-dev.properties
server.port=8081
coursehub.platform-name=GOCOURSE (DEV)
coursehub.max-courses-per-student=10
./mvnw spring-boot:run -Dspring-boot.run.profiles=dev

Output (shortened):

INFO  The following 1 profile is active: "dev"
INFO  Tomcat started on port 8081 (http) with context path '/'
GOCOURSE (DEV) ready: 2 courses, max 10 per student, help: support@gocourse.example
Source (higher wins)Example
Command-line argument--server.port=9090
Environment variableSERVER_PORT=9090, COURSEHUB_PLATFORMNAME=Demo
application-{profile}.propertiesapplication-dev.properties
application.propertiesdefault values

How it works:

  • application.properties always loads first. An active profile's file then overrides only the keys it contains, so support-email keeps its default value.
  • Environment variables use uppercase with underscores. This is how containers and cloud platforms set database passwords and ports without touching the JAR.

How Spring Boot Auto-Configuration Works

Auto-configuration classes are ordinary @Configuration classes with conditions. Each one asks questions such as "Is this class on the classpath?" and "Has the developer already defined this bean?".

Condition annotationApplies the configuration when
@ConditionalOnClassA class is on the classpath (for example DispatcherServlet)
@ConditionalOnMissingBeanYou have not defined a bean of that type yourself
@ConditionalOnPropertyA property has a given value
@ConditionalOnWebApplicationThe app is a web application
./mvnw spring-boot:run -Dspring-boot.run.arguments=--debug

Output (small part of the report):

============================
CONDITIONS EVALUATION REPORT
============================

Positive matches:
-----------------
   DispatcherServletAutoConfiguration matched:
      - @ConditionalOnClass found required class 'org.springframework.web.servlet.DispatcherServlet'
      ...

Negative matches:
-----------------
   ...

How it works:

  • Because the web starter put DispatcherServlet on the classpath, Spring MVC was configured. No database starter was added, so no DataSource bean exists.
  • Positive matches list every auto-configuration that was applied and why; negative matches list the ones skipped and the condition that failed. Read this report whenever a bean you expected is missing.
  • Most auto-configured beans use @ConditionalOnMissingBean. If you declare your own bean of the same type, Spring Boot backs off and uses yours. That is how you customize anything Boot sets up.

Monitor the App With Spring Boot Actuator

# add to application.properties
management.endpoints.web.exposure.include=health,info
management.info.env.enabled=true
info.app.name=CourseHub
info.app.version=1.0
curl http://localhost:8080/actuator/health
curl http://localhost:8080/actuator/info

Output:

{"status":"UP"}
{"app":{"name":"CourseHub","version":"1.0"}}

How it works:

  • /actuator/health returns UP while the app and its dependencies (database, disk space) are healthy. Load balancers and Kubernetes call it to decide whether to send traffic.
  • Only endpoints listed in exposure.include are reachable over HTTP. Keep sensitive ones such as env and beans hidden in production.

Package and Run an Executable JAR

./mvnw clean package
java -jar target/coursehub-0.0.1-SNAPSHOT.jar --server.port=9090

Output (shortened):

[INFO] Building jar: /home/asha/coursehub/target/coursehub-0.0.1-SNAPSHOT.jar
[INFO] BUILD SUCCESS
...
INFO  Tomcat started on port 9090 (http) with context path '/'
GOCOURSE ready: 2 courses, max 3 per student, help: support@gocourse.example

How it works:

  • package runs the tests, then the Boot plugin repackages the JAR so it contains your classes, every dependency JAR and a launcher.
  • The same file runs on any machine with Java 25: a laptop, a VM or a Docker image. --server.port=9090 overrides the property for this run only.

Real-World Example: Spring Boot Tutorial Project With an Enrollment Rule

CourseHub must stop a student from joining more courses than the limit in coursehub.max-courses-per-student. The rule lives in a service, the limit in configuration, and the controller answers with clear HTTP status codes.

# add to application.properties so error JSON includes the reason
server.error.include-message=always
package com.gocourse.coursehub.enrollment;

import com.gocourse.coursehub.CourseHubProperties;
import com.gocourse.coursehub.course.CourseService;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.web.server.ResponseStatusException;

@Service
public class EnrollmentService {

    public record EnrollmentResult(String student, String courseCode, int coursesTaken, int limit) {}

    private final CourseService courseService;
    private final CourseHubProperties props;
    private final Map<String, Set<String>> coursesByStudent = new ConcurrentHashMap<>();

    public EnrollmentService(CourseService courseService, CourseHubProperties props) {
        this.courseService = courseService;
        this.props = props;
    }

    public EnrollmentResult enroll(String student, String courseCode) {
        courseService.findByCode(courseCode).orElseThrow(() ->
                new ResponseStatusException(HttpStatus.NOT_FOUND, "Course " + courseCode + " does not exist"));

        Set<String> taken = coursesByStudent.computeIfAbsent(student, key -> ConcurrentHashMap.newKeySet());
        synchronized (taken) { // one student's enrollments change one at a time
            if (taken.contains(courseCode)) {
                throw new ResponseStatusException(HttpStatus.CONFLICT, student + " is already enrolled in " + courseCode);
            }
            if (taken.size() >= props.maxCoursesPerStudent()) {
                throw new ResponseStatusException(HttpStatus.CONFLICT,
                        student + " already has " + taken.size() + " courses (limit " + props.maxCoursesPerStudent() + ")");
            }
            taken.add(courseCode);
            return new EnrollmentResult(student, courseCode, taken.size(), props.maxCoursesPerStudent());
        }
    }
}
package com.gocourse.coursehub.enrollment;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class EnrollmentController {

    public record EnrollmentRequest(String student, String courseCode) {}

    private final EnrollmentService enrollmentService;

    public EnrollmentController(EnrollmentService enrollmentService) {
        this.enrollmentService = enrollmentService;
    }

    @PostMapping("/api/enrollments")
    @ResponseStatus(HttpStatus.CREATED)
    public EnrollmentService.EnrollmentResult enroll(@RequestBody EnrollmentRequest request) {
        return enrollmentService.enroll(request.student(), request.courseCode());
    }
}
# Add two more courses, then send five enrollment requests for Asha and one for Ravi
for course in docker python; do
  curl -s -X POST localhost:8080/api/courses -H "Content-Type: application/json" \
       -d "{\"code\":\"$course\",\"title\":\"$course course\",\"feeInr\":1999}" > /dev/null
done
for course in java go docker java python; do
  curl -s -X POST localhost:8080/api/enrollments -H "Content-Type: application/json" \
       -d "{\"student\":\"asha\",\"courseCode\":\"$course\"}"; echo
done
curl -s -X POST localhost:8080/api/enrollments -H "Content-Type: application/json" \
     -d '{"student":"ravi","courseCode":"kotlin"}'; echo

Output:

{"student":"asha","courseCode":"java","coursesTaken":1,"limit":3}
{"student":"asha","courseCode":"go","coursesTaken":2,"limit":3}
{"student":"asha","courseCode":"docker","coursesTaken":3,"limit":3}
{"timestamp":"2026-11-18T05:51:03.218Z","status":409,"error":"Conflict","message":"asha is already enrolled in java","path":"/api/enrollments"}
{"timestamp":"2026-11-18T05:51:03.231Z","status":409,"error":"Conflict","message":"asha already has 3 courses (limit 3)","path":"/api/enrollments"}
{"timestamp":"2026-11-18T05:51:03.240Z","status":404,"error":"Not Found","message":"Course kotlin does not exist","path":"/api/enrollments"}

How it works:

  1. Layers. The controller only converts HTTP to method calls. The business rule sits in EnrollmentService, which could be reused by a scheduled job or a message listener.
  2. Configuration-driven rule. The limit comes from CourseHubProperties. Starting with the dev profile raises it to 10 with no code change, and the fifth request would then succeed.
  3. Thread safety. Tomcat handles requests on many threads. ConcurrentHashMap keeps the map safe, and locking one student's set prevents two parallel requests from both passing the limit check.
  4. Meaningful status codes. Success returns 201 Created, a duplicate or over-limit request returns 409 Conflict, and an unknown course returns 404. With include-message=always the JSON explains why; leave it off for public APIs if messages could reveal internal details.
  5. Where this goes next. The in-memory maps disappear on restart. The Spring Data JPA lesson replaces them with a real database, and the Spring MVC lesson adds HTML pages to the same kind of application.

0 Comments

Reviewed before they appear

No comments yet.

Java
Java Introduction Java Features Java Syntax Java Comments Java Statements Java Output Java Variables Java Data Types Java Type Casting Java Operators Java Strings Java Numbers Java Math Java Booleans Java User Input Java Conditions Java If Else Java Switch Java While Loop Java For Loop Java Break Java Continue Java Arrays Java Methods Java Parameters Java Return Values Java Scope Java Recursion Install Java Install JDK Java IDEs Java JDK Java JRE Java JVM Java Compiler Java File Compile Java Run Java JShell Basics Java Packages Java OOP Java Classes Java Objects Class Methods Constructors Constructor Overload this Keyword static Keyword final Keyword Encapsulation Inheritance Polymorphism Abstraction Access Modifiers super Keyword Method Overload Method Override Instanceof Operator Nested Classes Inner Classes Anonymous Classes Enums Records Array Basics Array Length Loop Arrays Multidimensional Arrays Array Copy Array Sorting Array Search ArrayList LinkedList HashSet TreeSet HashMap TreeMap Queue Interface Deque Interface Stack Class Iterator List Interface Set Interface Map Interface Collections Class Comparable Comparator Generics Basics Generic Classes Generic Methods Wildcards String Basics String Length String Methods String Concatenation String Compare String Search String Replace String Split String Format StringBuilder StringBuffer Text Blocks Regular Expressions Number Types Integer Class Float Class Double Class BigInteger BigDecimal Math Class Random Numbers Number Format Date Basics LocalDate LocalTime LocalDateTime ZonedDateTime Date Formatting Date Parsing Period Class Duration Class Java Instant Class Java Exception Basics Java try...catch Java Multiple Catch Blocks Java finally Block Java throw Keyword Java throws Keyword Java Checked Exceptions Java Unchecked Exceptions Java Custom Exceptions Java try-with-resources Java Exception Chaining Java File Basics Java Create Files Java Read Files Java Write Files Java Delete Files Java File Paths Java File Class Java BufferedReader Java BufferedWriter Java FileInputStream Java FileOutputStream Java Object Streams Java Directory Handling Java NIO Basics Java Files API Java Input Java Scanner Class Java Console Input Java PrintStream Java InputStream Java OutputStream Java Reader Class Java Writer Class Java Buffered Streams Java Data Streams Java Generics Introduction Java Generic Types Java Generic Methods Java Bounded Types Java Wildcards Java Type Erasure Java Generic Interfaces Java Generic Collections Java Lambda Basics Java Lambda Syntax Java Functional Interfaces Java Method References Java Stream API Java Stream Creation Java Stream Filter Java Stream Map Java Stream Reduce Java Stream Sort Java Stream Collect Java Collectors Class Java Optional Class Java Parallel Streams Java Threads: Thread Basics Create a Thread in Java Java Thread Class Java Runnable Interface Java Thread States Java Thread Sleep Java Thread Join Java Thread Priority Java Synchronization Java Thread Safety Java Race Conditions Java Deadlocks Java Executor Service Java Thread Pools Java Callable Interface Java Future Interface Java CompletableFuture Java Concurrent Collections Java Atomic Classes Java Virtual Threads Java Networking Basics Java URL Class Java URI Class Java HttpClient Java HTTP Requests Java HTTP Responses Java Socket Basics Java ServerSocket Java DatagramSocket Java WebSocket Basics Java JDBC Basics Java JDBC Setup Java Database Connection Java JDBC Connection Interface Java JDBC Statement Java PreparedStatement Java ResultSet Java JDBC CRUD Operations Java JDBC Transactions Java JDBC Batch Update Java Connection Pooling with HikariCP Java JPA Basics: Entities, EntityManager and JPQL Java Hibernate Basics: SessionFactory, Session and HQL Package in Java: Basics Explained with Examples Create Package in Java: Step-by-Step Guide with Examples Import Package in Java: The import Statement Explained Access Control in Java: Packages, Classes and Members JAR File in Java: Create, Run and Inspect JAR Files Java Modules: Introduction to the Java Module System module-info in Java: Every Module Directive Explained Java Module Path: How --module-path Finds Your Modules Java Classpath: How -cp and CLASSPATH Find Your Classes Java Annotations: Basics of @ Metadata in Java Java Built-in Annotations: @Override, @Deprecated and More Java Custom Annotations: Create Your Own @interface Java Annotation Targets: @Target and ElementType Explained Java Reflection API: Inspect and Use Classes at Runtime Java Class Metadata: Names, Modifiers, Hierarchy and Generic Java Dynamic Objects: Create Objects Dynamically With Reflec Java Dynamic Proxy: Intercept Method Calls With Proxy and In Java Security Java Secure Coding Java Password Hashing Java Input Validation Java Cryptography Basics Java KeyStore Basics Java TLS Basics Java SecureRandom Java JUnit Basics Java JUnit Test Methods JUnit Assertions JUnit Test Fixtures JUnit Parameterized Tests Mockito in Java Java Mock Objects Java Integration Testing Java Code Coverage Maven in Java Create a Maven Project in Java Maven Dependencies Maven Plugins Gradle in Java Gradle Build Gradle Dependencies Build Executable JAR in Java Build WAR File in Java HTTP Basics in Java Java Servlet Basics Servlet Lifecycle in Java HttpServletRequest in Java HttpServletResponse in Java JSP in Java JSTL in JSP REST API in Java JSON in Java Java Web Application Spring Framework Basics Spring Boot Tutorial Spring MVC Spring Data JPA Spring Security Spring Boot REST API Jakarta EE Basics Java Deployment JAR Deployment Java WAR Deployment Run Java as a Service Docker Java: Dockerize a Java Application Java Environment Variables and Configuration Java Logging Basics Java Production Setup Java JVM Options Java JVM Monitoring Java Hello World App Java Calculator App Java Number Guess Game Java Student Manager Java Library System Java Bank App Java Todo App Java File Manager Java Quiz App Java REST API Project Java Chat Server Java Employee Manager Java E-commerce API
Ask about this post
AI Ask about this post

Ask questions about Spring Boot Tutorial and get answers drawn from it.

Signed-in readers only.