Course: Java Technologies+
Java Technologies+
Presented by:
Eduardo Burgos
Angel Taveras
Objectives
It’s a course where we plan to show the greatest amount of tools and technologies over which we have been working lately. This idea comes from the amount of people that always asks “what are you working with?”, “what do you use in your work?”, etc.
This class assumes from the student a minimum java knowledge (We’re not going to teach object inheritance or polymorphism), object oriented programming and databases for it’s correct development.
The Way it Works
Angel and I are going to take turns on classes, which means, I will teach some subjects and he will teach others. During all classes, we will both be there (that being teaching or not) to help the students. We will have 1 helping person for every other 10 students in the class. The exercises and homework will be developed in a continuous way, which means those will be used for the next assignment.
For obvious reasons, there will be no tests in this class.
Costs
Location
Depends on the schedules.
Weekly Schedule and Start Date
We plan to start on Friday October 31, 2008
The schedule will be Fridays 18:00 - 22:00 and Saturdays 9:00-13:00.
Contents
Module 1: Building Blocks (44 hrs)
Development Environment: Better Builds (12 hrs)
Subversion
Versioning Concept
Repository Creation
Subversion w/Eclipse
Apache Maven
Maven Concept
Build Phases
Configuration
Maven Archetypes
Maven Integration w/Eclipse
Maven Plugins
Continuous Integration (Apache Archiva)
Issue Management Systems
Bugzilla
Mylyn (Eclipse Integration)
Code generation (AppFuse/Apache Velocity/Java Emitter Template [JET]) (8 hrs)
Application Skeleton generation with AppFuse
Generation of small application parts with Apache Velocity
Java Emitter Template (JET)
Data Layer with Hibernate/EJB3 (20 hrs)
1 -ORM Concepts (2 hrs)
What it’s Persistence?
- Relational Databases
- Understanding SQL
- Using SQL in java
- Persistence in Object Oriented Applications
The paradigm mismatch
- The problem of granularity
- The problem of Subtypes
- The problem of identity
- Problems relating to associations
- The problem of data navigation
- The cost of the mismatch
Persistence Layers an alternatives
- Layered Architecture
- Hand-coding persistence layer with SQL/JDBC
- Using Serialization
- Object Oriented Database Systems
- Other Options
Object/Relational Mapping
- What it’s ORM?
- Generic ORM Problems
- Why ORM?
- Introducing Hibernate, EJB3, and JPA
2 - Domain Models (2 hrs)
Implementing The Domain Model
- Addressing Leakage of concerns
- Transparent and automated persistence
- Writing POJOs and Persistent entity classes
- Implementing POJO associations
- Adding Logic to accesor methods
Object/Relational Mapping Metadata
- XML Based metadata
- Annotation-based metadata
3- Mapping Concepts And Strategies (2 hrs)
Understanding Entities And Value Types
- Fine-grained domain models and concept
Mapping Entities with identity
- Understanding java identity and equality
- Handling database identity
- Database primary keys
- Basic value types
Fine-grained models and mapping
- Mapping basic Properties
- Mapping components
4- Inheritance and Custom Types (2 hrs)
Mapping class Inheritance
- Table per Concrete class with implicit polymorphism
- Table per Concrete class with unions
- Table per class hierarchy
- Table per subclass
- Mixed Strategies
- Choosing a Strategy
Creating Custom Mapping Types
- Considering custom mapping types
- Creating a UserType
- Creating a CompositeUserType
- Parameterizing Custom Types
- Mapping Enumerations
5- Mapping Collections (4 hrs)
Sets, bags, lists and maps of value types
Collections of components
Mapping a parent/children relationship
- Multiplicity
- Making the association bidirectional
- Cascade object state
Single Valued Entity associations
- Shared Primary Key associations
- Mapping with a join table
Many-valued entity associations
- One-to-many associations
- Many-to-many associations
- Adding columns to join tables
- Mapping Maps
Polymorphic Associations
- Polymorphic many-to-one associations
- Polymorphic collections
- Polymorphic table per concrete class
6 - Querying with HSQL and JPA QL (4 hrs)
Creating and running Queries
- Preparing a Query
- Executing a Query
- Using named queries
Basic HQL and JPA QL Queries
- Selection
- Restriction
- Projection
Joins, reporting queries, and subselects
- Joining relations and associations
- Reporting queries
- Using subselects
Querying with criteria and example
- Basic Criteria Queries
- Joins and dynamic fetching
- Projection and report queries
Using native SQL queries
- Automatic resultset handling
- Retrieving scalar values
7 - Working with objects (2 hrs)
The persistence lifecycle
- Object States
- The persistence Context
Object Identity and Equality
- Introducing Conversations
- The Scope of Object Identity
- The Detached Objects
Hibernate Interfaces
- Storing/Loading Objects
- Working with detached entity instances
8 - Transactions and Concurrency (2 hrs)
Transaction Essentials
- Database and system transactions
- Transactions in Hibernate Applications
- Transaction with JPA
Controlling concurrent access
- Understanding database-level concurrency
- Optimistic Concurrency Control
- Using isolation
Unit Testing (4 hrs)
Unit Test (What is a test and why do we need it?)
JUnit
maven test (example)
Generating similar tests with Code Gen
Maven Surefire/Cobertura
Module 2: Concurrency, Service Oriented Architecture (60 hrs)
Java 5 Concurrency Framework (8 hrs)
1 - Fundamentals (2.5 hrs)
Thread Safety
- Atomicity
- Locking
- Guarding State with Locks
- Liveness and Performance
Sharing Objects
- Visibility
- Inmutability
Composing Objects
- Design Thread Safe Classes
- Delegating Thread Safety
- Documenting Synchronizacion Policies
Building Blocks
- Sync Collections
- Concurrent Collections
- Blocking Queues
- Producer/Consumer Pattern
- Synchronizers
2 - Structuring Concurrent Applications (2.5 hrs)
Task Execution
- Executing tasks and threads
- The EXecutor Framework
Cancellation And Shutdown
- Task Cancellation
- Stoping a thread-based service
- Handling abnormal thread termination
- JVM shutdown
Applying Thread Pools
- Implicit couplings between tasks and execution policies
- Sizing thread pools
- Configuring ThreadPools
- Parallelizing Recursive Algorithms
GUI Applications and Threads (Swing Applications)
- Why are GUIs single-threaded ?
- Short-running GUI Tasks
- Long-running GUI Tasks
- Shared data models
- Other forms of single-threaded subsystems
3 - Liveness, Performance (1 hr)
Avoiding Liveness Hazards
- Deadlock
- Avoiding and diagnosing deadlocks
- Other liveness hazards
Perfomance and Scalability
- Thinking about performance
- Amdahl’s Law
- Cost introduced by threads
- Reducing Lock Contention
- Comparing Map Performance
- Reducing Context Switch Overhead
4 - Advanced Topics (2 hrs)
Explicit Locks
- Fairness
- Performance
- Synchronized and ReentrantLocks
- Read-Write Locks
Custom Synchronizers
- Anatomy of a Synchronizer
- AQS (AbstractQueuedSynchronizer)
Atomic Variables and Nonblocking Algorithms
- Disadvantages of Locking
- Hardware Support for Concurrency
- Atomic Variables
- Nonblocking Algorithms
Spring Framework (8 hrs)
Spring IoC (Inversion of Control container) (3 hrs)
Spring Security (Only interfaces, each framework will implement security on it’s own way with spring-security) (1 hr)
Spring AOP (Aspect Oriented Programming) (4 hrs)
Process Scheduling/Quartz in action! (4 hrs)
Motivation
What is Quartz?
Why Quartz?
Samples
Lucene (Text Indexing) (6 hrs)
Core Lucene
- Understanding Lucene
- Indexing and Searching
- Understanding the core Indexing Classes
- Understanding the core Searching Classes
Indexing
- Understanding the indexing process
- Basic Index Operations
- Boosting Documents And Fields
- Indexing Dates
- Indexing Numbers
- Indexing Fields used for sorting
- Controlling the indexing process
- Optimizing an index
- Concurrency, thread-safety, and locking issues
Searching
- Implementing a simple search feature
- Using IndexSearcher
- Understanding Lucene Scoring
- Creating queries
- Parsing Query Expressions
Analysis
- Using Analyzers
- Analyzing the analyzer
- Using the build-in analyzers
- Dealing with keyword fields
- “Sounds like” querying
- Synonyms, aliases, and words that mean the same
- Stemming analysis
- Language Analysis
Advanced Search Techniques
- Sorting search results
- Using PhrasePrefixQuery
- Querying on multiple fields at once
- Span queries
- Filtering a Search
- Searching across multiple indexes
Extending Search
- Using a custom sort method
- Using a custom HitCollector
- Extending QueryParser
- Using a Custom Filter
Hibernate Search (Text Indexing) (2 hrs)
Architecture
- Work execution
- Reader strategy
Configuration
- Directory Configuration
- Reader strategy configuration
- Enabling Hibernate Search and Automatic Indexing
Mapping entities to the index structure
- Mapping an Entity
- Property/Field Bridge
Querying
- Building Queries
- Retrieving the results
- Filters
- Optimizing the query process
- Native Lucene Queries
Manual Indexing
- Indexing
- Purging
Index Optimization
- Automatic Optimization
- Manual Optimization
- Adjusting Optimization
Web Services (Apache CXF) (8 hrs)
SOAP
REST
Some different transports (JMS, HTTP, JBI).
JBI/OSGI (8 hrs)
JBI 1.0 concept (Service assemblies, service units, service engines)
JBI 2.0 (upcoming)
Introduction to Apache Servicemix
OSGI concept
Eclipse with osgi
Plugin/Module model
Servicemix 4 application
Management Console - JMX (2 hrs)
MBeans, etc
JackRabbit/Apache Sling - Document Oriented Databases (4 hrs)
Jackrabbit/Sling database access from web services
Development of a small application using this service model
Module 3: User Interface Frameworks (36 horas)
Reporting (BIRT) (4 hrs)
AJAX with GWT (12 hrs)
Getting Started
- Introducing GWT
- Creating the Default Application
Building User Interfaces
- Working with Widgets
- Working with Panels
- Handling Events
- Creating Composite Widgets
- Building JSNI Components
- Modularizing an Application
Advanced Techniques
- Communicating with GWT-RPC
- Client-Side RPC Architecture
- Achieving Interoperability with JSON
- Automatically generating New Code
- Changing application based on GWT properties
Adobe Flex/AIR (20 horas)
Flex Basic (4 hrs)
Comparing flash and flex
Comparing web and desktop (air)
Flex Builder
MXML
Data Binding
i18n
Events
Components (4 hrs)
Grids
Containers
Renderers
Creating new components
Validation (2 hrs)
Effects (1 hr)
Basic Effects
Services (3 hrs)
Web Services
HTTP Services
RPC (delayed until we get to BlazeDS)
Object types (RPC bind, XML, E4X, Flex objects)
Converting an application to AIR ( 2 hrs )
BlazeDS Proxy, RPC, AMF (Adobe Flex) (4 hrs)
Proxy Service concept
AMF binary protocol
RPC concept
RPC bound data types
BlazeDS sample with a spring factory
