Java Full Stack Development: From Core Java to Microservices – Live Training
(Become an industry-ready Java Full Stack Developer with hands-on projects and real-world case studies. Learn to design, develop, and deploy modern web applications using Spring Boot and Microservices.)
The “Java Full Stack Development: From Core Java to Microservices” course is a comprehensive, hands-on program designed to help you become a proficient full stack developer using the Java ecosystem. This course covers everything from foundational Java programming concepts to advanced enterprise application development with Spring Framework, Hibernate, RESTful APIs, Spring Boot, and Microservices.
Through structured modules, you’ll gain in-depth knowledge of backend technologies, database integration, and front-end connectivity, enabling you to design, build, and deploy complete web applications. You’ll also learn to implement security, testing, performance optimization, and cloud deployment best practices followed by modern software industries.
By the end of the course, you will be capable of developing scalable, secure, and production-ready full stack applications, and will be fully equipped for roles such as Java Developer, Full Stack Engineer, or Backend Developer in enterprise-level projects.
About the Instructor:
|
Trainer Profile – Jagdev Jagdev is a highly experienced corporate trainer and full stack development expert with over a 10 years of hands-on experience in Java technologies. He has successfully delivered numerous corporate and online training programs on Core Java, Spring Framework, Hibernate, REST APIs, and Microservices. Known for his clear explanations and real-world teaching approach, Jagdev bridges the gap between theoretical concepts and practical implementation. His sessions emphasize coding best practices, design patterns, and industry standards that help learners build production-grade applications confidently. Over the years, he has trained and mentored 400+ professionals worldwide, helping many of them transition into successful Java Full Stack Developer roles across top organizations. |
“Java Full Stack Development: From Core Java to Microservices” – Demo Video
“Java Full Stack Development: From Core Java to Microservices” – Day 1 Video
Live Sessions Price:
For LIVE sessions – Offer price after discount is 300 USD 259 119 USD Or USD25000 INR 15900 INR 9900 Rupees
OR
Free Day 2 Session on:
19th November @ 9 PM – 10 PM (IST) (Indian Timings)/
19th November @ 10:30 AM – 11:30 AM (EST) (U.S Timings)/
19th November @ 3:30 PM – 4:30 PM (BST) (UK Timings)
Class Schedule:
For Participants in India: Monday to Friday @ 9:00 PM – 10:00 PM (IST)
For Participants in the US: Monday to Friday @ 10:30 AM – 11:30 AM (EST)
For Participants in the UK: Monday to Friday @ 3:30 PM – 4:30 PM (BST)
What students have to say about Jagdev:
|
👨 Arun Bhatia: 👩 Humera Nikath: 👨 Miguel Santos: 👩 Priya Menon: 👨 Yusuf: 👩 Srikshitha: |
Salient Features:
- 45+ Hours of Live Training along with recorded videos
- Lifetime access to the recorded videos
- Course Completion Certificate
Who can enroll for this course?
- IT professionals or software developers looking to transition into full stack roles.
- Java developers who want to upgrade their skills in Spring Boot, Hibernate, and Microservices.
- Fresh graduates or students seeking a career in software development.
- Testers, support engineers, or analysts interested in learning application development.
- Backend or frontend developers who want to become end-to-end full stack engineers.
- Anyone passionate about coding and eager to build scalable enterprise applications using Java.
What will I learn by the end of this course?
-
Build robust backend applications using Spring Framework, Spring Boot, and Hibernate.
-
Develop and consume RESTful APIs with proper versioning, validation, and error handling.
-
Work with Spring Data JPA for seamless database integration and data persistence.
-
Secure applications using Spring Security, JWT, and OAuth2 authentication.
-
Implement Microservices architecture with service discovery, API Gateway, and inter-service communication.
-
Manage configurations, monitoring, and deployment using Spring Boot Actuator, Docker, and Kubernetes.
-
Apply AOP, MVC, and dependency injection principles for modular, maintainable code.
-
Write unit and integration tests with JUnit and Mockito for reliable, production-ready applications.
-
Integrate the backend with modern frontend frameworks like React or Angular through REST APIs.
-
Follow real-world project workflows from requirement gathering to deployment.
Course syllabus:
1. Spring Core
- Core Concepts
- Inversion of Control (IoC)
- Dependency Injection (DI)
- Spring Container
- Bean Lifecycle
- Spring Modules Overview
- Bean Configuration
- XML-based Configuration
- Annotation-based Configuration
- Java-based Configuration (@Configuration, @Bean)
- Component Scanning (@Component, @Service, @Repository, @Controller)
- Autowiring (@Autowired, @Qualifier)
- Spring Containers
- BeanFactory
- ApplicationContext
- WebApplicationContext
- Context Hierarchies
- Bean Scope and Lifecycle
- Scopes: Singleton, Prototype, Request, Session, Application
- Bean Lifecycle Methods (init-method, destroy-method)
- @PostConstruct and @PreDestroy
- BeanPostProcessor
- InitializingBean and DisposableBean
- Spring Expression Language (SpEL)
- Syntax and Operators
- Accessing Properties and Methods
- Conditional Expressions
- Using SpEL in Annotations
- Event Handling
- ApplicationEvent and ApplicationListener
- Custom Events
- Event Publishing
- Testing Spring Applications
- Unit Testing with JUnit and Mockito
- @ContextConfiguration
- @RunWith(SpringRunner.class)
- @SpringBootTest (if using Spring Boot)
- Utility Features
- Environment Abstraction
- Property Sources and Profiles
- Type Conversion and Formatting
- Resource Loading
2. Hibernate- ORM
- Fundamentals
- What is Hibernate?
- ORM (Object Relational Mapping) Basics
- Hibernate vs JDBC vs JPA
- Hibernate Architecture
- Hibernate Lifecycle
- Configuration
- Hibernate Configuration File (hibernate.cfg.xml)
- Mapping Files (*.hbm.xml)
- Annotation-Based Configuration (@Entity, @Table, etc.)
- Hibernate Properties (dialect, connection settings)
- Core Annotations
- @Entity, @Table, @Id, @GeneratedValue
- @Column, @Transient, @Enumerated
- @OneToOne, @OneToMany, @ManyToOne, @ManyToMany
- @JoinColumn, @JoinTable
- Querying
- HQL (Hibernate Query Language)
- JPQL (Java Persistence Query Language)
- Native SQL Queries
- Named Queries
- Criteria API
- Query Parameters and Pagination
- Transactions and Session Management
- Hibernate Session and SessionFactory
- Transaction Management
- flush(), clear(), evict()
- Auto-commit and Manual Commit
- Caching
- First-Level Cache
- Second-Level Cache
- Query Cache
- Cache Providers (Ehcache, Infinispan)
- Performance Optimization
- Lazy vs Eager Loading
- Batch Fetching
- Fetch Strategies (JOIN, SELECT)
- N+1 Problem and Solutions
- Inheritance Mapping
- @Inheritance(strategy = …)
- Single Table, Joined Table, Table per Class
- Concurrency and Locking
- Optimistic Locking (@Version)
- Pessimistic Locking
- Isolation Levels
- Testing and Tools
- Hibernate with JUnit
- In-memory Databases (H2, HSQLDB)
- Hibernate Validator
- Hibernate Envers (Auditing)
- Integration
- Hibernate with Spring
- Hibernate with JPA
- Hibernate with Maven/Gradle
- Hibernate with REST APIs
- Miscellaneous
- Custom Types and UserType
- Interceptors and Event Listeners
- Entity Graphs
- Multi-tenancy Support
3. Spring Data JPA
- Basic Concepts
- JPA vs Hibernate vs JDBC
- Entity and Table Mapping
- Primary Keys and @Id
- Relationships: @OneToOne, @OneToMany, @ManyToOne, @ManyToMany
- Cascade Types and Fetch Strategies
- Repository Interfaces
- CrudRepository
- JpaRepository
- PagingAndSortingRepository
- QueryByExampleExecutor
- Query Methods
- Derived Query Methods (e.g. findByName, findByAgeGreaterThan)
- Custom Queries with @Query
- Native Queries with @Query(nativeQuery = true)
- Named Queries
- JPQL (Java Persistence Query Language)
- Pagination and Sorting
- Pageable and Sort
- Page and Slice
- Transactions and Auditing
- @Transactional
- @EnableJpaAuditing
- @CreatedDate, @LastModifiedDate
- Advanced Features
- Specifications (JpaSpecificationExecutor)
- Projections (Interface-based and DTO-based)
- Entity Graphs (@EntityGraph)
- Locking (@Lock, @Version)
- Custom Repository Implementations
- Testing and Configuration
- In-memory Databases (H2, HSQL)
- @DataJpaTest
- @EnableJpaRepositories
- Spring Boot Auto Configuration
4. REST CRUD API
- What is REST?
- Principles of REST (Statelessness, Uniform Interface, etc.)
- CRUD Operations: Create, Read, Update, Delete
- Tools and Testing
- Postman / Insomnia
- Swagger / OpenAPI
- Curl / HTTPie
- Versioning Strategies
- URI versioning: /api/v1/items
- Header versioning: Accept: application/vnd.api.v1+json
- Parameter versioning: /api/items?version=1
5. Spring Security
- Core Concepts
- What is Spring Security?
- Authentication vs Authorization
- Security Filters and Filter Chain
- SecurityContext and SecurityContextHolder
- Principal and GrantedAuthority
- Configuration Styles
- XML-based Configuration
- Java-based Configuration (@EnableWebSecurity, SecurityFilterChain)
- Spring Boot Auto-Configuration
- Authentication
- Form-Based Login
- Basic Authentication
- Digest Authentication
- Custom Login Pages
- AuthenticationManager and AuthenticationProvider
- UserDetails and UserDetailsService
- Password Encoding (BCryptPasswordEncoder)
- Authorization
- Role-Based Access Control (hasRole, hasAuthority)
- Method-Level Security (@PreAuthorize, @Secured, @PostAuthorize)
- URL-Based Authorization (antMatchers, requestMatchers)
- AccessDecisionManager and Voters
- Session and CSRF
- Session Management
- CSRF Protection
- CORS Configuration
- Remember-Me Authentication
- JWT and Token-Based Security
- Stateless Authentication
- JWT Token Generation and Validation
- Custom Filters for JWT
- SecurityContext Population from Token
- OAuth2 and OpenID Connect
- OAuth2 Client and Resource Server
- Authorization Code Flow
- PKCE Support
- OpenID Connect Integration
- Scopes and Consent Pages
- Advanced Features
- Security Events and Listeners
- Custom Authentication Filters
- Custom AccessDeniedHandler and AuthenticationEntryPoint
- Multi-Tenant Security
- Security with Reactive Stack (WebFlux)
- Testing and Debugging
- @WithMockUser and @WithUserDetails
- Spring Security Test Support
- Debugging Filter Chains
- Security Debug Mode
- Integration
- Spring Security with Spring MVC
- Spring Security with REST APIs
- Spring Security with Thymeleaf
- Spring Security with Spring Boot
6. Spring MVC
- Core Concepts
- Model-View-Controller (MVC) Architecture
- DispatcherServlet
- HandlerMapping
- Controller and ViewResolver
- Request Flow in Spring MVC
- Controller Layer
- @Controller and @RestController
- @RequestMapping, @GetMapping, @PostMapping, etc.
- @PathVariable, @RequestParam, @RequestBody
- @ModelAttribute
- Exception Handling (@ExceptionHandler, @ControllerAdvice)
- Model and View
- Model, ModelMap, and ModelAndView
- Data Binding and Form Handling
- View Technologies: JSP, Thymeleaf, FreeMarker
- ViewResolver Configuration
- Form Handling
- HTML Forms and Spring Binding
- @InitBinder and WebDataBinder
- Validation with JSR-303 (@Valid, @Validated)
- Custom Validators
- Session and State Management
- @SessionAttributes
- HttpSession and SessionStatus
- Cookies and Flash Attributes
- Integration and Configuration
- XML vs Java-based Configuration
- @EnableWebMvc
- Spring Boot Auto Configuration for MVC
- Static Resource Handling (/resources/**)
- Internationalization (i18n)
- Pagination and Sorting
- Handling Pageable Requests
- Integration with Spring Data
- Testing
- Unit Testing Controllers with MockMvc
- Integration Testing with @WebMvcTest
- Testing REST APIs
- Miscellaneous
- File Upload Handling (MultipartFile)
- Interceptors (HandlerInterceptor)
- Filters and Custom Middleware
- Content Negotiation
- CORS Configuration
7. AOP
- Core Concepts
- Aspect-Oriented Programming (AOP): Separating cross-cutting concerns from business logic.
- Aspect: A module that encapsulates behaviors affecting multiple classes.
- Advice: Action taken at a particular join point (e.g., @Before, @After, @Around).
- Join Point: A point during execution (e.g., method call) where advice can be applied.
- Pointcut: Expression that matches join points.
- Weaving: Linking aspects with other application types (compile-time, load-time, or runtime).
- Annotations and Advice Types
- @Aspect
- @Before
- @After
- @AfterReturning
- @AfterThrowing
- @Around
- @Pointcut
- Configuration Styles
- Annotation-based Configuration
- XML-based Configuration
- Java-based Configuration (@EnableAspectJAutoProxy)
- Pointcut Expressions
- Matching method signatures
- Wildcards and patterns
- Combining pointcuts (&&, ||, !)
- Targeting specific packages or annotations
- Proxy Mechanism
- JDK Dynamic Proxy (for interfaces)
- CGLIB Proxy (for classes)
- Limitations of proxy-based AOP
- Use Cases
- Logging
- Security checks
- Transaction management
- Performance monitoring
- Exception tracking
- Testing and Debugging
- Verifying advice execution
- Using logs to trace AOP behavior
- Testing with mock aspects
- Integration
- Spring AOP vs AspectJ
- Using AspectJ annotations in Spring
- Combining AOP with Spring Boot
- AOP in Spring Web and REST APIs
8. Spring Boot
- Core Concepts
- What is Spring Boot?
- Spring Boot vs Spring Framework
- Auto-Configuration
- Spring Boot Starters
- Spring Boot CLI
- Spring Boot Initializer
- Configuration
- properties / application.yml
- Profiles (@Profile)
- Externalized Configuration
- Environment Abstraction
- Dependency Management
- Maven and Gradle Integration
- Spring Boot BOM (Bill of Materials)
- Version Compatibility
- Web Development
- Spring Boot with Spring MVC
- RESTful APIs (@RestController, @RequestMapping)
- Content Negotiation
- Exception Handling (@ControllerAdvice)
- File Uploads
- Security
- Spring Boot with Spring Security
- Form Login and Basic Auth
- JWT Integration
- OAuth2 and OpenID Connect
- Role-Based Access Control
- Data Access
- Spring Boot with Spring Data JPA
- Entity Mapping and Repositories
- Query Methods and @Query
- Pagination and Sorting
- Database Initialization (schema.sql, data.sql)
- Flyway and Liquibase Integration
- Monitoring and Management
- Spring Boot Actuator
- Health Checks and Metrics
- Custom Endpoints
- Micrometer Integration
- Testing
- @SpringBootTest
- @WebMvcTest, @DataJpaTest
- MockMvc and TestRestTemplate
- Profile-based Testing
- Dev Tools and Utilities
- Spring Boot DevTools
- Live Reload
- Configuration Reloading
- Microservices and Cloud
- Spring Boot with Spring Cloud
- Service Discovery (Eureka)
- API Gateway (Spring Cloud Gateway)
- Circuit Breaker (Resilience4j)
- Config Server
- Distributed Tracing (Zipkin, Sleuth)
- Packaging and Deployment
- Embedded Servers (Tomcat, Jetty, Undertow)
- Executable JARs and WARs
- Dockerizing Spring Boot Apps
- Kubernetes Deployment
- Cloud Platforms (AWS, Azure, GCP)
- Frontend Integration
- Spring Boot with Thymeleaf
- Spring Boot with React/Angular (via REST APIs)
- Static Resource Handling
9. Microservice
- Core Concepts
- What are Microservices?
- Monolith vs Microservices
- Domain-Driven Design (DDD)
- Service Independence and Loose Coupling
- Bounded Contexts
- Scalability and Fault Isolation
- Design Principles
- Single Responsibility Principle
- Decentralized Data Management
- API Contracts and Versioning
- Resilience and Fault Tolerance
- Automation and CI/CD
- Observability and Monitoring
- Communication Patterns
- Synchronous (REST, gRPC)
- Asynchronous (Message Queues, Kafka)
- Event-Driven Architecture
- Choreography vs Orchestration
- Service Discovery
- Key Patterns
- API Gateway
- Circuit Breaker
- Bulkhead
- Retry and Timeout
- Saga Pattern (Choreography & Orchestration)
- Strangler Fig Pattern
- Database per Service
- Security
- Authentication and Authorization
- OAuth2 and OpenID Connect
- JWT Tokens
- Service-to-Service Security
- Rate Limiting and Throttling
- Deployment and Infrastructure
- Containers (Docker)
- Container Orchestration (Kubernetes)
- Service Mesh (Istio, Linkerd)
- CI/CD Pipelines
- Blue-Green and Canary Deployments
- Monitoring and Observability
- Centralized Logging (ELK Stack)
- Distributed Tracing (Zipkin, Jaeger)
- Metrics Collection (Prometheus, Grafana)
- Health Checks and Alerts
- Testing Strategies
- Unit Testing
- Contract Testing (Pact)
- Integration Testing
- End-to-End Testing
- Consumer-Driven Contracts
Live Sessions Price:
For LIVE sessions – Offer price after discount is 300 USD 259 119 USD Or USD25000 INR 15900 INR 9900 Rupees