Maven projects use dependencies to include external libraries. If your Maven project is a Spring Boot application, you can use Spring Boot dependency starters.
A Spring Boot dependency starter is a collection of related libraries that enables a specific capability in your application, such as building web applications, accessing databases or securing endpoints.
The "Most Common Production REST API" Stack
If you inspect a typical business API in 2026, you'll often see something close to:
Usual Name
Dependency Name
Spring Web
spring-boot-starter-web
Testing
spring-boot-starter-test
Spring Data JPA
spring-boot-starter-data-jpa
Validation
spring-boot-starter-validation
Spring Security
spring-boot-starter-security
Actuator
spring-boot-starter-actuator
PostgreSQL Driver
org.postgresql:postgresql
Lombok
org.projectlombok:lombok
That set alone probably covers 70–80% of typical Spring Boot backend applications built for internal tools, SaaS products, e-commerce systems, and microservices.
The client–server architecture is a distributed application structure that divides workloads between service providers (servers) and service consumers (clients).
A service is an abstraction over computing resources.
A server hosts one or more server programs and exposes services to clients.
Clients request services and servers process those requests.
The most common communication stack is TCP/IP.
Examples of client–server applications include email systems, network printing systems, and the World Wide Web.
Naming Conventions for Classes in Spring / Jakarta Applications
For a modern Java application, developers use widely recognized naming conventions that make codebases easier to navigate.
Suppose you want to give a name to objects by what their class is responsible for. The table is organizing so that it show in the first column the purpose of the object and in the other columns convention to follow to give a name to a class.
A small caveat first:
@Service, @Repository, and @Controller are Spring stereotypes.
Jakarta EE does not provide direct equivalents for all of them.
In Jakarta EE, developers often use @ApplicationScoped, @RequestScoped, @Singleton or EJB annotations such as @Stateless.
So the mapping is sometimes exact, sometimes only conceptual.
A Java interface defines a set of behaviors as abstract methods. A class that implements that interface has to fulfill those behaviors. An interface defines what happens, an object defines how it happens.
Interfaces allow to decouple implementations. This reduces dependencies between implementations and allows to change implementations independently.
Sample Analogy: Booking a Room
Suppose you are designing an application that allows customers to book hotel rooms. When a customer makes a reservation, they are not concerned with the name of the hotel; they are primarily interested in the destination city and the check-in and check-out dates. The room booking application therefore provides an interface in which the customer requests an accommodation, rather than a specific hotel.
An application framework is a set of reusable components and functionalities that simplifies software development by removing the need for developers to build applications from scratch.
When developing applications, you usually distinguish between boilerplate code and business code.
Boilerplate code handles common technical needs shared by many applications, such as error logging, transaction management, security, inter-system communication, and performance optimizations such as caching and data compression. Synonims of boilerplate code are: plumbing code, framework code and infrastructure code.
Business code implements the use cases and specific requirements of an application—what users expect the application to do. It is what makes one application different from another.
A framework lets developers focus on business code by providing reusable solutions for common technical needs, reducing the amount of infrastructure code that must be written and maintained.
2.0 Spring as a collection of frameworks
Spring is a collection of frameworks and libraries, not just a single framework; therefore we say that Spring is an ecosystem.
The most common modules in the Spring Framework ecosystem are:
Spring Core – the foundational module that provides essential capabilities, including:
Spring Context – manages the lifecycle and configuration of objects (beans)
Spring AOP (Aspect-Oriented Programming) – intercepts and modifies method execution
Spring Expression Language (SpEL) – provides an expression language used in
configuration and annotations
Spring MVC (Model-View-Controller) – provides the components needed to build web
applications and RESTful web services.
Spring Data Access – provides support for working with relational databases and data access
technologies.
Spring Testing – provides tools for writing and running tests for Spring applications.
A character set is just a collection of symbols (letters, digits, punctuation, emojis, etc.) that a computer system knows
about, together with the numbers (code points) assigned to them.
Character Set - Formal definition
A character set (more precisely, a coded character set) is a mapping between a finite set of abstract characters and a set of unique code points (integers).
It defines:
Character repertoire = the set of characters included.
Code space = the range of assignable numeric values.
Mapping function = assigns each character exactly one code point.
Formally:
f : Character ↔ CodePoint ∈ CodeSpace
Where the code point is the single integer value that uniquely identifies one abstract character
In this section, we see the docker commands for creating, stopping, restarting and deleting containers
TOC:
1 Check for existing containers and images
The Docker commands to list existing containers and images in your local Docker environment
You can use the docker ps command to list any running container
$ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
You can use the docker images command to list local images
$ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
You’re on a clean system with no pre-existing containers or images.
2 Run a container
Docker command to run a new container
The docker run command creates and starts a new container from a specified image. If the image is not already present on the local system, Docker automatically pulls it from a registry (such as Docker Hub).
Basic Syntax
docker run [OPTIONS] <image>:<tag>
What happens when you run docker run
Image retrieval
Docker checks if the specified image (<image>:<tag>) exists in the local image cache. If not, Docker automatically pulls it from Docker Hub (or another registry), unpacks the image layers and sets them up as the container’s filesystem.
Container creation (docker create)
A new container object is created from the image. It has its own ID, configuration, filesystem, and network settings.
Container start (docker start)
Docker starts the container by running the default command CMD defined in the image (or overridden by the user).
Application accessibility
If the container exposes services, you can map its ports to your host using the -p flag to make them accessible. This makes the service available on the host machine’s port and accessible from any client (local and external clients) that can connect to the host.
Common Options
-d
Run the container in detached mode (in the background).
-p <host_port>:<container_port>
Map a container port to a port on the host machine.
--name <container_name>
Assign a custom name to the container.
-it
Run the container interactively with a terminal session attached.
--rm
Automatically remove the container once it exits.
Note: in day-to-day use, docker run is usually enough. The docker start command is rarely needed, but it can be useful if you want to reuse a container multiple times without recreating it.
Example: the docker run command to create and start a new container from an image
docker run ubuntu echo "hello"
This creates a container from the ubuntu image and runs the command echo "hello" inside it.
Example: the docker run command to pull an image from Docker Hub
$ docker run hello-world
Docker first searches the local image cache. If hello-world isn’t present locally, Docker will fetch it from Docker Hub, then run it in a container.
Example: run an Nginx web server container
docker run -d -p 8080:80 --name mynginx nginx:latest
This starts Nginx (nginx:latest) in detached mode (-d), maps container port 80 to host port 8080 (-p 8080:80), and names the container mynginx.
You can then open a browser to http://localhost:8080 to access it.
Example: docker run pulls the specified image from Docker Hub, starts a new container, and assigns it the name test.
$ docker run -d --name test -p 5555:80 docker/welcome-to-docker
Docker Command Explanation
docker run → starts a new container.
-d flag → runs the container in the background (detached mode).
-p 5555:80 option → maps port 5555 on the host to port 80 inside the container. This allows you to access the web server running inside the container (isolated network) from your host machine.
From the host’s perspective, port 80 inside the container is exposed through port 5555 on the host, so any client (e.g., your browser) connecting to port 5555 on the host is redirected to port 80 inside the container.
docker/welcome-to-docker → specifies the image to use for creating the container.
Figure: Docker Engine sets up NAT/forwarding so localhost:8080 -> container:80
-p 5555:80 publishes host port 5555 to container port 80 via NAT on the docker bridge.
both processes are on the same machine; the container just has isolated networking.
Docker first checks the local image cache to see if an image with the specified name and tag exists. If the image is not found locally, Docker pulls it from the Docker Hub registry, displaying the progress as it downloads each layer. Once the download is complete, Docker shows the image digest, confirms that the image has been successfully downloaded, and finally displays the ID of the newly created container.
Now, you can open your browser to http://localhost:5555/ to test if the app is working
3 Check the container and image
issue again the docker ps command to check how many containers are running
you can see the container called test based on the specified image and mapping port 5555 to 80
$ docker ps
CONTAINER ID IMAGE PORTS NAMES
1834dd448893 docker/welcome-to-docker 0.0.0.0:5555->80/tcp, [::]:5555->80/tcp test
then, issue again the docker images command to check how many images are on your local machine
$ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
docker/welcome-to-docker latest c4d56c24da4f 4 weeks ago 22.2MB
there is a local copy of the docker/welcome-to-docker image just pulled from Docker Hub.
4 Stopping, restarting and deleting containers
To stop a running container: docker stop <container_name>
To start a stopped container: docker start <container_name>
To delete a running container: docker rm -f <container_name>
Example: stop the container you have created
$ docker stop test
test
This will make the browser not able to load the app anymore
Example: restart the container named test
$ docker start test
test
This will make the app back up and the browser able to load it
Example: delete the container. The -f flag force the termination without giving thr app the 10 seconds to gracefully stop.
$ docker rm test -f
test
the -f flag forces the termination without giving thr app the 10 seconds to gracefully stop.
the container is removed, but you still have the image on you machine.
