Loading...
Java Backend Development with Spring boot and Microservices
Your Plan to Become a
Java
Backend Developer
Technologies covered
Course Structure
Spring Boot
- Backend Roadmap discussion
- Installation
- Getting started with programming
- Some basic calculations
- Use of datatypes
- Printing outputs
- What is Spring?
- Core Components of Spring
- Advantages of Using Spring
- Spring Philosophy and Loose Coupling
- Spring IoC Container
- Role of the Container
- Bean Factory vs. Application Context
- Bean Lifecycle
- Dependency Injection (DI)
- Bean Scopes
- Bean XML Config
- Constructor vs. Setter vs. Field Injection
- Benefits of DI in Promoting Loose Coupling
- Why Spring Boot?
- Spring Boot Starters
- Auto-Configuration
- Creating a Simple Spring Boot Application for REST APIs
- Understanding REST and RESTful Services
- Developing RESTful Services
- @RestController
- @RequestMapping and HTTP Methods
- Handling request and validations
- Status Codes and Responses
- Data Handling (JSON, XML)
- Exception Handling in REST APIs
- Integrating Data Sources
- Spring Data JPA
- Hibernate
- Repository Interfaces
- Transaction Management
- Build Tools
- How does maven work
- Practical guide to maven
- Concepts of AOP
- Architecture Components
- Aspect
- Join Point
- Advice
- Pointcut
- Using AOP for Transaction Management, Logging, and Security
- Basics of Spring Security
- Authentication vs. Authorization
- Securing REST APIs
- JSON Web Tokens (JWT)
- OAuth2
- Need of serialisation
- Derialisation and Deserialisation
- Serializable Interface
- transient Keyword
- ObjectOutputStream and ObjectInputStream
- Versioning and serialVersionUID
- Externalizable Interface
- Performance Considerations
- Security Concerns
- Use of Serialization in Frameworks
- Monitoring with Actuator
- Metrics and Health Indicators
- Custom Endpoints
- Profiles and Configuration Management
- Advanced Auto-Configuration
- Spring Testing Context
- Testing Spring Boot Applications
- Testing RESTful Web Services
- File Class
- Files Class
- Reading and Writing Files
- BufferedReader and BufferedWriter
- FileInputStream and FileOutputStream
- Directories and Paths
- Creating, Deleting, and Checking Files
- File Permissions
- Walking File Trees
- File Attributes
- Watching a Directory for Changes
- Overview of Garbage Collection
- Generational Garbage Collection
- Garbage Collection Algorithms: Mark-Sweep, Mark-Compact, Copying
- Garbage Collectors: Serial, Parallel, CMS, G1, ZGC, Shenandoah
- Garbage Collection Optimization
- Monitoring Garbage Collection with JVM Tools
- Finalization and its Pitfalls
- Weak References and Soft References
- Best Practices for Reducing Garbage Collection Overhead
- Java Compilation Process
- Java Compiler (javac)
- Bytecode in Java
- Just-In-Time (JIT) Compilation
- Stages of JIT Compilation: Interpretation, Compilation, Optimization
- HotSpot JVM Compiler
- Adaptive Optimization
- Benefits of JIT Compilation
- Comparison Between JIT and AOT (Ahead-Of-Time) Compilation
- Java Memory Model
- Heap Memory: Space where objects are allocated.
- Stack Memory: Stores method calls and local variables.
- Program Counter (PC) Register
- Method Area: Stores class structure and metadata.
- Runtime Constant Pool: Part of the method area which stores per-class runtime constants.
- Garbage Collection: Automatic memory management and cleanup.
- Memory Allocation: new Operator
- Memory Leaks and How to Avoid Them
- Set Up Development Environment: Install Java JDK, Maven/Gradle, and an IDE (e.g., IntelliJ IDEA or Eclipse).
- Create a New Spring Boot Project: Use Spring Initializr (start.spring.io) to generate a project with dependencies like Spring Web, Spring Data JPA.
- Project Structure Overview: Understand the standard Maven/Gradle project layout used by Spring Boot.
- Create a Domain Model: Define entity classes with JPA annotations.
- Create Repository Interfaces: Extend JpaRepository for database operations.
- Create Service Layer: Implement business logic in service classes.
- Create REST Controllers: Write controller classes to handle HTTP requests.
Relational Database (SQL)
- What is a Relational Database?
- What is non-relational Database
- Overview of SQL Database Systems (MySQL, PostgreSQL, Oracle, SQL Server)
- Database, Tables, and Rows
- Data Types and Schemas
- Primary Keys, Foreign Keys, and Indexes
- Basic Data Retrieval (SELECT, FROM, WHERE)
- Sorting and Filtering Data (ORDER BY, DISTINCT, LIMIT)
- Combining Conditions (AND, OR, NOT)
- Aggregate Functions (COUNT, SUM, AVG, MIN, MAX)
- Grouping Data (GROUP BY, HAVING)
- Subqueries and Joins
- Inner Joins
- Left/Right Outer Joins
- Cross Joins
- Self Joins
- Inserting Data (INSERT)
- Updating Data (UPDATE)
- Deleting Data (DELETE)
- Using Transactions (COMMIT, ROLLBACK)
- Understanding Normal Forms
- Designing Efficient Schema
- Avoiding Redundant and Duplicate Data
- Views and Stored Procedures
- Triggers and Cursors
- Dynamic SQL
- Indexing Strategies
- Query Optimization Techniques
- Performance Monitoring Tools
Microservices with Java Spring Boot
- What are Microservices?
- Definition and Core Principles
- Benefits and Challenges
- Monolithic vs. Microservices Architecture
- Comparison and Use Cases
- Microservices and Cloud-Native Architecture
- Java and Spring Boot Setup
- Development Tools and IDEs
- Introduction to Docker and Containers
- Creating a Basic Spring Boot Application
- Understanding Spring Boot Auto-Configuration
- Spring Boot Actuator for Health Checks
- Developing RESTful Services
- Controllers and Routing
- Data Exchange and Serialization
- Error Handling and Validation
- Securing REST APIs
- Synchronous vs. Asynchronous Communication
- RESTful API Communication
- Event-Driven Architecture
- Message Brokers (RabbitMQ, Kafka)
- Implementing Event Sourcing
- Database per Microservice
- Handling Data Consistency
- Distributed Transactions and Sagas
- Spring Cloud Config for Centralized Configuration
- Dynamic Configuration Updates
- Service Discovery Patterns
- Using Netflix Eureka
- Load Balancing with Spring Cloud LoadBalancer
- Routing and Aggregation
- Spring Cloud Gateway
- Security
- Circuit Breaker Pattern
- Spring Cloud Circuit Breaker
- Fallback Methods for Dependency Issues
Containerization with Docker
- Docker
- Containerization with Docker
- Kubernetes
- Microservices and Kubernetes
AWS for Deploying Microservices
- Overview of AWS
- Core services and their uses
- AWS Global Infrastructure (Regions, Availability Zones)
- Setting up an AWS account
- Understanding the AWS Management Console
- Amazon EC2
- Instances, AMIs, and Elastic Load Balancing
- AWS Lambda
- Serverless compute concepts
- AWS Elastic Beanstalk
- Deploying applications quickly
- Managing application environments
- Amazon ECS (Elastic Container Service)
- Basics of ECS
- Task Definitions, Services, and Clusters
- Amazon EKS (Elastic Kubernetes Service)
- Kubernetes on AWS
- EKS Cluster Management
- AWS Fargate
- Serverless compute for containers
- Running containers without managing servers
- Amazon S3
- Object storage for any scale
- Hosting static resources
- Amazon RDS
- Choosing the right database for microservices
- Amazon VPC
- Creating isolated networks
- Subnets, Route Tables, Internet Gateways
- AWS Route 53
- Content Delivery Network services
- AWS API Gateway
- Creating, deploying, and managing APIs
- Messaging and queuing services
- Decoupling microservices
- AWS CodeCommit, CodeBuild, and CodeDeploy
- Continuous integration and continuous delivery services
- AWS CodePipeline
- Orchestrating release pipelines
- Monitoring resources and applications