Advanced Java Training

nTier's Advanced Java training course focuses on developing software using the Java 2 Platform, Standard Edition, or J2SE. It is intended for students with solid experience in structured and object-oriented Java programming, including use of the Collections API and exception handling. The course software also includes an optional overlay of workspace and project files to support use of the Eclipse IDE in the classroom.

The course is organized into four modules. The first covers several general-purpose topics such as writing multi-threaded applications, the Reflection API, and network programming using sockets. Then the course takes up the challenge of building multi-tier applications using the standard Java platform. Multi-tier development most frequently uses the Java 2 Platform, Enterprise Edition, or J2EE, and we have a wide range of courses in that area. However it is quite possible to build lightweight multi-tier applications using only J2SE, and for some purposes the J2EE is more trouble than it's worth. So the course looks at each of the traditional tiers and the J2SE APIs most suited to developing them. The second module of the course covers the Java Foundation Classes, or JFC, for building graphical user interfaces (GUIs) for the presentation tier. The third module introduces Java Remote Method Invocation, or RMI, as a way of distributing Java objects over multiple processes, which may be spread over a network of machines; this provides a means of developing a separate business tier. Finally, the fourth module teaches the Java Database Connectivity, or JDBC, API, for the persistence tier.

Students will complete the course with a good working knowledge of each of these technologies, prepared to build distributed Java applications and to pursue JFC, RMI, or JDBC in greater depth.

We also offer Introduction to Java training and Intermediate Java training.

• Write multi-threaded Java applications.
• Use the Reflection API for highly generic tasks, discovery, or code-generation.
• Communicate between processes using network sockets.
• Understand the basics of the JFC architecture.
• Build simple GUI applications using JFC.
• Build more complex GUIs using various JFC controls.
• Use the many hooks into the JFC architecture to easily customize rendering and editing within JFC controls.
• Understand the significance of the MVC decomposition in using JFC controls.
• Build GUI classes that make effective use of events as fired from model, view and controller elements of the GUI itself.
• Understand the role of Java RMI in distributed Java software development.
• Understand the relationship between RMI and various J2EE technologies such as JNDI, EJB, and CORBA.
• Understand the RMI framework and architecture, especially the role of generated stubs and skeletons.
• Implement simple RMI clients and servers.
• Connect to a database using JDBC and perform a simple query.
• Update relational data using JDBC to execute updates, inserts and deletes.
• Use prepared statements to produce reusable database queries and optimize execution time.
• Use callable statements to access database procedures.
• Use scrollable and updatable results sets for more robust solutions.
• Use commit, rollback, and savepoint to build transactional systems.
• Use batch processing for efficient handling of large datasets

Students must be experienced Java programmers, able to build, test, and debug complex applications using structured and object- oriented code designs, and familiar with the Collections API and Java exception-handling.

Module 1. Advanced Java APIs

1. Threads
   • Java Thread Model
   • Threads and ThreadGroups
   • Creating and Running Threads
   • Manipulating Thread State
   • Creating Thread Classes
   • Thread Synchronization
   • Java 1.5: Concurrency Library wait and notify join and sleep
2. Reflection Uses for Meta-Data
   • The Reflection API
   • The Class Class
   • The java.lang.reflect Package
   • Reading Type Information
   • Navigating Inheritance Trees
   • Dynamic Instantiation
   • Dynamic Invocation
   • Java 1.5: Annotations and Aspect-Oriented Programming
3. Serialization
   • The Challenge of Object Serialization
   • Serialization
   • API Serializable Interface
   • ObjectInputStream and ObjectOutputStream
   • The Serialization Engine
   • Transient Fields
   • readObject and writeObject
   • Externalizable Interface
4. Sockets
   • The OSI Reference Model
   • Network Protocols
   • The Socket Class
   • The ServerSocket Class
   • Connecting Through URL Objects
   • HTTP and Other TCP Servers
   • Datagram Clients and Servers
   • Non-Blocking Sockets

Module 2. The Java Foundation Classes

1. Introduction to JFC
   • Abstract Windowing Toolkit (AWT) Basics
   • Simple Layout Management
   • Simple Event Handling
   • Lightweight Controls
   • JFC Feature
   • Set JFC Architecture and Relationship to AWT
2. JFC Application Design
   • Role of a JFrame
   • Building a Frame-Based JFC Application
   • Panes Using Dialogs
3. JFC Components
   • JFC Component
   • Class Hierarchy
   • JComponent Features
   • Simple Control Types
   • Text Components
   • Menus
   • Managing Look and Feel
4. Architectural Patterns
   • Observer Pattern
   • Model-View-Controller
   • Decomposition
   • Strategy Pattern
   • JList
   • Factory Pattern
   • JComboBox

Module 3. Java Remote Method Invocation

1. RMI Architecture
   • Motivation for RMI
   • RMI and EJB
   • RMI and CORBA
   • Overview of RMI Architecture
   • Stubs and Skeletons
   • Remote Reference Layer
   • RMI Transport
   • Lifetime of a Remote Method Invocation
   • RMI Registry
   • Naming and URL Resolution
   • RMI Up and Running
2. RMI Implementation
   • Interface Design
   • The Remote Interface
   • Implementation Classes
   • The RemoteObject and RemoteServer Classes
   • The UnicastRemoteObject Class
   • Server Implementation
   • Using the Registry
   • Client Implementation
   • Code Deployment
3. Practical RMI
   • Stub Source Code
   • RMI Marshaling
   • Skeleton Source Code
   • Diagnostic Code
   • Using RemoteServer
   • Passing Objects
   • The Factory Pattern
   • Serialization vs. Remote Reference
   • Designing for Latency
   • The Value Object Pattern
   • Exception Handling

Module 4. Java Database Connectivity

1. Database and SQL Fundamentals
   • Relational Databases and SQL Database, Schema, Tables, Columns and Rows
   • SQL Versions and Vendor Implementations
   • DDL - Creating and Managing Database Objects
   • DML - Retrieving and Managing Data Sequences
   • Stored Procedures
   • Using SQL Terminals
2. JDBC Fundamentals
   • What is the JDBC API?
   • JDBC Drivers
   • Making a Connection
   • Creating and Executing a Statement
   • Retrieving Values from a ResultSet
   • SQL and Java Datatypes
   • SQL NULL Versus Java null
   • Creating and Updating Tables
   • Handling SQL Exceptions and Proper Cleanup
   • Handling SQLWarning
3. Advanced JDBC
   • SQL Escape Syntax
   • Using Prepared Statements
   • Using Callable Statements
   • Scrollable Result Sets
   • Updatable Result Sets
   • Transactions Commits, Rollbacks, and Savepoints
   • Batch Processing
   • Alternatives to JDBC
4. Introduction to Row Sets
   • Row Sets in GUI and J2EE programming
   • Advantages of RowSets
   • RowSet Specializations
   • Using CachedRowSets