Core Java, OOP, JDBC/SQL, Servlet/JSP basics, Spring Boot, REST APIs, JPA/Hibernate, testing and a reviewed Java application.
What you will cover
Core Java
OOP
JDBC/SQL
Servlet/JSP basics
Spring Boot
REST APIs
JPA/Hibernate
testing
a reviewed Java application
Topic list from the institute's programme record.
Certification
Certificate terms for this programme are confirmed by the institute at admission. Any ADIVAS course-completion certificate is an institute certificate; it is not a university degree, an externally accredited qualification or a vendor certification (such as AWS or Microsoft) unless the institute states so in writing.
The programme title is as supplied in the institute's list. Please confirm the awarding body and recognition with the institute before enrolling.
Curriculum 0.1 · Draft: written for ADIVAS and awaiting academic review and approval. Topics and weeks may change before your batch starts.
Your skill trail
You move through 7 stations. Each week builds one skill you can show, not just a topic you have heard.
1
Core Java and OOP
Write solid object-oriented Java with classes, interfaces, exceptions and generics.
Week 1 Java setup, syntax and control flow
Week 2 Methods, arrays and Strings
Week 3 Classes, objects and encapsulation
Week 4 Inheritance, interfaces and polymorphism
Week 5 Exceptions and generics
2
Collections, I/O and engineering habits
Process data with collections, streams and files, and work with Maven, Git and JUnit.
Week 6 The Collections Framework
Week 7 Lambdas, streams and file I/O
Week 8 Maven, Git and JUnit testing
3
SQL and JDBC
Design schemas, write SQL and connect Java to MySQL safely.
Week 9 SQL fundamentals with MySQL
Week 10 Joins, aggregates and schema design
Week 11 JDBC and the DAO pattern
Week 12 Transactions and connection pooling
4
Servlet and JSP basics
Understand HTTP and build a small MVC web application.
Week 13 HTTP and Servlets
Week 14 JSP, forms and sessions
Week 15 MVC web application with JDBC
5
Spring Boot and REST
Build layered, validated and tested REST services.
Week 16 Spring Boot foundations
Week 17 REST controllers and JSON
Week 18 Layers, DTOs, validation and error handling
Week 19 Testing Spring Boot applications
6
JPA and Hibernate
Map objects to tables and query data efficiently.
Week 20 JPA entities and repositories
Week 21 Relationships, queries and performance
7
Reviewed Java application
Design, build, test, review and present a complete application.
Week 22 Capstone design and reviewed AI assistance
Week 23 Build, test and harden the application
Week 24 Delivery and review
★
Course Enrolment Service
Your project, reviewed by a trainer.
The ADIVAS mastery ladder: how each skill is recognised
Explored You have seen the idea and tried a first example.
Practising You can do it with hints and keep improving.
Proficient You complete the weekly practical task correctly on your own.
Proven You apply it in a project reviewed by your trainer.
Skill-level tracking is being added to the learner workspace. Your trainer already reviews weekly practical work.
What you will be able to do
Write object-oriented Core Java using classes, interfaces, exceptions, generics and collections.
Use streams, lambdas and file I/O, and manage projects with Maven and Git.
Write unit tests with JUnit and debug failures using the IDE debugger and stack traces.
Design relational schemas and write SQL for CRUD, joins and aggregates in MySQL.
Access a database from Java with JDBC using PreparedStatement, transactions and the DAO pattern.
Explain HTTP and build Servlet and JSP pages with forms, sessions and an MVC structure.
Build layered Spring Boot services with dependency injection, validation and clear error handling.
Design and test REST APIs using correct HTTP methods, status codes and DTOs.
Map entities with JPA/Hibernate, write repository queries and avoid common performance traps.
Use an AI assistant for drafts and review its output for correctness, security and test coverage.
Who it suits
School Class 12 students with some programming exposure who want to see how real web applications are built.
College Diploma and degree students who want a complete, practical Java web development path with databases and testing.
Professional Career changers and working adults who want to build maintainable Java back-end applications through project practice.
Prerequisites: Basic computer skills and logical thinking. Prior programming is helpful; weeks 1 to 2 restart Java from the basics. Tools: JDK 17 or later, IntelliJ IDEA Community Edition or VS Code with Java extensions, Maven, MySQL Community Server and Workbench, Apache Tomcat (Jakarta Servlet container), Spring Boot with Spring Initializr, Git, Postman or curl, An AI coding assistant (with review rules taught in the course).
Weekly plan
Core Java and OOP Weeks 1–5
Week 1: Java setup, syntax and control flow
Theory
JDK, JVM and the compile-run cycle
Variables, types, operators and Scanner input
if, switch and loops
Lab
Install JDK 17 or later and an IDE, then write a fee calculator with GST and a number-pattern printer.
Homework
Write a program that classifies marks into grades and prints a multiplication table.
Deliverable
Three programs in a Git repository with sample runs.
Weekly checkpoint
Predict outputs of snippets involving integer division and loops.
You will be able to
Write object-oriented Core Java using classes, interfaces, exceptions, generics and collections.
Week 2: Methods, arrays and Strings
Theory
Methods, overloading and recursion basics
Arrays and two-dimensional arrays
String, StringBuilder and common String methods
Lab
Build a text utility (palindrome, word count, vowel count) and a marks analyser using arrays and methods.
Homework
Write a method that validates an Indian mobile number and test it with eight inputs.
Deliverable
A utility class with documented methods and test inputs.
Weekly checkpoint
Debug an equals versus == String bug and an array out-of-bounds loop.
You will be able to
Write object-oriented Core Java using classes, interfaces, exceptions, generics and collections.
Week 3: Classes, objects and encapsulation
Theory
Fields, constructors, this and static
Encapsulation with access modifiers
toString, equals and hashCode contract
Lab
Model Customer and Account classes for a bank and implement deposit and withdraw rules.
Homework
Override equals and hashCode in Customer and explain why both are needed.
Deliverable
A bank model with a demo class.
Weekly checkpoint
Read a class and predict output including static counters.
You will be able to
Write object-oriented Core Java using classes, interfaces, exceptions, generics and collections.
Week 4: Inheritance, interfaces and polymorphism
Theory
extends, super, method overriding
Abstract classes and interfaces, default methods
Composition over inheritance
Lab
Build a payment system with an interface Payable implemented by CardPayment and UpiPayment and process them through one list.
Homework
Refactor an inheritance tree into composition where the relation is 'has-a'.
Deliverable
A payment module with a short design note.
Weekly checkpoint
Predict dynamic dispatch results; choose interface or abstract class.
You will be able to
Write object-oriented Core Java using classes, interfaces, exceptions, generics and collections.
Week 5: Exceptions and generics
Theory
Checked and unchecked exceptions, try-with-resources
Custom exceptions
Generic classes and methods, bounded types basics
Lab
Add InsufficientBalanceException to the bank model and write a generic Pair class and a generic max method.
Homework
Make a retrying input reader that handles bad numbers gracefully.
Deliverable
Bank model with custom exceptions and a generic utility.
Weekly checkpoint
Trace try/catch/finally output; identify a compile error from a generic misuse.
You will be able to
Write object-oriented Core Java using classes, interfaces, exceptions, generics and collections.
Collections, I/O and engineering habits Weeks 6–8
Week 6: The Collections Framework
Theory
List, Set, Map and their implementations
Iteration, sorting with Comparable and Comparator
Choosing a collection by access pattern
Lab
Load 50 student records into collections and produce a sorted rank list, a unique city set and a marks-by-class map.
Homework
Count word frequencies of a paragraph with a HashMap and print the top five.
Deliverable
A collections-based report program.
Weekly checkpoint
Pick the right collection for four scenarios; predict HashMap output.
You will be able to
Write object-oriented Core Java using classes, interfaces, exceptions, generics and collections.
Week 7: Lambdas, streams and file I/O
Theory
Lambda expressions and functional interfaces
Stream filter, map, collect and Optional
Reading and writing files with java.nio.file
Lab
Read a CSV of sales from a file and use streams to compute totals per category and the top three products.
Homework
Rewrite two loops from week 6 as streams and compare readability.
Deliverable
A CSV sales analyser.
Weekly checkpoint
Predict the result of a short stream pipeline.
You will be able to
Use streams, lambdas and file I/O, and manage projects with Maven and Git.
Week 8: Maven, Git and JUnit testing
Theory
Maven project structure and dependencies
Git branches and pull requests
JUnit 5 tests, assertions and test-driven thinking; debugging with breakpoints
Lab
Convert an earlier project to Maven, write ten JUnit tests including boundary and failure cases and fix two bugs found by them.
Homework
Add a GitHub-style README and a .gitignore to the repository.
Deliverable
A Maven project with passing tests and a clean Git history.
Weekly checkpoint
Read a failing test report and locate the bug.
You will be able to
Use streams, lambdas and file I/O, and manage projects with Maven and Git. Write unit tests with JUnit and debug failures using the IDE debugger and stack traces.
SQL and JDBC Weeks 9–12
Week 9: SQL fundamentals with MySQL
Theory
Relational model, primary and foreign keys
CREATE, INSERT, SELECT, UPDATE, DELETE
WHERE, ORDER BY, LIMIT and NULL handling
Lab
Create a library database and practise 15 CRUD queries on books, members and loans.
Homework
Write queries for overdue loans and members with no loans.
Deliverable
A SQL script with schema, sample data and solved queries.
Weekly checkpoint
Read queries and state their results; spot a missing WHERE in an UPDATE.
You will be able to
Design relational schemas and write SQL for CRUD, joins and aggregates in MySQL.
Week 10: Joins, aggregates and schema design
Theory
INNER and LEFT JOIN
GROUP BY and HAVING
Normalisation to 3NF and one-to-many and many-to-many relations
Lab
Normalise an orders spreadsheet into four tables and write reporting queries with joins and grouping.
Homework
Draw an ER diagram for a hospital appointment system.
Deliverable
ER diagram and a reporting query set.
Weekly checkpoint
Predict the row count of a join; choose WHERE or HAVING.
You will be able to
Design relational schemas and write SQL for CRUD, joins and aggregates in MySQL.
Write BookDao with add, find, update and delete methods using PreparedStatement and a console menu on top.
Homework
Demonstrate an injection on a concatenated query and then block it.
Deliverable
A JDBC library application with a DAO layer.
Weekly checkpoint
Rewrite an unsafe query safely; find a resource leak.
You will be able to
Access a database from Java with JDBC using PreparedStatement, transactions and the DAO pattern.
Week 12: Transactions and connection pooling
Theory
Transactions, commit, rollback and isolation overview
Batch inserts
Connection pool concept and configuration outside the code
Lab
Implement a book-issue operation that updates two tables in one transaction and rolls back on failure, then test the failure path.
Homework
Move credentials to a properties file that is excluded from Git.
Deliverable
Library application with transactional issue and return.
Weekly checkpoint
Explain why issue and stock update must succeed together; predict the result after a rollback.
You will be able to
Access a database from Java with JDBC using PreparedStatement, transactions and the DAO pattern.
Servlet and JSP basics Weeks 13–15
Week 13: HTTP and Servlets
Theory
HTTP requests, responses, methods and status codes
Servlet container, lifecycle and Jakarta Servlet API
Reading form data and writing responses
Lab
Deploy a Servlet on Tomcat that greets by name from a form, and inspect the request and response in the browser's network tab.
Homework
Write a Servlet that returns a course fee quote with GST for an amount sent as a parameter.
Deliverable
A running Servlet application with screenshots of request and response.
Weekly checkpoint
Sequence the steps of a request; match status codes to meanings.
You will be able to
Explain HTTP and build Servlet and JSP pages with forms, sessions and an MVC structure.
Week 14: JSP, forms and sessions
Theory
JSP and expression language
Cookies, sessions and login state
Input validation and output escaping
Lab
Build a login and registration flow with a session, and show a user-specific page.
Homework
Add output escaping and demonstrate why unescaped input is dangerous.
Deliverable
A login-protected JSP application.
Weekly checkpoint
Explain how a session keeps a user logged in; spot an XSS risk.
You will be able to
Explain HTTP and build Servlet and JSP pages with forms, sessions and an MVC structure.
Week 15: MVC web application with JDBC
Theory
Model-View-Controller with Servlet as controller
Filters for authentication
Error pages and redirect-after-post
Lab
Build a library web app combining Servlets, JSP views and the JDBC DAO layer, with a filter protecting admin pages.
Homework
Add a search page and pagination.
Deliverable
A small MVC web application running on Tomcat.
Weekly checkpoint
Practical: add a field end to end across the layers.
You will be able to
Access a database from Java with JDBC using PreparedStatement, transactions and the DAO pattern. Explain HTTP and build Servlet and JSP pages with forms, sessions and an MVC structure.
Spring Boot and REST Weeks 16–19
Week 16: Spring Boot foundations
Theory
Inversion of control and dependency injection
Spring Initializr, starters and application properties
Beans, components and configuration profiles
Lab
Generate a Spring Boot project with Initializr, create a service bean injected into a controller and run it from Maven.
Homework
Explain constructor injection against a hand-written new and show a unit test that benefits.
Deliverable
A running Spring Boot skeleton with a service bean.
Weekly checkpoint
Identify what the container creates; trace an injection.
You will be able to
Build layered Spring Boot services with dependency injection, validation and clear error handling.
Week 17: REST controllers and JSON
Theory
REST resources, HTTP methods and idempotency
@RestController, @PathVariable, @RequestBody
Status codes: 200, 201, 204, 400, 404, 409
Lab
Build a Course resource API with GET, POST, PUT and DELETE using an in-memory list and test it with Postman.
Homework
Return correct status codes for missing items and duplicates.
Deliverable
A tested Course REST API.
Weekly checkpoint
Choose the correct method and status code for five operations.
You will be able to
Design and test REST APIs using correct HTTP methods, status codes and DTOs.
Week 18: Layers, DTOs, validation and error handling
Theory
Controller, service and repository layers
DTOs versus entities
Bean Validation and a global exception handler
Lab
Refactor the Course API into layers, add validation rules and return a consistent JSON error body.
Homework
Write three error-case requests and their expected responses.
Deliverable
A layered API with validation and error handling.
Weekly checkpoint
Find why an entity returned directly leaks a field; fix a validation gap.
You will be able to
Build layered Spring Boot services with dependency injection, validation and clear error handling. Design and test REST APIs using correct HTTP methods, status codes and DTOs.
Week 19: Testing Spring Boot applications
Theory
Unit testing services with mocks
Controller tests with MockMvc
Test data and the test pyramid
Lab
Write service tests with a mock repository and MockMvc tests for success, validation failure and not-found responses.
Homework
Reach a meaningful test for each endpoint and list what is still untested.
Deliverable
A test suite with a short coverage note.
Weekly checkpoint
Read a failing MockMvc test and identify the issue.
You will be able to
Write unit tests with JUnit and debug failures using the IDE debugger and stack traces. Design and test REST APIs using correct HTTP methods, status codes and DTOs.
JPA and Hibernate Weeks 20–21
Week 20: JPA entities and repositories
Theory
ORM idea, JPA and Hibernate
@Entity, @Id, @Column and generated keys
Spring Data repositories and derived query methods
Lab
Replace the in-memory list with a JPA entity and repository on MySQL and inspect the SQL that Hibernate prints.
Homework
Add derived queries to find courses by level and by fee range.
Deliverable
Course API backed by MySQL through JPA.
Weekly checkpoint
Match annotations to their purpose; predict the table that an entity produces.
You will be able to
Map entities with JPA/Hibernate, write repository queries and avoid common performance traps.
Week 21: Relationships, queries and performance
Theory
@OneToMany, @ManyToOne and @ManyToMany
JPQL, pagination and fetch types
The N+1 query problem and @Transactional
Lab
Add Student and Enrollment entities, observe an N+1 problem in the SQL log and fix it with a join fetch query.
Homework
Add pagination to the list endpoint and verify the generated SQL.
Deliverable
A relationship model with a before-and-after SQL log.
Weekly checkpoint
Explain N+1 with an example; choose lazy or eager loading for a case.
You will be able to
Map entities with JPA/Hibernate, write repository queries and avoid common performance traps.
Reviewed Java application Weeks 22–24
Week 22: Capstone design and reviewed AI assistance
Theory
Requirements, API contract and schema design
Prompting with context and constraints
A review checklist for AI-written code: correctness, security, tests, licensing, privacy
Lab
Design the capstone, ask an AI assistant to draft a service class, then review and test it, recording every defect found.
Homework
Finalise the schema and API list and a review log.
Deliverable
Design document, ER diagram, API list and AI review log.
Weekly checkpoint
Review a given AI draft and list defects and tests.
You will be able to
Use an AI assistant for drafts and review its output for correctness, security and test coverage.
Week 23: Build, test and harden the application
Theory
Authentication basics and password hashing concept
Logging and configuration management
Integration testing against a test database
Lab
Implement the capstone endpoints with validation, error handling, logging and integration tests.
Homework
Fix issues from a peer review.
Deliverable
A working application with tests and a feature checklist.
Weekly checkpoint
Demonstrate three endpoints and a handled error.
You will be able to
Build layered Spring Boot services with dependency injection, validation and clear error handling. Design and test REST APIs using correct HTTP methods, status codes and DTOs. Map entities with JPA/Hibernate, write repository queries and avoid common performance traps.
Week 24: Delivery and review
Theory
Packaging an executable jar
Writing a README and an API guide
Presenting trade-offs and lessons learned
Lab
Package and run the application from the jar, demonstrate it, and answer code-level questions in a viva.
Homework
Submit a tagged repository and a one-page reflection.
Deliverable
Tagged repository with README, API guide, test report and demo.
Weekly checkpoint
Final practical and viva.
You will be able to
Use streams, lambdas and file I/O, and manage projects with Maven and Git. Write unit tests with JUnit and debug failures using the IDE debugger and stack traces. Use an AI assistant for drafts and review its output for correctness, security and test coverage.
Sample lessons
Week 17
Designing a REST API: methods and status codes
A REST API exposes resources such as courses at URLs like /api/courses/5, and uses HTTP methods to say what to do: GET reads, POST creates, PUT replaces or updates and DELETE removes. The response status code tells the client what happened: 200 means success, 201 means created, 404 means the resource was not found and 400 or 409 report a bad request or a conflict. Using these consistently makes an API predictable for every client developer.
Method
URL
Action
Success code
GET
/api/courses
List courses
200
GET
/api/courses/5
Read one course
200
POST
/api/courses
Create a course
201
PUT
/api/courses/5
Update a course
200
DELETE
/api/courses/5
Remove a course
204
Step by step
List the resource and its URL: /api/courses and /api/courses/{id}.
Map operations to methods: GET list, GET one, POST create, PUT update, DELETE remove.
Write a @RestController method for each operation.
Return ResponseEntity with 201 after creating and 404 when the id does not exist.
Test each call in Postman and check the status code and JSON body.
In real life
A mobile app for a coaching institute calls the same API to list courses and enrol a student. If the API returns a 200 for an error, the app cannot tell what really happened.
Worked example
Problem. A client sends POST /api/courses with valid JSON and the course is saved with id 8. Which status and header should be returned?
Solution. Return 201 Created and a Location header such as /api/courses/8, with the created course in the body.
Common mistakes
Using POST for everything, so methods lose their meaning.
Returning 200 with an error message in the body instead of the correct 4xx status.
Try it yourself
Choose the method and status code for: delete a course that does not exist; update a course successfully.
Design URLs for students and their enrolments.
Week 11
JDBC with PreparedStatement and the DAO pattern
JDBC is the standard Java API for talking to a relational database. You open a Connection, send SQL through a PreparedStatement and read the rows from a ResultSet. Using ? placeholders keeps user input as data, which prevents SQL injection. A DAO (data access object) class gathers all SQL for one table in one place so the rest of the program never touches SQL directly.
Console or web page
Service logic
DAO with PreparedStatement
JDBC driver
MySQL database
Step by step
Add the MySQL driver dependency in Maven.
Open a Connection in a try-with-resources block using settings from a properties file.
Prepare INSERT INTO books(title, author) VALUES (?, ?) and set the parameters.
Execute, then read generated keys or a ResultSet for queries.
Wrap this in BookDao methods such as add, findById and delete.
In real life
A library desk system has to look up a member by phone number thousands of times a day. A DAO keeps that lookup in one tested method instead of repeating SQL across screens.
Worked example
Problem. Write the call that finds a book by id using a PreparedStatement.
Solution. String sql = "SELECT title FROM books WHERE id = ?";
try (PreparedStatement ps = con.prepareStatement(sql)) {
ps.setInt(1, id);
try (ResultSet rs = ps.executeQuery()) {
if (rs.next()) return rs.getString("title");
}
}
return null;
Common mistakes
Building SQL by joining strings with user input.
Not closing connections, so the database eventually runs out of connections.
Try it yourself
Write BookDao.update(id, title) using PreparedStatement.
Explain what a ResultSet cursor does before rs.next() is called.
Try the questions
The same skills are asked at three levels: School (Classes 6–12), College and Professional. Switch the level and the language (English or Tamil), and say how sure you are before you check: knowing what you are unsure about is part of learning.
Classes 6–12: everyday examples, no prior knowledge. Practice only. Nothing here is graded or saved.
Question 1 / 4 · Understand platform independence
A Java program written on a Windows laptop runs unchanged on a Linux computer. Which part makes this possible?
Projects
Course Enrolment Service
Build a layered Spring Boot REST application backed by MySQL that manages courses, students and enrolments for a small training institute. Include validation, error handling and automated tests, and keep a review log for any AI-assisted code.
Tasks
Design the schema with at least three tables, a many-to-many relation and an ER diagram.
Implement entities and repositories with JPA and add a custom query with pagination.
Create REST endpoints for courses, students and enrolments with correct methods and status codes.
Add Bean Validation and a global exception handler returning a consistent error body.
Write unit tests for services and MockMvc tests for every endpoint including failure paths.
Document the API in a README and keep an AI review log of accepted, changed and rejected suggestions.
Sample input
POST /api/enrolments with {"studentId": 12, "courseId": 5} when student 12 is already enrolled in course 5
Expected output
HTTP 409 with a JSON error message 'Student already enrolled', no new row created and the related test passing.
How it is assessed
Criterion
Weight
Schema and JPA mapping
20%
REST design and correct status codes
20%
Validation and error handling
15%
Automated tests
20%
Code structure and Git history
10%
AI review log and documentation
15%
Stretch challenge: Add token-based login for admin endpoints and a report endpoint of enrolments per course.
Library Web App (Servlet/JSP with JDBC)
Build a classic MVC web application with Servlets, JSP and JDBC that lets a librarian log in, search books, issue and return them. It must use PreparedStatement everywhere and a transaction for issue and return.
Tasks
Create the schema and a DAO layer using PreparedStatement.
Write Servlets as controllers and JSP pages as views.
Protect librarian pages with a session and a filter.
Make issue and return transactional.
Escape output and validate all inputs.
Sample input
Librarian issues book B21 to member M08 while B21 has zero copies available.
Expected output
The page shows 'No copies available' and the database remains unchanged.
How it is assessed
Criterion
Weight
MVC structure
25%
Safe JDBC and transactions
30%
Session security and validation
25%
Working features and demo
20%
Stretch challenge: Add a fine calculation for late returns.
How you are assessed
Each week has a 25-minute checkpoint of 6 questions mixing code reading, output prediction, debugging and one design or SQL item, plus a lab submission checked against listed test cases.
Practical work. Practicals at weeks 8, 15 and 24: solve unseen problems in Java, debug a seeded failure, write SQL against a given schema, extend an endpoint and explain choices in a viva.
What trainers look for
Weight
Correctness against test cases
25%
Code quality, OOP and layered design
25%
Testing and debugging
20%
Database and API design
20%
Explanation and responsible AI use
10%
Where this can lead
Prepares you for junior Java developer and back-end trainee roles.
Prepares you to build and test REST services backed by relational databases.
Gives a strong base for further study of Spring Security, microservices and cloud deployment.
These describe skills you will build. ADIVAS does not guarantee jobs, placement or salary.
Other programmes in Programming & Software Development
