|
Provided by: Boston University Corporate Education Center Advanced Java ProgrammingUnfiled |
 |
This course provides advanced training in 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 first part of the course covers several general-purpose topics: using Java-5.0 generics, writing multi-threaded applications, the Reflection API and annotations, and network programming using sockets. Then the course takes up the challenge of building multi-tier applications using the standard Java platform.
We will look at each of the traditional tiers and the J2SE APIs most suited to developing them: the Java Foundation Classes, or JFC, for building graphical user interfaces (GUIs) for the presentation tier; Java RMI as a way of distributing Java objects in a separate business tier; and JDBC for the persistence tier. Upon completion of the course, you will be prepared to build distributed Java applications and to pursue JFC, RMI, or JDBC in greater depth.
What you will learn:
Make effective use of Java generic types.
Write multi-threaded Java applications.
Use the Reflection API for highly generic tasks, discovery, or code-generation.
Use standard annotations and develop custom annotations to express meta-data in Java source files.
Communicate between processes using network sockets.
Understand the roles of JFC, RMI, JDBC, and other Core API packages in the classic multi-tier architecture for distributed systems.
Understand the basics of the JFC architecture.
Build complex GUIs using various JFC controls.
Understand the relationship between RMI and various J2EE technologies such as JNDI, EJB, and CORBA.
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.
Use the Java 5.0 Core API and related tools to develop robust multi-tier applications.
Prerequisites: 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. JAV 104 would be excellent preparation.
Module 1. Advanced Java APIs
1. Threads
Java Thread Model
Creating and Running Threads
Manipulating Thread State
Thread Synchronization
Volatile Fields vs. Synchronized Methods
wait and notify
join and sleep
The Concurrency API
Atomic Operations
2. Reflection
Uses for Meta-Data
The Reflection API
The Class
The java.lang.reflect Package
Reading Type Information
Navigating Inheritance Trees
Dynamic Instantiation
Dynamic Invocation
Reflecting on Generics
3. 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 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
Module 3. Java Remote Method Invocation
1. RMI Architecture
Motivation for RMI
RMI, EJB, and CORBA
RMI Architecture
Lifetime of a Remote Method Invocation
Registries
Naming and URL Resolution
Interface Design
The Remote Interface
Implementation Classes
The RemoteObject and RemoteServer Classes
The UnicastRemoteObject Class
Server Implementation
Using the Registry
Client Implementation
Code Deployment
2. Practical RMI
RMI Marshaling
Passing Objects
The Factory Pattern
Serialization vs. Remote Reference
Designing for Latency
The Transfer Object Pattern
Controlling Object Location
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
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
4. Introduction to Row Sets
Row Sets in GUI and J2EE programming
Advantages of RowSets
RowSet Specializations
Using CachedRowSets
|
|
||||||||||
