Pre-Requisitos

• Técnicas de Programação Java.
• Informações gerais da AWS
• Orientação sobre como lidar com DevOps
• Aprendizagem de frameworks Java como Spring Core 5.0

Materiais

Português + Lab Pratico on premise vs cloud

Conteúdo Programatico

Module 1: Background to Agile

• 1. The day in the life of a Project Manager
• 2. The day in the life of a Project Team Member
• 3. The need for change
• 4. Traditional Projects vs Agile Projects

Module 2 : Agile Basics

• 1. Agile Manifesto
• 2. Values
• 3. Principles
• 4. Pillars of Agile

Module 3 : Business Inputs

• 1. User Stories - definition
• 2. Business Value
• 3. Definition
• 4. Prioritizing
• 5. Minimum Viable Product (MVP) / MMF
• 6. Shaping up user stories (the 3Cs)
• 7. INVEST Criteria
• 8. User Story Maturity

Module 4 :Agile Variants

• 1. Scrum (very high-level)
• 2. Kanban
• 3. XP
• 4. DSDM
• 5. Scrum-ban
• 6. Lean
• 7. Feature Driven Development
• 8. PI chart on usage

Module 5 : APM Framework

• 1. Process Map
• 2. Process Steps need, deliverables & activities
• 3. Envision
• 4. Speculate
• 5. Explore
• 6. Adapt
• 7. Close

Module 6 : APM Framework

• 1. Process Map
• 2. Process Steps need, deliverables & activities
• 3. Envision
• 4. Speculate
• 5. Explore
• 6. Adapt
• 7. Close

Module 7 : Introducing Scrum

• 1. The Scrum Guide
• 2. Popularity of Scrum

Module 8 : Scrum Building Blocks

• 1. Event, Artifacts, and roles
• 2. Scrum at a glance
• 3. 3 Scrum roles
• 4. Other stakeholders
• 5. Project Manager
• 6. Agile Coach
• 7. 3 artifacts
• 8. 5 events

Module 9 : Agile Estimation

• 1. Estimation Basics
• 2. Agile Estimation Practices
• 3. Planning Poker
• 4. Types of Agile Estimates

Module 10 : Agile Planning

• 1. Breaking the myth
• 2. Product Planning
• 3. Release Planning
• 4. Iteration Planning

Module 11 : Monitoring & Tracking

• 1. Information Radiators
• 2. Burn-down chart
• 3. Burn-up chart
• 4. CFD

Module 12 : Agile Metrics & Agile Tools

• 1. Agile Metrics
• 2. Agile Tools

Module 13 : Scaling Agile

• 1. Why we need to scale Agile
• 2. Agile @ Scale flavors
• 3. SAFe®
• 4. DAD
• 5. LeSS

Module 14 : Careers in Agile

• 1. Agile certifications
• 2. Enterprise Agile

Module 1: Introduction to Java

• Features of Java
• Simple
• Secure
• Portable
• Robust
• Multithreading
• Platform-Independent
• Distributed.
• Dynamic
• New Features of Java 8
• Introducing Java Environment
• Java Development Kit
• Java Platforms
• Java Virtual Machine
• Java API
• Java Programs
• Installing Java
• What about CLASSPATH?
• Java’s Reserve Words
• Starting a Java program
• Line 1—public class App
• Line 2—public static void main(String[] args)
• Line 3—System.out.println(“Hello from Java!”);
• Compiling Code 15
• Compiling Code: Using Command-Line Options
• Cross-Compilation Options
• Compiling Code: Checking for Deprecated Methods
• Running Code
• Running Code: Using Command-Line Options
• Commenting Your Code
• Importing Java Packages and Classes
• Finding Java Class with CLASSPATH
• Summary

Module 2: Variables, Arrays and Strings

• Variables
• Data Typing
• Arrays
• Strings
• What Data Types are Available?
• Creating Integer Literals
• Creating Floating-Point Literals
• Creating Boolean Literals
• Creating Character Literals
• Creating String Literals
• Creating Binary Literals
• Using Underscores in Numeric Literals
• Declaring Integer Variables
• Declaring Floating-Point Variables
• Declaring Character Variables
• Declaring Boolean Variables
• Initializing Variables Dynamically
• Conversion between Data Types
• Automatic Conversions
• Casting to New Data Types
• Declaring One-Dimensional
• Creating One-Dimensional Arrays
• Initializing One-Dimensional Arrays
• Declaring Multi-Dimensional Arrays
• Creating Multi-Dimensional Arrays
• Initializing Multi-Dimensional Arrays
• Creating Irregular Multi-Dimensional Arrays
• Getting an the Length of an Array
• Understanding General Form of Static Import
• Importing Static Members
• The String Class
• Getting String Length
• Concatenating Strings
• Getting Characters and Substrings
• Searching For and Replacing Strings
• Changing Case in Strings
• Checking for Empty String
• Formatting Numbers in Strings
• The StringBuffer Class
• Creating StringBuffers
• Getting and Setting StringBuffer Lengths and Capacities
• Setting Characters in String Buffers
• Appending and Inserting Using StringBuffers
• Deleting Text in StringBuffers
• Replacing Text in String Buffer
• Using the Wrapper Class
• Autoboxing and Unboxing of Primitive Types
• Learning the Fundamentals of Varargs Methods
• Overloading Varargs Methods
• Learning the Ambiguity in Varargs Methods
• Using Non-Reifiable Formal Parameters

Module 3: Operators, Conditionals and Loops

• Operators
• Conditionals
• Loops
• Operator Precedence
• Incrementing and Decrementing (++ and --)
• Unary NOT (~ And !)
• Multiplication and Division (* and /)
• Modulus (%)
• Addition and Subtraction (+ and -)
• Shift Operators (>>, >>>, and <<)
• Relational Operators (>, >=, <, <=, ==, and !=)
• Bitwise and Bitwise Logical AND, XOR, and OR (&, ^, and /)
• Logical (&& and ||)
• The if-then-else Operator
• Assignment Operators (= and [operator]=)
• Using the Math
• Changes in the Math Class
• Class StrictMath
• Comparing Strings
• The if Statement
• The else Statement
• Nested if
• The if-else Ladders
• The switch Statement
• Using Strings in switch Statement
• The while Loop
• The do-while Loop
• The for Loop
• The for-each Loop
• Supporting for-each in Your Own Class
• A (Poor) Solution
• Significance of for-
• Nested Loops
• Using the break Statement
• Using the continue Statement
• Using the return Statement
• Summary

Module 4: Class, Object, Packages and Access Specifiers

• The Control Overview of a Class
• Working with Objects
• Working with Methods
• Defining Default Methods
• Working with Constructors
• Using Default Constructor
• Using Parameterized Constructors
• Exploring Packages
• Studying the Types of Packages
• Importing Packages
• Using Access Specifiers
• Working with Streams API
• Stream API Overview
• Collection and Stream
• Commonly Used Functional Interfaces in Stream
• Java.util.Optional
• Aggregate Operations
• Working with Time API

Module 5: Implementing Object-Oriented Programming in Java

• Understanding Encapsulation
• Understanding Abstraction
• Understanding Inheritance
• Understanding the final Keyword
• Preventing Inheritance
• Declaring Constant
• Preventing Method Overriding
• Implementing Interfaces
• Working with Lambda Expressions
• Method References
• Using Lambda Expressions
• Implementing Abstract Classes and Methods
• Difference between Abstract Classes and Interfaces
• Implementing Polymorphism
• Understanding the Static Polymorphism
• Understanding the Dynamic Polymorphism
• Summary

Module 6: Working with Streams, Files and I/O Handling

• Streams, Readers and Writers
• Essentials in NIO
• Buffers
• Channels
• Charsets and Selectors
• Enhancements in NIO with Java 8
• The Path Interface
• The Files Class
• The Paths Class
• The File Attribute Interfaces
• The FileSystem Class
• The FileSystems Class
• The FileStore Class
• Prospects of NIO
• Working with Streams
• The InputStream Class
• The OutputStream Class
• The ByteArrayInputStream Class
• The ByteArrayOutputStream Class
• The BufferedInputStream Class
• The BufferedOutputStream Class
• The FileInputStream Class
• The FileOutputStream Class
• Working with the Reader Class
• Working with the Writer Class
• Accepting Input from the Keyboard with the InputStreamReader Class
• Working with the OutputStreamWriter Class
• Working with Files
• Using the File Class
• Using the FileReader Class
• Using the FileWriter Class
• Working with the RandomAccessFile Class
• Working with Character Arrays
• Using the CharArrayReader Class
• Using the CharArrayWriter Class
• Working with Buffers
• Using the BufferedReader Class
• Using the BufferedWriter Class
• Working with the PushbackReader Class
• Working with the PrintWriter Class
• Working with the StreamTokenizer Class
• Implementing the Serializable Interface
• Working with the Console Class
• Working with the Clipboard
• Working with the Printer
• Printing with the Formatter Class
• Using the System.out.printf() Method
• Using the String.format() Method
• Formatting Dates Using the String.format() Method
• Using the Java.util.Formatter Class
• Scanning Input with the Scanner class
• Summary

Module 7: Implementing Exception Handling

• Overview of Exceptions
• Exception Handling Techniques
• Rethrowing Catched Exception with Improved Type Checking
• Built-in Exceptions
• User-Defined Exceptions
• Summary

Module 8: Working with Multiple Threads

• Using Threads in Java
• Life Cycle of a Thread
• Synchronization of Threads
• Multithreaded Custom Class Loader
• Getting the Main Thread
• Naming a Thread
• Pausing a Thread
• Creating a Thread with the Runnable Interface
• Creating a Thread with the Thread Class
• Creating Multiple Threads
• Joining Threads
• Checking if a Thread Is Alive
• Setting Thread Priority and Stopping Threads
• Synchronizing
• Communicating between Threads
• Suspending and Resuming Threads
• Creating Graphics Animation with Threads
• Eliminating Flicker in Graphics Animation Created Using Threads
• Suspending and Resuming Graphics Animation
• Using Double Buffering
• Simplifying Producer-Consumer with the Queue Interface
• Implementing Concurrent Programming
• Simplifying Servers Using the Concurrency Utilities
• Knowing Various Concurrency Utilities
• Learning about the Java.util.concurrent Package
• Learning about the Java.util.concurrent.locks Package
• Learning about the Java.util.concurrent.atomic Package
• Summary

Module 9: Working with Collections Framework

• The Collection Interfaces
• The Collection Classes
• The Map Interfaces
• The Map Classes
• Collections Framework Enhancements in Java SE 8
• Using the Collection Interface
• The Queue Interface
• The List Interface
• The Set Interface
• The SortedSet Interface
• Using the Collection Classes
• Using the Comparator Interface
• Using the Iterator Interface
• Using the ListIterator Interface
• Using the AbstractMap Class
• Using the HashMap Class
• Using the TreeMap Class
• Using the Arrays Class
• Learning the Fundamentals of Enumerations
• The Legacy Classes and Interfaces
• Using the Aggregate Operations
• Using the Java.util.function Package
• Summary

Module 10: Creating Packages, Interfaces, JAR Files and Annotations

• Packages and Interfaces
• JAR Files
• The Java API Package
• The Java.lang Package
• Basics of Annotation
• Other Built-In Annotations
• Creating a Package
• Creating Packages that have Subpackages
• Creating an Interface
• Implementing an Interface
• Extending an Interface
• Using Interfaces for Callbacks
• Performing Operations on a JAR File
• Marker Annotations
• Single Member Annotations
• Summary

Module 11: Working with Java Beans

• What is Java Bean?
• Advantages of Java Bean
• Introspection
• Persistence
• Customizers
• Understanding Java Beans
• Designing Programs Using Java Beans
• Creating Applets that Use Java Beans
• Creating a Java Bean
• Creating a Bean Manifest File
• Creating a Bean JAR File
• Creating a New Bean
• Adding Controls to Beans
• Giving a Bean Properties
• Design Patterns for Properties
• Using Simple Properties
• Designing Patterns for Events
• Learning Methods and Design Patterns
• Creating Bound Properties
• Giving a Bean Methods
• Giving a Bean an Icon
• Creating a BeanInfo Class
• Setting Bound and Constrained Properties
• Implementing Persistence
• Using the Java Beans API
• Learning the Basics of an Event
• Using the Java Beans Conventions
• Using the Remote Notification and Distributed Notification
• Using Beans with JSP
• Summary

Module 12: Networking and Security with Java

• Basics of Networking
• Sockets in Java
• Client-Server Networking
• Proxy Servers
• Internet Addressing
• Domain Name Service
• Inet4Addresses and Inet6Addresses
• The URL Class
• The URI Class
• URI Syntax and Components
• TCP/IP and Datagram
• Blackboard Assignment Retrieval Transaction
• Understanding Networking Interfaces and Classes in the Java.net Package
• Understanding the InetAddresses
• Caching InetAddress
• Creating and Using Sockets
• Creating TCP Clients and Servers
• Understanding the Whois Example
• Submitting an HTML Form from a Java Program
• Handling URL
• Using the URLConnection Objects
• Working with Datagrams
• Datagrams Server and Client
• Working with BART
• Learning about the Java.security Package
• Summary

Module 13: Implementing Event Handling and Wrappers in Servlets 3.1

• Introducing Events
• Introducing Event Handling
• Working with the Types of Servlet Events
• Developing the onlineshop Web Application
• Introducing Wrappers
• Working with Wrappers
• Summary

Module 14: Java Server Pages 2.3 and Expression Language 3.0

• Introducing JSP Technology
• Listing Advantages of JSP over Java Servlet
• Exploring the Architecture of a JSP Page
• Describing the Life Cycle of a JSP Page
• Working with JSP Basic Tags and Implicit Objects
• Working with Action Tags in JSP
• Exploring EL
• Using Custom Tag Library with EL Functions

Module 15: Implementing Filters

• Exploring the Need of Filters
• Exploring the Working of Filters
• Exploring Filter API
• Configuring a Filter
• Creating a Web Application Using Filters
• Using Initializing Parameter in Filters
• Manipulating Responses
• Discussing Issues in Using Threads with Filters
• Summary

Module 16: Java EE Design Patterns

• Describing the Java EE Application Architecture
• Introducing a Design Pattern
• Discussing the Role of Design Patterns
• Exploring Types of Patterns
• Summary

Module 17: Implementing SOA using Java Web Services

• Section A: Exploring SOA and Java Web Services
• Overview of SOA
• Describing the SOA Environment
• Overview of JWS
• Role of WSDL, SOAP and Java/XML Mapping in SOA
• Section B: Understanding Web Service Specifications to Implement SOA
• Exploring the JAX-WS 2.2 Specification
• Exploring the JAXB 2.2 Specification
• Exploring the WSEE 1.3 Specification
• Exploring the WS-Metadata 2.2 Specification
• Describing the SAAJ 1.3 Specification
• Working with SAAJ and DOM APIs
• Describing the JAXR Specification
• JAXR Architecture
• Exploring the StAX 1.0 Specification
• Exploring the WebSocket 1.0 Specification
• Describing the JAX-RS 2.0 Specification
• Exploring the JASON-P 1.0 Specification
• Section C: Using the Web Service Specifications
• Using the JAX-WS 2.2 Specification
• Using the JAXB 2.2 Specification
• Using the WSEE and WS-Metadata Specifications
• Implementing the SAAJ Specification
• Implementing the JAXR Specification
• Implementing the StAX Specification

Module 1: Introduction To Hibernate And Concepts

• Need for Hibernate
• Hibernate and ORM (Object-Relation Mapping)

Module 2: Hibernate Configuration

• Required JAR Files
• Hibernate configuration File
• Hibernate properties File
• Hibernate XML File
• SQL Dialects

Module 3: Hibernate Concepts

• Id and Primary Key
• Id Generation Methods
• Transaction
• POJOs (Plain Old Java Objects) and the Data Layer
• Hibernate Over Entity Beans
• Understanding Hibernate Architecture
• Configuration
• SessionFactory
• Session
• Query
• Criteria
• Hibernate Configuration
• Hibernate Mappings
• Persistent Classes
• Working with Hibernate to perform
• CRUD Operations
• Configuring Mappings Using Annotations.

Module 4: Hibernate Mappings

• Component Mapping
• Inheritance Mappings
• Table Per Class Hierarchy
• Table Per Sub Class
• Table Per Concrete Class
• Association Mappings
• One -to-One
• One -to-Many
• Many -to-One
• Many -to-Many

Module 5: Hibernate Query Language

• Select clause
• From clause
• Where clause
• Aggregate functions
• Expressions
• Sorting
• Grouping
• Sub queries

Module 6: Criteria Queries

• Creating Criteria
• Narrowing the Result
• Ordering the Result

Module 7: Native Sql

• Using SQL Query
• Named SQL Query
• Using Stored Procedure for Querying
• Creating Custom SQL for CRUD

Module 8: Hibernate Query Languages And Transactions And Caching

• Using HQL, criteria API, native sql
• Hibernate Transaction
• Hibernate and JDBC
• Hibernate second level caching

Module 9: Spring Hibernate Integrations

• Spring Hibernate Integration
• Data source creation
• Hibernate DAO implementation using

Module 10: Hibernate Uses In Project

• Design Web Application using hibernate
• Hibernate in web application(case studies)
• Project Guidance

Spring

Module 1: Course Introduction

• Introduction
• Content still to come

Module 2: Install and Setup

• Which Version Of Java?
• Installing JDK 11 on Windows
• Installing and Configuring IntelliJ IDEA on Windows
• Installing JDK 11 on a Mac
• Installing and Configuring IntelliJ IDEA on a Mac
• Installing JDK 11 on a Linux Machine
• Installing and Configuring IntelliJ IDEA on a Linux Machine

New Spring 5:

Module 1: Maven and your first project

• Your Programming Careers Questions Answered
• Access to Programming Career Q&A
• Spring 5 Feature Overview
• Maven and Other Tools
• Creating a Maven Project
• Importing Maven Projects
• Maven Lifecycle Plugin and Goals
• Fix our Maven Project

Module 2: Logging with SLF4J & Logback

• What is Logging?
• Using Logging with Logback
• Logback Configuration

Module 3: Multi module Spring Project

• Project Overview
• Create Multi Module Project
• Project Setup
• Using a Spring Container
• Implementing the Game
• Constructor Based Dependency Injection
• Setter Based Dependency Injection
• Setter or Constructor
• Using Bean Lifecycle Callbacks
• XML or Annotation Configuration
• Autowiring Beans
• Beans as Components
• Using Java Annotation Configuration
• Message Generator Challenge
• Implementing MessageGenerator Logic
• Console Module Setup Challenge
• Application Events
• Finish Game Logic
• Using Qualifiers
• Creating Custom Annotations
• Using Properties
• minNumber Challenge
• Code Cleanup and Constructor Injection
• Code Cleanup Challenge

Module 4: Lombok Introduction

• Lombok Introduction
• Setup Lombok
• Using Lombok
• Lombok Challenge

Module 5: Spring MVC

• Spring MVC Introduction
• Creating todo List Project
• Project Setup Challenge
• Setup Maven War Plugin
• Setup Maven Cargo Plugin and Tomcat
• Setup Dispatcher Servlet
• Simple Controller
• View Resolver and View
• Spring MVC Request Processing
• Model and Model Attributes
• Simple Service Challenge
• Request Parameters
• Project Requirements
• To Do Item Class
• To Do Data Class
• Creating the Todo Item Controller
• Creating View and Basic JSTL tags
• Todo Item Service Challenge
• Implementing the Add Item Feature
• Implementing Post Redirect Get Pattern
• Home View and Navigation
• Delete Item Challenge
• Implement Edit Item Feature
• View Item Challenge

Module 6: Spring Boot 2 Introduction

• Introduction to Spring Boot 2
• Using Spring Initializr
• Understanding Spring Boot Project Structure
• Simple Spring Boot Application

Module 7: Spring Boot 2 And Thymeleaf 3

• Add Spring Boot to an Existing Project
• Spring Boot Web Module
• Thymeleaf Introduction
• Setup Thymeleaf and Initial Template
• Spring Boot Developer Tools
• Game Service Challenge
• Play Thymeleaf Template
• Thymeleaf Preprocessing
• Thymeleaf Template Challenge
• Thymeleaf Fragments
• Thymeleaf Fragment Challenge
• Thymeleaf Decoupled Template Logic
• Thymeleaf Decoupled Template Logic Challenge
• Bug Fixes
• Spring Internationalization
• Thmyeleaf Internationalization Challenge
• Message Generator Internationalization Main Message
• Message Generator Internationalization Result Message
• Request Interception
• Locale Change Interceptor
• Thymeleaf Recap

Module 8: Gradle Introduction

• What is Gradle?
• Creating a Gradle Spring Boot Project
• Gradle Build Lifecycle Projects and Tasks
• Understanding the Gradle Scripts
• Running Gradle Tasks
• Simple Spring Gradle Application

Module 9: Gradle Multi Module Project Setup

• Creating a Spring Boot Project Challenge
• Configure Gradle Multi-module Project
• Configure Sub Modules
• Testing our Project
• More Content

OLD Spring

Module 1: Installation & Setup - Part 1

• Install JDK for Windows
• Install Eclipse for Windows
• Install Tomcat for Windows
• Configure Tomcat Within Eclipse for Windows
• Install JDK for Mac
• Install Eclipse for Mac
• Install Tomcat for Mac
• Configure Tomcat Within Eclipse for Mac
• Install JDK for Linux
• Install Eclipse for Linux
• Install and Configure Tomcat for Linux

Module 2: Introduction to Java EE

• Introduction to JEE
• Exploring Java EE basics: Drilling into the Concepts
• Exploring Java EE basics: Building the Servlet
• Exploring Java EE basics: Creating a JSP and running the App
• Exploring Java EE basics: Adding a Service layer to the mix
• Exploring Java EE basics: Adding JSTL Library Support
• Exploring Java EE basics: JSTL in JSP
• Exploring Java EE basics: Drilling into the Concepts

Module 3: Installation and Setup - Part 2

• Overview of Spring Tooling
• Install Spring IDE
• Installing Maven
• Creating a Maven Project
• Understanding the Project Object Model

Module 4: Introducing Spring Framework

• Why Spring
• Overview of the Spring Framework
• Spring Framework vs JEE
• Introducing the Spring IoC containSpring IoC container: Accessing metadata from the file Spring IoC container: Accessing metadata from theSpring IoC Container Challenge
• Setting Constructor Arguments using the Spring bean config file
• Setting Properties using the Spring bean config file
• Setter based Dependency Injection in Spring
• Setter based Dependency Injection in Spring continued
• Spring Setter based Dependency Injection in Spring : Running the App
• Constructor based Dependency Injection in Spring
• Spring Constructor based Dependency Injection : Running the App

Module 5: Introducing Spring MVC

• Creating Spring MVC Project Infrastructure
• Adding dependencies in an alternative way in a Spring MVC Project
• Adding Spring MVC Dispatcher Servlet
• Building the Spring Controller - "C" part of MVC
• Context and MVC Configuration
• Autowiring collaborating objects in Spring
• Bringing View Resolver in the mix and running the App

Module 6: Bean Configuration

• Bean scopes for a Spring Bean
• Spring bean scopes: Singleton and Prototype
• Spring bean scopes, Request and Session: creating the project and Java classes
• Spring bean scopes, Request and Session: creating the config file and Controller
• Spring bean scopes, Request and Session: Running the App
• Customize Spring Bean with Callbacks
• Standard Naming for Spring Bean Callbacks
• Spring Bean instantiation using Static Factory and Instance Factory methods
• Spring Bean Definition with C Namespace
• Spring Bean Definition with P Namespace

Module 7: Configuring Spring with Annotations

• Pros and Cons of Spring Configuration : Annotations vs XML
• Autowiring Spring Beans: creating project infrastructure
• Autowiring Spring Beans: using setters, constructors and fields
• Spring Beans as Components: Cutting down on xml config
• Handling Properties in Spring: using XML config
• Handling Properties in Spring: mixing XML with Annotations
• Handling Properties in Spring using pure Annotations: creating infrastructure
• Handling Properties in Spring using pure Annotations: building and running

Module 8: Introducing MySQL

• Install MySQL for Windows
• Install MySQL on Mac
• Install MySQL on Linux
• MySQL Workbench Basics : Environment and table creation
• MySQL Workbench Basics : Insert and Export

Module 9: Working with Spring JDBC

• Introduction to Spring JDBC
• CRUD with Spring JDBC Template: Project Setup
• CRUD with Spring JDBC Template: Creating DAO Layer
• CRUD with Spring JDBC Template: XML config & Property file
• CRUD with Spring JDBC Template: More with DAOs
• CRUD with Spring JDBC Template: DAO and Test Harness
• CRUD with Spring JDBC Template: Building App and executing Test Harness
• CRUD with Spring JDBC Template: Expanding DAO Layer further
• Spring JDBC Exceptions : an Overview
• Spring Named Parameters Template: Understanding the API
• Spring Named Parameters Template: Building the DAO
• Spring Named Parameters Template : Components and Testing

Module 10: Spring MVC in depth - Part 1

• Spring Java Config: Creating the project infrastructure
• Spring Java Config: Creating the Java and Web Configuration
• Spring Java Config: Running the App
• Fix minor error in WebMvcConfig
• JNDI Datasource: Building the Spring Service and Controller
• JNDI Datasource: Conceptual Overview and Configuration
• JNDI Datasource: Building views and Running the App
• Spring MVC Architecture Going Deeper
• Spring Handler Mapping Customization: Creating the infrastructure
• Spring Handler Mapping Customization: Seeing the effect of customization
• Spring Interceptors: an Introduction
• Spring Interceptors: Integrating and building views with CSS inline styling
• Spring Interceptors: Continuing building the views with CSS Internal styling
• Spring Interceptors: Continue building views with mixed styling
• Spring Interceptors: Running the app with a closing summary
• Introducing Logging
• Logging: Working with SLF4J, a powerful logging API
• Logging: LOG4J implementation and introducing Logger, Appender and Layout
• Logging: Continuing with log4j and getting to know Conversion Patterns
• Logging: Configuring log4j.properties and wrapping up
• Spring Interceptors: Invoking all the Interceptor methods
• Spring Interceptors: Running the app and wrapping up!

Module 11: Spring MVC in depth - Part 2

• Section Overview
• RequestMapping and RequestParams In-depth : Introduction & test harness
• RequestMapping and RequestParams In-depth : Class level mapping
• RequestMapping and RequestParams In-depth : Wrapping up first test
• RequestMapping and RequestParams In-depth : method attribute & fallback
• RequestMapping and RequestParams In-depth : defaultAttribute and default naming
• RequestMapping and RequestParams In-depth : resolving ambiguous request mapping
• RequestMapping and RequestParams In-depth : multiple request mapping
• Model Attributes on Methods in-depth: Adding multiple attributes
• Model Attributes on Methods in-depth: working with 'name' attribute
• Model Attributes on Methods in-depth: working with 'value' attribute
• Model Attributes on Methods in-depth: working with ModelAndView API
• Model Attributes on Methods in-depth: Introducing Spring Form Tag and Elements
• Model Attributes on Methods in-depth: Exploring ModelAndView API
• Model Attributes on Methods in-depth: Default data binding
• Model Attributes on Methods in-depth: Implicit resolution of logical view name
• Session Attributes: Creating the project infrastructure
• Session Attributes: Bringing in the Controller
• Session Attributes: Adding the JSPs
• Session Attributes: Cranking the Java configuration
• Session Attributes: Testing our application
• Session Attribute & Request Attribute: an Introduction
• Session Attribute & Request Attribute: Applying to Interceptor and Controller
• Session Attributes, Session Attribute & Request Attribute: Testing all

Module 12:Spring MVC in depth - Part 3 (Forms and Validation)

• Spring Form Tags: An Overview
• Spring Form Tags: Creating project infrastructure - part 1
• Spring Form Tags: Creating project infrastructure - part 2
• Spring Form Tags: SELECT tags - part 1
• Spring Form Tags: SELECT tags - part 2
• Spring Form Tags: SELECT tags - part 3
• Spring Form Tags: CHECKBOX tags - part 1
• Spring Form Tags: CHECKBOX tags - part 2
• Spring Form Tags: CHECKBOX tags - part 3
• Spring Form Tags: CHECKBOXES tags
• Spring Form Tags: RADIOBUTTON & RADIOBUTTONS tags
• Spring Form Validation: an Introduction
• Spring Form Validation: Creating the project Infrastructure
• Spring Form Validation: Creating the JSPs
• Spring Form Validation: Running the first validation test
• Spring Form Validation: Working with @Size and @Notblank validations
• Spring Form Validation: Introducing Custom Validation Constraints
• Spring Form Validation: Creating our first Custom Validation Constraint
• Spring Form Validation: Regular Expression Validation
• Spring Form Validation: Using Apache Commons API Validator
• Spring Form Validation: Class Level Validation
• Spring Form Validation: Final Changes and Test

Module 13: IntelliJ Spring Section

• IntelliJ Spring Config and Test Import
• Import Non Web Based Project
• Build Spring MVC Demo
• Controller Service and JSP
• Welcome Service and Add Beans

OLD - NEW Spring 5

• Install and setup
• Which version of Java should you use?
• How To Install The Java Development Kit (JDK) For Windows
• Download and Install IntelliJ (FREE and PAID version) for Windows
• How To Install The Java Development Kit (JDK) For Mac OS X
• Download and Install IntelliJ (FREE and PAID version) on a Mac
• How To Install The Java Development Kit (JDK) For Ubuntu Linux
• Install and Configure IntelliJ (FREE and PAID version) for Ubuntu Linux

DevOps

Module 1: Cloud computing

• What is Cloud Computing
• How Cloud Computing are helpful
• Cloud's role in DevOps orchestration
• What is AWS
• Use cases in AWS
• Companies using AWS and Market tends
• Different Services offered in AWS
• Use case: - Highly available fault tolerant systems
• Understanding availability zone
• region
• Creating your own account in AWS
• Creating a VPC
• subnet
• network gets way
• Running your own EC2 instance
• Connecting in EC2 and installing https in EC2
• S3
• Over viewS3
• SNS. Cloud watch
• Understanding the Serverless (Lambda)

Module 2: DevOps History and evolution of DevOps

• What is the market trend of DevOps
• Which back ground people can switch to DevOps
• Some typical tool stack for DevOps Jobs
• How to get maximum from the course
• Client-Server and Distributed Version control system
• Git
• Advantages of Git over SVN
• Git User trends
• Different Git tools (Git Desktop. Kraken)
• Git Installation and Configuration
• Setting up Git Bash and Git UI
• Creating first repository: Local
• Git commands: add
• commit
• push
• status
• history
• Branch why what? Understanding Master
• Creating a Branch
• Merging a Branch
• Resolving Merge conflicts
• checking the difference
• Understanding the tags: Modifying
• undoing
• deleting and discarding
• What
• Use Case of Unit Testing
• Different kind of Unit Testing
• What is JUnit
• Writing a Simple JUnit Test
• Test NG introduction
• Write a Unit Testing Case in your Favorite language.
• Linux Administration
• A Linux Introduction
• Open Source Philosophy
• Distributions
• Embedded Systems
• Command Line Basics
• Basic Shell
• Command Line Syntax – ls
• Command Line Syntax – $PATH, Case Sensitivity
• Command Line Syntax – Basic Commands
• Command Line Syntax – uname
• Command Line Syntax – Command History, Command Completion
• Command Line Syntax – cd and pwd
• Shell Configuration Files
• Variables – Environment / System Variables
• Variables – User Defined
• Globbing
• Quoting
• Formatting Commands
• Working with Options
• Using the Command Line to Get Help
• Man
• Info
• locate, find, whereis, and using /usr/share/doc/
• Exercise: Man Page Walkthrough
• Exercise: Basic Command Line
• Using Directories and Listing Files
• The Linux File System
• Files, Directories
• Hidden Files and Directories
• Home
• Absolute and Relative Paths
• Exercise: Maneuvering the Linux File System
• Creating, Moving and Deleting Files
• Files and Directories
• Case Sensitivity
• Simple Globbing and Quoting
• The Power of the Command Line
• Archiving Files on the Command Line
• Files, Directories
• Archives, Compression
• Searching and Extracting Data from Files
• Commands (Revisited)
• Command Line Pipes
• I/O Redirection
• Regular Expressions
• Exercise: Practicing with Pipes and Grep
• Turning Commands into a Script
• Basic Text Editing
• Basic Shell Scripting
• Basic Shell Scripting, Continued
• Exercise: Using the vi Text Editor
• Available
• The Linux Operating System
• Choosing an Operating System
• Windows, Mac, and Linux Differences
• Distribution Life Cycle Management
• Understanding Computer Hardware
• Hardware
• Where Data is Stored
• Kernel
• Processes
• syslog, klog, dmesg
• /lib, /usr/lib, /etc, /var/log
• Your Computer on the Network
• Internet, Network, Routers
• Domain Name Service and the Default Gateway (Network Router)
• Network Configuration
• Security and File Permissions
• Basic Security and Identifying User Types
• Root and Standard Users
• System Users
• Creating Users and Groups
• User IDs
• User Commands
• Group Commands
• Exercise: Managing User Accounts
• Exercise: Creating User Groups
• Managing File Permissions and Ownership
• File/Directory Permissions and Owners
• Special Directories and Files
• Symbolic Links
• System files, Special Files, and Sticky Bits
• Use Case in Maven
• Ant vs Maven
• Maven installation and Configuration What is Maven Central
• Dependency Management why and How
• Introduction to POM
• Build lifecycle
• Maven repositories Maven plugins
• Using a POM file to run unit testing (Jenkins)
• Multi-module POM
• dependency hierarchy
• Artifactory management
• Maven Release and Snapshot
• Assignment- Create a Maven Hello world Java Project
• Run the Unit testing and and create the artifact for that
• Use Case (How Artifactories are managed)
• Artifact Lifecycle
• Basic use of Sonatype Nexus
• Artifactory Live demo
• Use Case WebServer Deployment in DevOps
• Architecture
• Different types of Webserver
• Proxy servers
• Mail Server
• Installation of Tomcat
• Manual Deployment
• Deploying a Web application using Maven
• Idea about Automated Deployment using Continuous Integration
• Create a Tomcat Server and Deploy the application manually
• Create a Tomcat Server and Deploy the Application Using Maven
• Benefits of Code Profiling tool
• Use case of Code Profiling tool
• Different kind of Code quality tools
• Over view of Sonar
• Installation of SonarQube
• Installation fo Code Analyser
• Sonar profiles
• Running Sonar for a project
• Configuring SonarQube for one Sample java project.

Module 3: Jenkins

• Why Jenkins?
• What is Continuous Integration and Continuous Deployment (Use Case1)
• Jenkins installation and Configuration
• Running Jenkins as windows service
• Deploying Jenkins in Tomcat Server
• Jenkins Global Configuration
• Building your first Hello world job
• Jenkins User Management
• Jenkins Plugin management
• Jenkins SCM configuration (Git SVN)
• Understanding the Jenkins workspace
• Build
• pre build and post build job
• Jenkins Unit testing
• Automation testing
• Mail notification
• Jenkins Reporting
• Matrix and trend
• Jenkins remote executor
• Master Slave configuration in Jenkins
• Jenkins Most used plugin
• Advanced Reference
• Jenkins pipeline plugin
• Groovy scripting
• Scriptler
• Jenkins Parameterized build
• Environment inject plugin
• Use of Jenkins environment variables
• Deploying a specific revision
• Customizing the Jenkins UI
• Project based Matrix plugin
• Parallel Execution
• Configuring Jenkins Hub and Node in the cloud (AWS)
• Configuring a Selenium Desktop node with a Linux Server (AWS)
• Case Study
• Real time implementation of Automated role back
• Multi branch Deployment.
• What is Virtual Machine
• Why we need it
• What is Container
• Difference between Containers and Virtual Machine

Module 4: Docker

• Docker Installation and Configuration
• Major Docker Components
• Container Management Running Containers
• Docker file
• Working with Registries
• Docker Port Forwarding
• What is Configuration Management
• Configuration Management Challenges
• Configuration Management in DevOps Ecosystem
• Some tools
• Trends
• What is Container and Containerization
• Different types of Containers
• DOCKER: What why how ?
• Use Case 1 (Why Docker)
• Docker installation
• Docker VS Vagrant
• Docker Run commands
• Advanced Docker
• run commands
• Docker volume persistence
• Overview of Docker Compose
• Docker Hub
• Creating your own image
• Advanced reference
• Create a Docker container to run Jenkins
• Create a Docker container to run a CI/CD pipeline
• Use case 1 (Why puppet)
• Puppet installation and configuration
• Resource implementation
• Managing files and executing programs
• Testing your code Using Puppet Languages
• Variables Numbers and Strings
• Facts
• control flow
• Regex
• Loops
• Resource Processing
• Advanced Course
• Puppet Modules
• Define QA environment
• Changing Base Module path
• Separation of Data from Code
• Introduction to Hiera
• Hiera Backend creation in Puppet
• Variables and Function lookups
• Using Puppet modules
• Puppet Forge-Server- GitHub repo.

Module 5: Ansible

• What is Ansible
• Advantages of Ansible
• Environment Provisioning
• Configuration Deployment
• Installation of Ansible (AWS)
• Modules
• Playbooks and Writing a Playbook
• What is Monitoring
• Why we need monitoring
• Different tools of monitoring
• What is Nagios
• Nagios Architecture
• Different components of Nagios
• A typical Nagios Dashboard
• Installation and Configuration

HTML & CSS

Module 1: Overview of HTML5Learning Objective:

• New in HTML5
• New DOCTYPE and Character Set
• New and Depreciated Elements
• Semantic Markup
• Simplifying Selection using the Selectors API
• JavaScript Logging and Debugging
• Window.JSON
• DOM Level

Module 2: Using HTML5

• Currently available features
• Browser Support
• Detective native availability of features
• Working with emulation
• Create a web page that verifies the availability of new HTML5 features.

Module 3: Understanding HTML5 Markup

• HTML5 Page Structure
• HTML5 DOCTYPE
• HTML5 markup structural elements
• Semantic elements
• Create a web page that make usage of new structural and semantic elements like main, section, aside, article, header, footer and other semantic elements.

Module 4: HTML5 Forms

• HTML Forms VsXForms
• Functional Forms
• New Form Attributes and Functions
• Placeholder Attribute
• Autocomplete Attribute
• Autofocus Attribute
• List Attribute and datalist Element
• Min and Max attributes
• ValueAsNumber attribute
• Required Attribute
• Checking Forms with Validation
• Validation Feedback
• Develop a product entry form which uses HTML5 form elements and validation attributes.

Module 5: HTML 5 Audio & Video

• The Audio and Video Elements
• Understanding Audio and Video
• Working with Audio and Video Containers
• Understanding Audio and Video Codecs
• Create a web page that displays multiple video and audio using HTML5 video and audio elements.

Module 6: HTML5 Canvas & SVG

• Overview of Canvas Vs. SVG
• Canvas coordinates
• Context
• Pixel Data
• Working with Canvas APIs
• Drawing Operations
• Canvas Transforms
• Understanding and Working with SVG
• Create a web page that makes use of basic Canvas API and also displays svg graphics and drawings.

Module 7: HTML 5 Storage

• Overview of HTML5 Web Storage
• Browser Support for HTML4 Web Storage
• Using the HTML5 Web Storage
• Checking for Browser Support
• Setting and Retrieving Values
• Plugging Data Leaks
• Create a web page that sites and gets data Run HTML5 web storage.

Module 8: CSS3 Overview

• Introducing CSS3
• CSS3 Colors, Gradients and Multiple Backgrounds
• Rounded Corners and Border-Radius
• CSS3 Transforms
• Transitions
• Animations & 2D Transformations
• Web Fonts with @font-face
• CSS3 Multicolumn Layouts
• Develop a web page that enhances the richness of the page using CSS3,colours,gradients,border radius,animation,transformations and transitions.

Module 9: CSS3 Flexbox

• Introduction
• Box Model basics
• Container
• Direction
• Wrapping
• Justifying & Alignments
• Display order
• Flexibility
• Alignment
• Create a page that displays product gallery layout coded with flexbox.

Module 10: CSS Grid

• Introduction
• Grid Layout
• Grid Elements
• Placing Grid Lines
• Attaching Elements to the Grid
• Order and Align Items in Grid Layout
• Grid Flow
• Opening Grid Spaces
• Create a page that displays product gallery layout coded with CSS grid.

Amazon Web Services (AWS)

Module 1: Linux Fundamentals

• Overview of all basic commands
• Vim editor modes
• Filesystem hierarchy – Basic topics
• File and directories creation
• Grep
• Filter commands (head,tail,more,less)
• Creating users and groups
• Important files related
• Modifying,deleting users and group
• Linux permissions
• Basic permissions overview
• Software management
• Yellowdog update modifier(yum)
• Yum commands
• Different runlevels
• Services and daemons

Module 2: Why Cloud ?

• Why Cloud and What is Cloud Computing?
• Identify the features and benefits of cloud computing
• Different types of Cloud Computing deployment model
• Public Cloud, Private Cloud, Hybrid Cloud
• Virtualization – An essential in cloud
• Virtualization in Cloud model
• Different types of virtualization
• Hypervisor – Benefits
• Different types of services and its difference in Cloud computing
• IaaS, PaaS, SaaS
• Importance of scaling in cloud computing
• Different types of scaling and its applications
• Issues we overcome using cloud and applications
• Cost model that we use in cloud computing

Module 3: AWS – An overview

• Describe the features of AWS
• The features of AWS marketplace
• Describe the features of Amazon Compute Services
• Describe the features of Amazon Storage Services
• Describe the features of Amazon Network Services
• Describe the features of Amazon Database services
• Describe about various services in AWS
• Global Infrastruture – Regions and Availability Zones
• Create a free tier account in AWS and onboarding
• Introduction AWS management console

Module 4: Understand Identity Access Management of AWS

• Protect your AWS by different authentication system
• Password policies set for users
• AWS User Account and Groups in detail
• Creating custom policies in AWS
• Introduction about Roles and its use
• Creating Roles and associating policies
• Creating programmatic access and management console access for users
• Associating policies to the user and groups

Module 5: EC2 Instance

• Describe AMI and AWS Marketplace templates
• Launch a basic EC2 instance
• Different types of Instances Reserved, On-demand, Spot, Dedicated
• Security groups and tags for EC2 instance
• Public key – Private key introduction and protecting EC2 with keys
• Attaching and detaching EBS volumes
• Launch an ec2 instance from an AMI
• Create custom AMI and working with different region
• Make use of amazon EBS volume and create snapshots
• Manage the configuration of your application
• Deploying a new instance from the created AMI

Module 6: Auto-scaling

• Get Started with Auto Scaling Using the Console
• Creating Launch configurations and make use of it for autoscaling groups
• Maintain a Fixed Number of Running EC2 Instances
• Dynamic Scaling
• The lifecycle of autoscaling
• Policies of autoscaling

Module 7: Load Balancing

• Introduction to Loadbalancer (ELB)
• Different types of Loadbalancer in AWS
• Application Load balancer
• Network Load balancer
• Classic Load balancer
• Migrating classic load balancer to new load balancer
• Components and types of load balancing

Module 8: EBS (Elastic Block Storage)

• Create EBS volumes
• Delete EBS Volumes
• Attach and detach EBS volumes with EC2 instance
• Creating and deleting snapshots

Module 9: Object Storage in Cloud

• Understanding S3 durability and redundancy
• Introduction about S3 Buckets
• How S3 Uploading works and how to Download
• How to S3 Permissions
• How to implement S3 Object Versioning S3 Lifecycle Policies
• Storage Gateway
• Import Export
• S3 Transfer Acceleration
• Glacier storage

Module 10: Cloud Front

• Describing cloud front
• Creating a cloud front distribution
• Hosting a website of cloud front distribution
• Implementing global restrictions
• Configuring origins and behaviors

Module 11: Route 53

• Describe Hosted zones and Domain name understanding
• How to create hosted zones
• Hosting a website with custom domain name
• Understanding routing policies

Module 12: AWS Security Management

• Describing Security Practices for Cloud Deployment
• AWS Shared Responsibilities and Securities
• Importance of Cloud Trail
• Describing Trust advisor

Module 13: Amazon Virtual Private Cloud (VPC)

• Introduction to Amazon Virtual Private Cloud (VPC).
• VPC Advantages and understanding IP addressing CIDR
• Default and Non-default VPC
• Different Components in VPC
• Describe, create, and manage Amazon Virtual Private Cloud
• Amazon VPC, Private Subnet, and Public Subnet
• AWS Networking, Security Groups, and Network ACLs
• Configuration and management of VPN connectivity
• Subnet and Subnet Mask

Module 14: Relational Database Service (RDS)

• Introduction to RDS
• Different database services of AWS: Amazon RDS, Dynamo DB, Redshift etc.
• Create MYSQL RDS Instance, Oracle RDS Instance, MS SQL RDS Instance
• Configuring the database
• Configuring backups
• Configuring the maintenance windows
• Connecting to the database

Module 15: NDynamo DB

• Creating a dynamo dB
• Adding data manually
• Learn about strong and eventual consistency
• Calculating Read write consistency
• Configuring alarms

Module 16: Monitoring Services

• Knowledge on Cloud watch – A monitoring service
• Create and Configuring Monitoring services
• How to perform Setting thresholds and Configuring actions
• Creating a cloud watch alarm
• Getting statistics for ec2 instances
• Monitoring other AWS services
• Configuring Notifications
• Integrating cloud watch with Autoscaling

MOdule 17: Application Services – An Overview

• What is SNS
• Creating a topic
• Create subscription
• Subscribed to the subscription
• SQS & SES
• Lambda and Elastic Beanstalk

Module 18: AWS Troubleshooting

• Troubleshooting EC2 instance
• Troubleshooting using Cloud watch
• Troubleshooting using ELB
• Troubleshooting by using Cloud front

Module 19: AWS Architecture and Design

• Backup and Disaster Recovery
• How to manage Disaster Recovery and Backups
• Best Practice for DR and Backups
• AWS High Availability Design

Module 20: DevOps Fundamentals

• An understanding of DevOps and the modern DevOps toolsets
• The ability to automate all aspects of a modern code delivery and deployment pipeline using:
• Build tools – Apache ant, Maven
• Source code management tools – CVS, Git
• Test automation tools – JUnit
• Continuous Integration Tools – Jenkins, Team city
• Configuration management tools – Chef, Puppet, Ansible

JavaScript Training

Module 1: Introduction

• What is JavaScript?
• What is AJAX?

Module 2: Developer Essentials

• The development workflow
• Selecting the right tools for the job
• Just enough HTML and CSS
• Understanding objects
• Understanding variables
• Making comparisons
• Understanding events

Module 3: Starting to Code

• Writing your first script
• Internal vs. external scripts
• Using comments in scripts
• Using the noscript tag in HTML

Module 4: Interacting with Users

• Creating alert dialogs
• Understanding conditional statements
• Getting confirmations from users
• Creating prompts for users
• Understanding functions
• Making links smarter
• Using switch/case statements
• Handling errors

Module 5: JavaScript Language Essentials

• Getting started
• Creating loops
• Passing values to functions
• Detecting objects
• Reading arrays
• Returning values from functions
• Writing arrays
• Building do and while loops
• Re-using functions

Module 6: Creating Rollovers and More

• Creating a basic image rollover
• How to write a better rollover
• Creating a three-state rollover
• Making rollovers accessible and 508 compliant
• Making disjointed rollovers
• Creating slideshows
• Displaying random images

Module 7: Building Smarter Forms

• Getting started
• Creating jump menus
• Creating dynamic menus
• Requiring fields
• Cross-checking fields
• Displaying more informative errors
• Verifying radio button selections
• Setting one field with another field
• Verifying email addresses

Module 8: Handling Events

• Responding to window events
• Responding to mouse movements
• Responding to mouse clicks
• Responding to onBlur form events
• Responding to onFocus form events
• Responding to keyboard events

Module 9: Working with Cookies

• Demystifying cookies
• Writing a cookie
• Reading a cookie
• Displaying a cookie
• Counting with cookies
• Deleting cookies
• Handling multiple cookies
• Cookies in action

Module 10: The DOM, Nodes, and Objects

• Understanding the DOM
• Adding nodes to the DOM
• Deleting nodes from the DOM
• Deleting specific nodes
• Inserting nodes into the DOM
• Replacing nodes in