Java Master Program

Reading Time: 20 minutes

Core Java

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 Core 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
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
J2EE

Module 1: JDBC

  • Introduction to JDBC
  • Databases and Drivers
  • Types of Driver
  • Loading a driver class file
  • Establishing the Connection to different
  • Database with different Driver
  • Executing SQL queries by ResultSet,Statements , PreparedStatment interface.
  • Using CallableStatement
  • Transaction Management & BatchUpdate
  • Programs/Interview related Question and Answer

Module 2: JSP

  • Basics Of Jsp
  • Life cycle of JSP
  • JSP API
  • JSP in Eclipse and other IDE’s
  • Programs/Interview related Question and Answer.
  • Scripting Elements
  • scriptlet tag
  • expression tag
  • declaration tag
  • Implicit Objects
  • out
  • request
  • response
  • config
  • application
  • session
  • pageContext
  • page
  • exception
  • Directive Elements
  • page directive
  • include directive
  • taglib directive
  • Exception Handling
  • Action Elements
  • jsp:forward
  • jsp:include
  • Bean class
  • jsp:useBean
  • jsp:setProperty & jsp:getProperty
  • Displaying applet in JSP
  • Expression Language
  • What is expression and how to use it
  • Define expression and use over the service flow
  • The way to be achieve same in JSP
  • Mvc In Jsp
  • MVC pattern
  • Working flow implementation of MVC
  • CRUD operation using MVC
  • Design a real time web application using MVC
  • JSTL
  • Discussion on the tag library
  • How to implement and use
  • Custom Tags
  • Custom Tag : What and Why?
  • Custom Tag API?
  • Custom Tag Example
  • Attributes
  • Iteration
  • Custom URI

Module 3: Servlet

  • Basics of Servlet
  • Servlet: What and Why?
  • Basics of Web
  • Servlet API
  • Servlet Interface
  • GenericServlet
  • HttpServlet
  • Servlet Life Cycle
  • Working with Apache Tomcat Server
  • Steps to create a servlet in Tomcat
  • How servlet works?
  • servlet in Myeclipse
  • servlet in Eclipse
  • servlet in Netbeans
  • Servlet request
  • Servlet Request methods
  • Registration example with DB
  • Servlet Collaboration
  • Request Dispatcher
  • send Redirect
  • Servlet Configure
  • Servlet Configure methods
  • Servlet Configure example
  • Servlet Context
  • Servlet Context methods
  • Servlet Context example
  • Session Tracking
  • Cookies
  • Hidden Form Field
  • URL Rewriting
  • HttpSession

Module 4: Concurrent and implementation of collection

  • Implemenation of ArrayList
  • Implemenation of LinkedList
  • Implemenation of HashMap
  • Implementation of Queue/PriorityQueue/Deque

Module 5: Advanced Multi-Threading

  • Implemenation of Executor pool service and working mechanism with real time
  • Big file(Single , multiple ) processing using multiple thread
  • Implemenation to achieve thread class and runnable interface

Module 6: Javamail Api

  • Sending Email
  • Sending email through Gmail server
  • Receiving Email
  • Sending HTML content

Module 7: Design Pattern

  • Singleton
  • DAO
  • DTO
  • MVC
  • Front Controller
  • Factory Method
  • Abstract

Module 8: Junit

  • JUnit: What and Why?
  • Annotations used in JUnit
  • Assert class
  • Test Cases

Module 9: Maven

  • Maven: What and Why?
  • Ant Vs Maven
  • How to install Maven?
  • Maven Repository
  • Understanding pom.xml
  • Maven Example
  • Maven Web App Example
  • Maven using Eclipse

Module 10: Project Guidance

Struts
  • Introduction to Struts 2.0 Framework
  • Struts Framework Components
  • Struts 2.0 Configuring Elements
  • Struts 2.0 Configuring Files
  • Interceptors
  • Expression Language
  • Value Stack
  • UI Components
  • Type Conversion
  • Validation
  • Localization / Internationalization
Hibernate

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

What to read next?

Nothing to see here. Consider joining one of our full courses..