Page |1

REFERENCE MATERIAL
[Link]. (Computer
Science)

Server
Programming
Notes
(MR23-
1BSCC18)

*******************
 Page |2

SERVER PROGRAMMING (MR23-1BSCC18)

SYLLABUS

UNIT – I:
Spring Framework: Spring Framework Architecture, Modules, Spring
Dependencies, Spring Initializer, Spring vs Struts in Java, Spring MVC
UNIT– II:
Spring Boot: Micro services, Architecture, Auto configurations, Initialize, Install
Spring Tool Suite IDE, Creating an application, Dependency Management (Maven
and Gradle), Annotations, YAML Files, Actuators, Spring Boot Rest APIs creation.
UNIT – III:
Spring Boot: Micro services, Architecture, Auto configurations, Initialize, Install
Spring Tool Suite IDE, Creating an application, Dependency Management (Maven
and Gradle), Annotations, YAML Files, Actuators, Spring Boot Rest APIs creation.
UNIT – IV:
Spring boot JDBC: JDBC login application, Data JDBC, Data JPA, Spring Boot JPA.
Spring Boot: Thyme leaf Templates, Spring Boot Security.
UNIT – V:
SQLite Integration with Spring Boot: Introduction to SQLite – Features and
Advantages – Comparison with MySQL and MongoDB – SQLite Data Types –
Installation and Database Creation – Basic SQL Commands (CREATE, INSERT,
UPDATE, DELETE, SELECT) – Configuring SQLite in Spring Boot – Connecting with
Spring Data JPA – Performing CRUD Operations – Exception Handling – Creating
Executable JAR and Deployment.

SERVER PROGRAMMING LAB

1. Creating a Simple Spring Framework Application Develop a simple Java project
using the Spring Framework to display “Welcome to Spring Framework”.
2. Spring Dependency Injection Example Demonstrate Constructor and Setter
Injection in Spring using XML configuration.
3. Spring MVC Basic Application Create a basic Spring MVC application that
returns a welcome message using Controller and View (JSP).
4. Spring Boot Project Setup Initialize a new Spring Boot project using Spring
Initializr and run it successfully in STS IDE.
5. Spring Boot REST API – GET Request Create a REST API to display a list of
students using @RestController and test with Postman.
6. Spring Boot REST API – POST Request Create an endpoint to add a new student
record and return success message in JSON format.
7. JDBC Login Application Create a simple login validation system using Spring
Boot JDBC with a sample database table.
8. Thymeleaf Integration Build a simple web page using Thymeleaf Template to
display student details fetched from the database.
9. Spring Boot Security Basics Implement a simple username-password
authentication using Spring Security and in-memory users.
10. Exception Handling Example Demonstrate exception handling in Spring Boot
using @ControllerAdvice and @ExceptionHandler.
11. File Upload and Download in Spring Boot Develop a small application to
upload and download files using Spring Boot.
12. Spring Boot + SQLite CRUD Application Connect Spring Boot with SQLite
database, perform CRUD operations, and package the project as an executable
JAR.

~:0:~
 Page |3

Questions and Answers

Unit-II
1. What is Spring Boot, and how is it different from the
Spring Framework?
Spring Boot is a framework built on top of the Spring
Framework that simplifies the development of standalone,
production-ready Spring applications by reducing configuration and
setup effort.
What is Spring Boot?
 An extension of the Spring Framework.
 Designed to simplify application setup and development.
 Provides:
o Auto-configuration
o Embedded servers
o Opinionated defaults
 Enables rapid application development.
How Spring Boot Differs from Spring Framework
1. Configuration
 Spring Framework: Requires manual configuration
(XML/Java/annotations).
 Spring Boot: Uses auto-configuration to reduce boilerplate code.
2. Application Setup
 Spring Framework: Needs external server setup (Tomcat, JBoss).
 Spring Boot: Comes with embedded servers (Tomcat, Jetty).
3. Dependency Management
 Spring Framework: Developers manage dependencies manually.
 Spring Boot: Provides starter dependencies (e.g., spring-boot-
starter-web).
4. Development Speed
 Spring Framework: Slower initial setup.
 Spring Boot: Faster development and deployment.
5. Deployment
 Page |4

 Spring Framework: Requires WAR packaging and server

deployment.
 Spring Boot: Supports standalone JAR execution.

6. Production Readiness
 Spring Framework: Needs additional tools.
 Spring Boot: Provides Actuator for monitoring and health checks.
Comparison Table
Feature Spring Spring Boot
Framework
Type Core framework Framework
extension
Configuration Manual Auto-configured
Server External Embedded
Dependencie Individual Starters
s
Deployment WAR Executable JAR
Spring Boot simplifies the use of the Spring Framework by providing
auto-configuration, embedded servers, and starter dependencies,
making it ideal for modern, microservice-based applications.
2. What are Microservices, and how does Spring Boot support
microservices architecture?
Microservices are an architectural style where an application is
developed as a collection of small, independent, and loosely
coupled services, each responsible for a specific business function and
communicating through lightweight protocols (HTTP/REST).
What Are Microservices?
 Each service performs one business capability.
 Services are independently developed, deployed, and scaled.
 Communication occurs via REST APIs or messaging.
Each service can use its own database.

 Improves scalability, reliability, and maintainability.
How Spring Boot Supports Microservices
1. Standalone Service Development
 Page |5

 Spring Boot creates independent, executable applications.

 Each microservice runs as a separate process.
 Embedded servers remove external deployment dependency.
2. Rapid Development
 Auto-configuration reduces setup complexity.
 Starter dependencies simplify service creation.
 Faster development and deployment cycles.
3. RESTful Web Services
 Built-in support for REST APIs using Spring MVC and REST
controllers.
 Easy JSON/XML data handling.
4. Service Discovery
 Supports service registration and discovery using Spring Cloud
(Eureka).
 Enables dynamic communication between services.
5. Configuration Management
 Externalized configuration using Spring Cloud Config.
 Allows centralized and dynamic configuration.
6. Load Balancing
 Client-side load balancing using Spring Cloud LoadBalancer.
 Distributes requests across service instances.
7. Fault Tolerance
 Supports resilience patterns like Circuit Breaker (Resilience4j).
 Improves system reliability.
8. Monitoring and Health Checks
 Spring Boot Actuator provides metrics, health, and monitoring
endpoints.
 Helps in production management.
Advantages of Using Spring Boot for Microservices
 Lightweight and scalable
 Easy deployment and scaling
 Cloud-ready
 Strong ecosystem support
 Page |6

Spring Boot supports microservices architecture by enabling

standalone services, REST APIs, service discovery, configuration
management, load balancing, and fault tolerance, making it a
popular choice for building microservices-based applications.

3. Explain the architecture of a Spring Boot application. What are its

key components?
A Spring Boot application follows a layered architecture that
simplifies development by providing auto-configuration, embedded
servers, and production-ready features.
Overall Architecture (Layered)
Client
↓
Controller Layer
↓
Service Layer
↓
Repository (DAO) Layer
↓
Database
Spring Boot manages these layers using Inversion of Control (IoC) and
Dependency Injection (DI).
Key Components of Spring Boot Architecture
1. Application Entry Point
 Main class annotated with @SpringBootApplication.
 Starts the application and initializes Spring context.
@SpringBootApplication
public class DemoApplication
{
public static void main(String[] args)
{
[Link]([Link], args);
 Page |7

}
}
2. Controller Layer
 Handles HTTP requests from clients.
 Uses annotations like @RestController or @Controller.
 Maps URLs to handler methods.
3. Service Layer
 Contains business logic.
 Acts as an interface between Controller and Repository.
 Annotated with @Service.
4. Repository (DAO) Layer
 Handles database operations.
 Uses Spring Data JPA or JDBC.
 Annotated with @Repository.
5. Embedded Web Server
 Spring Boot includes embedded servers like Tomcat, Jetty, or
Undertow.
 Eliminates need for external server deployment.
6. Auto-Configuration
 Automatically configures beans based on dependencies.
 Reduces manual configuration.
7. Dependency Management
 Uses Spring Boot Starter dependencies.
 Ensures compatible library versions.
8. Application Configuration
 Uses [Link] or [Link].
 Supports externalized configuration.
9. Spring Boot Actuator
 Provides monitoring, health checks, and metrics.
 Useful for production environments.
Advantages of Spring Boot Architecture
 Loose coupling
 High scalability
 Page |8

 Easy testing and maintenance

 Faster development
Spring Boot architecture consists of layered components,
embedded server, auto-configuration, and dependency
management, making it simple, scalable, and production-ready.

4. What is auto-configuration in Spring Boot, and how does it work

internally?
Auto-configuration is a key feature of Spring Boot that
automatically configures Spring application components based on
the libraries present in the classpath, reducing manual configuration.
What Is Auto-Configuration?
 Automatically sets up beans and configurations.
 Eliminates the need for extensive XML or Java configuration.
 Works on the principle of “convention over configuration.”
 Enabled by default using @SpringBootApplication.
How Auto-Configuration Works Internally
1. @SpringBootApplication
 Combines three annotations:
o @Configuration
o @EnableAutoConfiguration
o @ComponentScan
 @EnableAutoConfiguration triggers auto-configuration.
2. Classpath Scanning
 Spring Boot checks available libraries in the classpath.
 Example:
o If spring-webmvc is present → configures Spring MVC.
o If spring-data-jpa is present → configures JPA and DataSource.
3. Auto-Configuration Classes
 Spring Boot uses predefined classes in:
 [Link]
 Examples:
o DataSourceAutoConfiguration
 Page |9

o WebMvcAutoConfiguration
4. Conditional Annotations
Auto-configuration uses conditions such as:
 @ConditionalOnClass – activates if a class exists
 @ConditionalOnMissingBean – activates if bean not defined
 @ConditionalOnProperty – activates based on property value
This ensures only required beans are created.
5. application. properties / [Link]
 Developers override default behavior using configuration files.
 Example:
[Link]=8081
[Link]=jdbc:mysql://localhost/db
6. Customization and Exclusion
 Auto-configuration can be disabled or customized:
@SpringBootApplication(exclude = [Link])
Advantages of Auto-Configuration
 Reduces boilerplate code
 Faster development
 Sensible defaults
 Easy customization
Spring Boot auto-configuration works by detecting classpath
dependencies, applying conditional logic, and creating required
beans automatically, allowing developers to focus on business logic
instead of configuration.
5. How do you initialize a Spring Boot project using Spring Initializr?
Spring Initializr is a tool that helps developers quickly create
and configure a Spring Boot project with minimal manual effort.
Steps to Initialize a Spring Boot Project
1. Open Spring Initializr
 Go to Spring Initializr website or use IDE support.
 Common IDEs: STS, Eclipse, IntelliJ IDEA.
2. Select Project Details
Choose the following options:
 P a g e | 10

 Project: Maven or Gradle

 Language: Java
 Spring Boot Version: Default (recommended)
 Packaging: JAR
 Java Version: 17 or as required

3. Enter Project Metadata

 Group: [Link]
 Artifact: demo
 Name: demo
 Description: Spring Boot application
 Package name auto-generated
4. Add Dependencies
Select required dependencies, such as:
 Spring Web
 Spring Data JPA
 Spring Security
 MySQL Driver
Spring Initializr ensures compatible versions automatically.
5. Generate the Project
 Click Generate.
 A ZIP file is downloaded.
 Extract and open it in your IDE.
6. Project Structure Created
Spring Initializr generates:
 [Link] / [Link]
 Main application class
 Standard folder structure
 [Link]
7. Run the Application
 Run the main class annotated with @SpringBootApplication.
 Embedded server starts automatically.
 P a g e | 11

Advantages of Using Spring Initializr

 Saves setup time
 Reduces configuration errors
 Standardized project structure
 Beginner-friendly
Spring Initializr simplifies Spring Boot project initialization by
automating project creation, dependency selection, and
configuration, enabling developers to start coding immediately.
6. What are the steps to install and configure Spring Tool Suite (STS)
IDE for Spring Boot development?
Spring Tool Suite (STS) is an IDE based on Eclipse, specifically
designed for Spring and Spring Boot application development.
Steps to Install STS
1. Install Java Development Kit (JDK)
 Install JDK 17 (recommended for Spring Boot).
 Set JAVA_HOME and update system PATH.
 Verify using:
java -version
2. Download Spring Tool Suite
 Download STS for your operating system.
 Choose the Eclipse-based STS package.
3. Install STS
 Extract the downloaded ZIP file.
 Run [Link] (Windows) or executable (Linux/macOS).
 Select a workspace directory.
Steps to Configure STS for Spring Boot
4. Configure Java in STS
 Go to Window → Preferences → Java → Installed JREs.
 Add JDK path and set it as default.
5. Create a Spring Boot Project
 Go to File → New → Spring Starter Project.
 Enter project details (Name, Group, Artifact).
 Select Spring Boot version and dependencies.
 P a g e | 12

 Click Finish.
6. Configure Maven/Gradle
 STS auto-configures Maven or Gradle.
 Ensure dependencies are downloaded successfully.
 Check [Link] for correctness.
7. Run the Spring Boot Application
 Right-click project → Run As → Spring Boot App.
 Embedded server starts automatically.
8. Optional Configuration
 Use [Link] or [Link].
 Enable Spring Boot Dashboard for monitoring apps.
Advantages of Using STS
 Built-in Spring Boot support
 Easy project creation
 Integrated debugging and testing
 Developer-friendly UI
Installing and configuring STS involves setting up JDK, installing
STS, creating a Spring Boot project, and running the application,
making it an efficient IDE for Spring Boot development.
7. How do you create and run a simple Spring Boot application?
A Spring Boot application can be created and run easily using
Spring Initializr and an IDE like Spring Tool Suite (STS) or IntelliJ
IDEA.
Steps to Create a Simple Spring Boot Application
1. Create Project Using Spring Initializr
 Open Spring Initializr (web or IDE).
 Select:
o Project: Maven
o Language: Java
o Packaging: JAR
o Java Version: 17
 Add dependency: Spring Web.
 Generate and open project in IDE.
 P a g e | 13

2. Main Application Class

 Generated automatically.
 Annotated with @SpringBootApplication.
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
[Link]([Link], args);
}
}
3. Create a Controller
 Handles HTTP requests.
 Use @RestController and @GetMapping.
@RestController
public class HelloController {

@GetMapping("/hello")
public String hello() {
return "Hello Spring Boot";
}
}
Steps to Run the Application
4. Run from IDE
 Right-click main class → Run As → Spring Boot App.
 Embedded Tomcat server starts.
5. Run from Command Line (Optional)
mvn spring-boot:run
6. Access the Application
 Open browser:
[Link]
 Output:
Hello Spring Boot
Advantages of Spring Boot Application
 Minimal configuration
 P a g e | 14

 Embedded server
 Fast startup
 Easy deployment
Creating and running a Spring Boot application involves project
creation, defining a controller, and running the application,
allowing developers to quickly build standalone web applications.
8. Explain dependency management in Spring Boot using Maven and
Gradle. How does Spring Boot simplify it?
Dependency management in Spring Boot refers to handling
external libraries required for application development. Spring Boot
simplifies dependency management by providing starter
dependencies and default version control using Maven and Gradle.
Dependency Management Using Maven
1. Maven in Spring Boot
 Spring Boot uses Maven as a build and dependency management
tool.
 Uses [Link] file.
2. Spring Boot Parent POM
 Spring Boot provides a parent POM:
<parent>
<groupId>[Link]</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.x.x</version>
</parent>
 Manages dependency versions automatically.
3. Starter Dependencies
 Starters are pre-configured dependency bundles.
 Example:
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
Includes:
 P a g e | 15

 Spring MVC
 Embedded Tomcat
 Jackson
Dependency Management Using Gradle
1. Gradle in Spring Boot
 Uses [Link] or [Link].

2. Spring Boot Plugin

plugins {
id '[Link]' version '3.x.x'
id '[Link]-management'
}
3. Adding Dependencies
dependencies {
implementation '[Link]:spring-boot-starter-web'
}
 No need to specify versions.
How Spring Boot Simplifies Dependency Management
1. Automatic Version Control
 Ensures compatible dependency versions.
 Avoids version conflicts.
2. Reduced Configuration
 No need to manage individual libraries manually.
 Fewer lines of configuration.
3. Consistency Across Projects
 Standardized dependency setup.
 Improves maintainability.
4. Easy Customization
 Developers can override versions if required.
Comparison Summary
Aspect Traditional Spring
Spring Boot
Dependency Manual Automatic
 P a g e | 16

Versions
Configuration Complex Simple
Setup Time High Low
Spring Boot simplifies dependency management in Maven and
Gradle by using starter dependencies, parent POM, and plugins,
allowing developers to focus on application logic instead of library
management.

9. What are commonly used Spring Boot annotations, and what is the
purpose of each?
Annotations in Spring Boot reduce configuration and simplify
application development by providing declarative programming
support.
1. Core Application Annotations
@SpringBootApplication
 Main annotation to start a Spring Boot application.
 Combines @Configuration, @EnableAutoConfiguration, and
@ComponentScan.
@Configuration
 Indicates a class contains Spring bean definitions.
@ComponentScan
 Scans packages to detect Spring components automatically.
2. Component Annotations
@Component
 Marks a class as a Spring-managed bean.
@Service
 Used in service layer.
 Contains business logic.
@Repository
 Used in data access layer.
 Provides exception translation for database operations.
3. Dependency Injection Annotations
 P a g e | 17

@Autowired
 Automatically injects dependencies.
 Supports constructor, setter, and field injection.
@Qualifier
 Resolves ambiguity when multiple beans exist.
4. Web & REST Annotations
@Controller
 Marks a class as a web controller.
 Returns views.

@RestController
 Combines @Controller and @ResponseBody.
 Returns data (JSON/XML).
@RequestMapping
 Maps HTTP requests to controller methods.
@GetMapping / @PostMapping
 Shortcut annotations for GET and POST requests.
@RequestParam
 Binds request parameters to method arguments.
@PathVariable
 Extracts values from URI path.
5. Configuration & Property Annotations
@Value
 Injects values from properties files.
@ConfigurationProperties
 Binds multiple properties to a Java class.
6. Database & JPA Annotations
@Entity
 Marks a class as a JPA entity.
@Id
 Specifies primary key.
@GeneratedValue
 Auto-generates primary key values.
 P a g e | 18

Summary Table
Annotation Purpose
@SpringBootApplication Bootstraps app
@Component / @Service / Bean creation
@Repository
@Autowired Dependency
injection
@RestController REST APIs
@RequestMapping URL mapping
@Entity Database mapping
Spring Boot annotations simplify development by reducing
configuration, enabling dependency injection, and supporting
web and database operations, making applications clean and
maintainable.
10. What are YAML configuration files in Spring Boot, and how do they
differ from [Link]?
Spring Boot supports externalized configuration using both
[Link] and [Link] (YAML) files to define
application settings.
What Are YAML Configuration Files?
 YAML stands for YAML Ain’t Markup Language.
 Uses indentation and hierarchy to represent configuration.
 In Spring Boot, configuration is stored in [Link].
 Mainly used for structured and hierarchical data.
[Link]
 Uses key–value pairs.
 Simple and flat structure.
 Easy for small configurations.
Example:
[Link]=8080
[Link]=jdbc:mysql://localhost/db
[Link]
 Uses indentation instead of dots.
 P a g e | 19

 More readable for complex configurations.

Example:
server:
port: 8080
spring:
datasource:
url: jdbc:mysql://localhost/db
Key Differences
Feature [Link] [Link]
es
Format Key–value pairs Hierarchical
Readability Less for large configs More readable
Structure Flat Nested
Complexit Simple Handles complex
y configs
Indentatio Not required Required
n
Advantages of YAML
 Cleaner and structured
 Less repetition
 Ideal for microservices and cloud apps
Advantages of [Link]
 Simple syntax
 Less indentation errors
 Easy for beginners
Both [Link] and [Link] are used for
configuration in Spring Boot. YAML is preferred for complex and
hierarchical settings, while properties files are suitable for simple
configurations.
11. What are Spring Boot Actuators, and how are they used to monitor
and manage applications?
 P a g e | 20

Spring Boot Actuator is a module that provides production-

ready features to monitor, manage, and observe Spring Boot
applications through built-in endpoints.
What Are Spring Boot Actuators?
 Actuator exposes management endpoints.
 Helps monitor application health, metrics, and environment.
 Mainly used in production and microservices.
 Accessible via HTTP or JMX.
How Actuator Is Enabled
 Add dependency:
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
Commonly Used Actuator Endpoints
Endpoint Purpose
/actuator/health Application health
status
/actuator/info Application information
/actuator/metrics Performance metrics
/actuator/env Environment properties
/actuator/beans Loaded Spring beans
/actuator/loggers Configure logging levels
/actuator/threaddump JVM thread details
How Actuators Help Monitoring
1. Health Monitoring
 Checks database, disk space, and services.
 Returns status: UP / DOWN.
2. Performance Metrics
 Provides metrics like:
o Memory usage
o CPU load
o HTTP request count and time
 P a g e | 21

3. Application Management
 Dynamic log level changes.
 Shutdown and restart (if enabled).
 View configuration details.
4. Integration with Monitoring Tools
 Works with tools like Prometheus, Grafana, and ELK.
 Useful for cloud and microservices environments.
Security of Actuator Endpoints
 Sensitive endpoints can be restricted.
 Controlled using:
[Link]=health,info
Advantages of Spring Boot Actuator
 Real-time monitoring
 Easy management
 Minimal configuration
 Production-ready support
Spring Boot Actuator provides built-in monitoring and
management endpoints that help developers observe application
health, performance, and behavior, making it essential for
production-grade Spring Boot applications.
12. How do you create REST APIs using Spring Boot? Explain with key
annotations involved.
REST APIs in Spring Boot are used to build stateless web services that
exchange data in formats like JSON or XML. Spring Boot simplifies REST API
creation using Spring MVC and annotations.
Steps to Create REST APIs in Spring Boot
1. Add Required Dependency
 Include Spring Web starter.
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
2. Create REST Controller
 Use @RestController to define REST endpoints.
 P a g e | 22

 It combines @Controller and @ResponseBody.

@RestController
public class HelloController {
}
3. Map Requests to Methods
 Use mapping annotations to handle HTTP requests.
@RequestMapping
 General mapping for all HTTP methods.
@GetMapping
 Handles HTTP GET requests.
@GetMapping("/hello")
public String hello() {
return "Hello Spring Boot";
}
@PostMapping
 Handles HTTP POST requests.
@PostMapping("/student")
public Student saveStudent(@RequestBody Student s) {
return s;
}

4. Key Annotations Used

Annotation Purpose
@RestController Defines REST controller
@GetMapping Handles GET requests
@PostMapping Handles POST requests
@PutMapping Handles PUT requests
@DeleteMappin Handles DELETE requests
g
@RequestBody Reads request body
@PathVariable Reads URL path values
@RequestPara Reads query parameters
m
5. Service Layer (Optional but Recommended)
 Business logic handled using @Service.
6. Return JSON Response
 P a g e | 23

 Spring Boot automatically converts Java objects to JSON using Jackson.

Advantages of REST APIs in Spring Boot
 Minimal configuration
 Embedded server support
 Easy testing and scalability
 Microservices-ready
Spring Boot enables easy REST API development using @RestController,
mapping annotations, and automatic JSON conversion, making it ideal for
modern web and microservice applications.

……………………………………………………………………………………………………………