Course Code: nabbespoke
Duration: 56 hours
Overview:

This instructor-led, live training (online or onsite) is aimed at beginner-level / intermediate-level / advanced-level ___ who wish to use ___ to ___.

By the end of this training, participants will be able to:

  • Install and configure ___.
  • ___. 
  • ___. 
  • ___. 

Format of the Course

Course Customization Options

  • To request a customized training for this course, please contact us to arrange.
Course Outline:

The Bespoke course outline ( 8 days training , 7 hours per days)
Advanced OOP Fundamentals and Principles ( Day 1)
 Introduction and Objectives
 Understanding the training goals
 Quick review of OOP basics: encapsulation, inheritance, polymorphism
 Deep Dive into SOLID Principles
 Single Responsibility Principle: Detailed examples and scenarios
 Open/Closed Principle: Refactoring examples
 Liskov Substitution Principle: Code demonstrations
 Interface Segregation Principle: Identifying violations
 Dependency Inversion Principle: Real-world applications
 Code Smells and Refactoring Techniques
 Identifying common code smells (e.g., God Object, Duplicated Code)
 Refactoring strategies: Decomposing large methods, eliminating dependencies
 Case study: Refactoring a sample legacy codebase
 Practical Exercises
 Group activity: Identify and fix code smells in provided examples
 Discuss solutions and improvement areas
Design Patterns ( Day 2 & Day 3)
 Introduction to Design Patterns
 Definition and purpose of design patterns
 Categories: Creational, Structural, Behavioral
 Creational Design Patterns
 Singleton: Implementation and thread-safety considerations
 Factory Method: Use cases and advantages
 Abstract Factory: When and why to use
 Builder Pattern: Handling complex object creation
 Prototype: Cloning and memory management
 Hands-On Exercises
 Implementing Singleton and Factory patterns
 Team task: Choose and implement a creational pattern for a problem scenario
 Code Review and Discussion
 Peer review of implementations
 Structural Design Patterns
 Adapter: Real-world examples and code demo
 Composite: Tree structures and recursive operations
 Decorator: Adding behavior dynamically
 Facade: Simplifying interfaces
 Proxy: Remote object management
 Behavioral Design Patterns
 Strategy: Encapsulating algorithms
 Observer: Event-driven programming
 Command: Encapsulating requests
 Chain of Responsibility: Flexible request handling
 State: Managing object state transitions
 Practical Implementation
 Case study discussion: Identifying patterns in provided examples
Object-Oriented Analysis and Design (OOAD) (Day 4)
 OOAD Overview
 Process overview: Analysis, design, and implementation
 Domain modeling: Identifying entities and their relationships
 Class Responsibility Collaborator (CRC) cards: Mapping responsibilities
 Use Case-Driven Design
 Writing effective use cases
 Mapping use cases to classes and interactions
 Designing a System
 Using UML diagrams: Class, sequence, and activity diagrams
Clean Code Practices and Advanced Topics ( Day 5)
 Writing Clean, Maintainable Code
 Naming conventions and code readability
 Avoiding complexity: Simplifying methods and classes
 Writing effective comments
 Testing Practices
 Unit testing: Test-driven development basics
 Mocking and stubbing in tests
 Integration and functional testing
Advanced OOP Topics (Day 5)
 Dependency Injection: Benefits and implementation
 Aspect-Oriented Programming (AOP): Overview and use cases
 Refactoring Workshop
 Hands-on session: Refactoring a legacy codebase
 Applying clean code and design pattern principles
 Final Review and Open Q&A
Applying Advanced OOP Principles and Design Patterns in Spring Boot Microservices ( 
Day 6)
Transitioning from Monolithic to Microservices Architecture
 Overview of Monolithic vs. Microservices architecture
 Challenges in transitioning to Microservices
 Identifying boundaries for microservices using Domain-Driven Design (DDD)
 Bounded contexts and aggregate roots
 Mapping domains to microservices
Refactoring Monolithic APIs into Microservices
 Assessing existing APIs: Identifying responsibilities and dependencies
 Decomposing large APIs into cohesive microservices
 Service decomposition strategies: Functional, Domain-driven, and Subdomain 
approaches
 Structuring microservices with appropriate patterns
Design Patterns for Microservices Architecture
 Creational Patterns
 Singleton for managing configurations and beans
 Factory for object creation in service layers
 Structural Patterns
 Adapter for integrating with legacy systems or external APIs
 Facade for simplifying interactions between multiple microservices
 Behavioral Patterns
 Chain of Responsibility for request processing pipelines (e.g., API filters)
 Strategy for implementing multiple algorithms (e.g., different business rules)
 Observer for event-driven communication between services
Spring Boot and Clean Code in Microservices
 Using Spring Boot annotations effectively (e.g., @RestController, @Service, 
@Repository)
 Dependency Injection in Spring for managing loosely coupled components
 Configuration management using Spring Cloud Config
 Writing maintainable and reusable code in microservices with clean code practices
Review Day ( Day 7 & Day 8)
Final Challenge: Building a Spring Boot Microservices System
 Given a sample monolithic API, design and implement a microservices-based 
solution:
 Scenario: Banking domain with monolithic APIs for customer management, account 
services, and transactions
 Design: Identify bounded contexts, implement design patterns, and refactor APIs into 
separate services
 Result: A functional Spring Boot microservices architecture with applied principles
 Final Microservices Architecture Review
 Reviewing microservices for scalability, maintainability, and clean design
 Discussing applied design patterns and principles