Secure Search

Java University

Exclusive Hands-On Training Delivered by the Experts

Super-charge your conference experience by attending our 12th annual Java University training event on Friday, September 24, 2010 at Moscone Center in San Francisco. Our expert-led courses give you an exclusive opportunity to delve deeper into the hottest technical topics in a dynamic classroom environment. Don't miss this one-of-a-kind training opportunity — for only $750.00 you can add Java University to your conference package or register for Java University only!


Attend a Full-Day Course (8:00 a.m. - 5:00 p.m.)



Attend a Half-Day Morning Course (8:00 a.m. - 12:00 p.m.)



Attend a Half-Day Afternoon Course (1:00 p.m. - 5:00 p.m.)

Designing and Implementing Secure Java Web Services

Instructor: Moises Lejter
Course Level: Intermediate to Advanced
Course Length: Full Day

Course Description
This course provides the information you need to design, implement, deploy, and maintain secure Web services and Web service clients using Java technology components, Java APIs, Java API for XML Processing (JAXP), Java Architecture for XML Binding (JAXB), SOAP with Attachments API for Java (SAAJ), Java API for XML Registries (JAXR), Java API for XML Web Services (JAX-WS), the Java API for RESTful Web Services (JAX-RS), and Java Platform, Enterprise Edition 6 (Java EE 6). It also explains Web services as a realization of Service Oriented Architecture (SOA). Learn to secure and optimize Web services using Web services standards (such as WS-Security) through the facilities built into Project Metro.

Course Approach
The instructor provides coding examples that illustrate the functionality of the JAX-WS API and how to secure Java technology-based Web services. The course also features a discussion of samples of code related to an implementation using JAX-WS APIs and Web Services Security. The demos for this course feature the Project GlassFish Application Server and NetBeans integrated development environment.

Morning Content

  • Java technologies for Web services and platforms
  • Java technologies for Web services development approaches
  • Web services development process
  • Java API for XML Web Services (JAX-WS)
  • The functionality provided by JAX-WS API for creating Web services
  • The architecture of JAX-WS API
  • Using JAXB within JAX-WS
  • Comparing the two development approaches provided JAX-WS API for creating Web services and Web service clients
  • The various types of Web service clients
  • Defining Web services through Web Services Description Language (WSDL)
  • Web services processing using JAXP, SAAJ, and JAXR for Web services

Afternoon Content

  • Securing Java Web services security using message-layer security
  • Message-layer Security mechanisms (WS-Security)
  • The functionality provided in Project Metro for securing Web service applications
  • The Security Assertions Markup Language (SAML) specifications for Web services
  • Optimizing Web services interactions
  • Using the message transmission optimization mechanism
  • Propagating transaction contexts (WS-Coordination and WS-AtomicTransaction standards)
  • Introducing message delivery guarantees
  • Implementing Web services using REST
  • Building RESTful Web services in JAX-WS
  • Building RESTful Web services using JAX-RS and Jersey

Prerequisites
A thorough knowledge of Java technology, Java Platform, Enterprise Edition (Java EE), Enterprise JavaBeans (EJBs) architecture framework and XML, and basic knowledge of SOAP, SAAJ, WSDL, and Universal Description, Discovery, and Integration (UDDI).

Objectives
Upon completion of this course, attendees should have an understanding of using the Java API for XML as the standard programming model for both Web service clients and endpoints in Java EE technology applications. Attendees should also have an understanding of the tools and techniques available for securing a Java technology-based Web service.

Features of this course:

  • Code reviewed and demonstrated by the instructor will be available for download upon completion of the class
  • Attendees will receive printed copies of instructor slides
  • Material will be presented by an Oracle-certified Java technology instructor
  • Instructor will be available for questions immediately following the course

Job Roles This course Is Applicable To

  • Java Web services developers

Developing Enterprise Applications with the Spring Framework

Instructor: Chris Richardson
Course Level: Intermediate
Course Length: Half Day, Afternoon

Course Description
This course enables attendees to gain a clear understanding of the Spring framework. Spring is a full-stack Java technology-based application framework. Through judicious support for dependency injection (DI), aspect-oriented programming (AOP), and portable service abstraction, Spring offers a powerful and pragmatic way to develop enterprise applications.

Course Approach
Topics covered include the principles of DI and how it helps simplify test-driven development (TDD). The course also examines the AOP concepts and their pragmatic applications, as well as Spring's extensive support for middle-tier functionality, including persistence, remoting, management, messaging, and control flow. The new features of Spring 2.5 are also covered, including context namespace, which offers syntax for common configuration scenarios and simplifies configuration by harnessing the power of Java annotations. By the end of the course, attendees should be ready to apply Spring in their own applications.

Content

  • The Spring Lightweight Container Architecture, including Inversion of Control
  • Agile, domain-driven design techniques with Spring
  • Effective JDBC and persistence data access
  • Declarative transaction management
  • Pragmatic AOP
  • Unit testing in isolation
  • Rapid system integration testing
  • Spring support for JSR-250 annotations

Prerequisites
Attendees should have the a good understanding of the core Java platform, as well as a basic knowledge of general Java EE concepts.

Objectives
Upon completion of this course, attendees should have an understanding of how to use the Spring framework to create useful business applications.

Features of This Course

  • Code reviewed and demonstrated by the instructor will be available for download after completion of the class
  • Attendees will receive printed copies of instructor slides
  • Material will be presented by an Oracle-certified Java technology instructor
  • Instructor will be available to answer questions immediately following the course

Job Roles This Course Is Applicable To

  • Business application developers

Developing Java Technology Applications with the Java Persistence API 2.0

Instructors: Linda DeMichiel, Bob Kellogg
Course Level: Intermediate
Course Length: Half Day, Afternoon

Course Description
This course covers how to use the Java Persistence API to develop and deploy data-driven applications with Java EE and Java SE. The Java Persistence API allows Java SE and Java EE developers to model database entities as plain old Java objects (POJOs). Attendees learn to program with the Java Persistence API independent of platform, as well as how the Java Persistence API integrates with EJB 3.x component services to facilitate the development of enterprise applications.

Course Approach
The instructors highlight and discuss sections of code examples illustrating the functionality and use of the Java Persistence API. The demos for this course feature the Project GlassFish Application Server and NetBeans integrated development environment.

Content
The Java Persistence API

  • The role of the Java Persistence API in a Java technology application
  • Understanding the principles of object relational mapping
  • The key concepts of persistence contexts and persistence units
Implementing entity classes
  • Modeling persistent state
  • Entity identity
  • Modeling entity relationships
  • Modeling inheritance relationships
Using the EntityManager API
  • Controlling the entity lifecycle
  • Using managed and detached entities
Using the Java Persistence API query language
  • Defining static queries
  • Defining dynamic queries
  • Deciding when and how to use SQL queries
Controlling the object/relational mapping
  • Understanding the defaults
  • Configuring with annotations
  • Configuring and/or overriding with XML
Implementing with container-managed and application-managed persistence contexts
  • Implementing with JTA transactions
  • Implementing using the EntityTransaction API
  • Using the bootstrapping APIs in Java SE environments
Leveraging container services for Java persistence
  • Understanding transaction propagation and persistence context propagation
  • Using extended persistence contexts to implement conversations
  • Configuring and packaging a Java Persistence Application

Prerequisites
Attendees must have prior knowledge of the Java programming language and basic knowledge of relational database concepts.

Objectives
Upon completion of this course, attendees should have an understanding of how to use the Java Persistence API to build data-driven applications with Java SE and Java EE.

Features of This Course

  • Code reviewed and demonstrated by the instructors will be available for download upon completion of the class
  • Attendees will receive printed copies of instructor slides
  • Instructors will be available to answer questions immediately following the course

Job Roles This Course Is Applicable To

  • Application developers

Developing Portable Java EE Applications with the Enterprise JavaBeans 3.1 Component API

Instructors: Bob Kellogg
Course Level: Intermediate
Course Length: Half Day, Morning

Course Description
This course provides attendees with up-to-date knowledge of the EJB 3.1 component API used to develop and deploy portable business applications in Java EE. The EJB 3.1 component has been vastly simplified to improve productivity when writing component-based applications. Attendees learn the fundamental EJB component concepts such as session beans, message-driven beans, transactions, and security, as well as how EJB 3.1 components make it easy to use container services to develop your applications.

Course Approach
The instructors will highlight and discuss sections of code examples illustrating the functionality and use of EJB 3.1 components. The demos for this course feature the Project GlassFish Application Server and NetBeans integrated development environment.

Content
Java EE Platform component model

  • The principles of a component-based development model
  • Understanding the roles involved in developing Java EE applications
Developing EJB 3.1 component session beans as business facades
  • The role of session beans
  • The function and operational characteristics of stateless and stateful session EJB components
  • The use of annotations and dependency injection to implement session beans and their clients
Developing EJB 3.1 component message-driven beans
  • The properties and lifecycle of message-driven beans
  • Developing Java Message Service (JMS) APIs and non-JMS API message-driven beans
Understanding common EJB component concepts
  • The role of annotations and deployment descriptors
  • The bean component environment and lookups
  • Application exceptions and system exceptions
  • Packaging and deploying to an application server
Implementing transactions
  • Implementing container-managed transactions (CMT)
  • Implementing bean-managed transactions (BMT)
Implementing security
  • Understanding the Java EE security architecture
  • Declarative authorization
  • Programmatic authorization
Advanced concepts
  • Implementing interceptor classes and methods
  • The EJB component timer service

Prerequisites:
Knowledge of the Java programming language.

Objectives
Upon completion of this course, attendees should have an understanding of how to use the EJB 3.1 Component API to build business applications with Java EE.

Features of This Course

  • Code reviewed and demonstrated by the instructor will be available for download after completion of the class
  • Attendees will receive printed copies of instructor slides
  • Instructors will be available to answer questions immediately following the course

Job Roles This Course Is Applicable To

  • Application developers

Extreme Performance: Tuning Java SE for Throughput and Latency

Instructors: Simon Roberts, Charlie Hunt
Course Level: Intermediate to Advanced
Course Length: Half Day, Morning

Course Description
Many software applications have very stringent response time goals or service level agreements. These requirements have traditionally been challenging for Java Platform, Standard Edition (Java SE) applications, due to garbage collection pauses. However, with advancements to Java Virtual Machines and the introduction of Java Real-Time System, these stringent response time requirements can be met. In this course attendees learn to tune both Java SE and Java Real-Time System applications. This course begins by performance tuning Java applications, which require less-strict, soft real-time responsiveness. Next the attendees will move on to performance tuning Java applications with strict and predictable real-time low-latency responsiveness requirements.

Course Approach
The instructors explain the concepts behind the art of performance tuning Java applications for low latency responsiveness, provide tools to help with performance tuning, and include demonstrations emphasizing the key points. A brief question and answer session will also be included.

Content
Learn how Java SE and Java Real-Time System address the challenges of applications that require low latency or garbage collection pause times.

Overview of Java SE HotSpot JVM garbage collectors

  • Intro to how generational garbage collection works
  • Overview of SerialGC collector
  • Overview of parallel / thoughput collector
  • Overview of concurrent collector
    • Concurrent collector phases
    • Advantages and challenges of concurrent collector
  • Overview of the Garbage First collector (in development)
  • Choosing the right collector
Performance tuning Java SE / HotSpotJVM for low latency
  • Garbage collection goals
  • Sizing Java heaps and heap spaces
  • Garbage collector tuning
    • Basics of garbage collector tuning
    • Detailed concurrent collector tuning
  • Monitoring tools
Overview of Java Real-Time System
  • Performance tuning Java Real-Time System garbage collector
  • Features of Java Real-Time System that avoid garbage collection pauses
  • Advantages and challenges of each feature
  • Tips on when and how to use these features
  • Tuning Java Real-Time System garbage collection.

Prerequisites
Basic understanding of a Java Virtual Machine is useful but not required. Java programming experience is also useful but not required.

Objectives
Upon completion of this course, attendees should be able to performance tune Java application with low latency responsiveness requirements.

Features of This Course

  • Attendees will receive printed copies of instructor slides
  • Attendees will be provided with demo materials and instructions on how to perform them
  • Instructors will be available to answer questions immediately following the course

Job Roles This Course Is Applicable To

  • Software architects
  • Application developers
  • Applications systems engineers
  • Application deployment engineers

Filthy Rich Clients

Instructor: Bryan Basham
Course Level: Intermediate to Advanced
Course Length: Half Day, Afternoon

Course Description
This course is based on the Java Series book, Filthy Rich Clients. Graphical effects and animation in GUIs can be gratuitous, but when done right, they can make applications more effective and users more productive.

Course Approach
This course provides a lot of code and demos so attendees learn how to apply the covered techniques to applications. The demos for this course feature the NetBeans integrated development environment.

Content
Fundamentals

  • Swing and graphics fundamentals
  • Advanced graphics rendering
  • Advanced swing rendering
  • Performance
Animation
  • Animation fundamentals
  • Timing framework
Effects
  • Static effects
  • Dynamic effects

Prerequisites
Attendees must have a basic knowledge of the Swing API, and should have written at least a small Swing application.

Objectives
Upon completing this course, attendees should have a better understanding of Swing graphics rendering and know how to take advantage of that knowledge to write better, better looking, and faster applications. They will also understand the fundamentals of how to animate rendering in Swing applications to create more-dynamic desktop applications.

Features of This Course

  • Code reviewed and demonstrated by the instructor will be available for download upon completion of the class
  • Attendees will receive printed copies of instructor slides
  • Material will be presented by a Oracle certified Java technology instructor
  • Instructor will be available to answer questions immediately following the course

Job Roles This Course Is Applicable To

  • Developers

How Java EE and SOA Help in Architecting and Designing Robust Enterprise Applications

Instructor: Joe Boulenouar
Course Level: Intermediate to Advanced
Course Length: Full Day

Course Description:
This course provides Java EE 5 and Java EE 6 best practices and patterns to design and architect robust enterprise applications that allow for rapid change and growth. Attendees gain an understanding of the latest Java EE 5 and 6 technology patterns and how they help solve important and recurring design problems. This course also covers how SOA, implemented in a wide range of technologies (including REST, RPC, RMI, DCOM, CORBA, and Web services), help businesses respond more quickly and cost-effectively to changing market conditions. Attendees also learn how an Enterprise Service Bus (ESB) helps automate, manage, and optimize business processes and workflows across systems, people, and partners, and build robust cloud computing applications. Also included in this course is information on how to prepare for the Java Enterprise Architecture certification.

Course Approach
This course focuses on Java EE patterns from the architectural and design perspectives. Enterprise SOA and cloud computing is also covered. The instructor uses UML diagrams and code segments to present these patterns. The demos for this course feature the Project GlassFish Application Server Enterprise Edition, NetBeans IDE with the Visual Web Pack, Java Composite Application Platform Suite for the enterprise designer, and Java System Web Server.

Morning Content
System architecture development and guidelines

  • Justify the need for architecture when developing for Java EE applications
  • Resolving risk factors in distributed enterprise systems
  • Guidelines for effective network communication
  • Guidelines for handling distributed transactions
  • Analyzing quality-of-service requirements
Software architecture
  • Decomposing Java EE application into components
  • Deployment diagrams to represent the architecture and design model
Using Java EE patterns
  • Java EE patterns that assist in the presentation tier
  • Web 2.0 design patterns
  • Java EE patterns that assist in the business tier
  • Java EE patterns that assist in the integration tier

Afternoon Content
Understanding enterprise SOA

  • Using SOA for enterprise application integration
  • How SOA improves B2B business processes
  • Service-oriented architecture and design
Building composite applications
  • Web services design patterns
  • Integrating and orchestrating applications services
  • JBI components: service engines and binding components
  • Enterprise Service Bus transformation, routing and orchestration
Building cloud computing applications
  • Cloud computing architecture
  • The impact of Java EE on cloud computing
  • The impact of SOA on cloud computing

Prerequisites
Knowledge of the Java programming language and EJB component technologies, and an understanding of Java EE application servers and distributed systems.

Objectives
Upon completion of this course, attendees should understand of how Java EE patterns help to architect and design robust Java EE applications. They should also understand the advantages of building enterprise SOA architectures.

Features of This Course

  • Case diagrams illustrating a solution to a given problem will be provided
  • Code reviewed and demonstrated by the instructor will be available for download after completion of the class
  • Attendees will receive printed copies of instructor slides
  • Material will be presented by an Oracle-certified Java technology instructor
  • Instructor will be available to answer questions immediately following the course

Job Roles This Course Is Applicable To

  • Java EE architects and designers
  • Project managers
  • Development managers

Integrating Web 2.0 and Cloud Computing to Build the Next-Generation Services

Instructor: Stacy Thurston
Course Level: Beginner to Intermediate
Course Length: Half Day, Morning

Course Description
This course covers how to develop and implement Enterprise 2.0 technology to integrate and connect to cloud computing. Attendees will learn to implement an Enterprise 2.0 front-end application using JavaScript, Ajax, CSS, and HTML to provide a rich user experience and connect to cloud computing services transparently through secure Web services. Attendees will learn how cloud computing controls capacity or adds services without investing in new infrastructure, requiring new personnel, or licensing new software. Software as service, platform as a service, and infrastructure as a service are also covered.

Course Approach
The instructor will explain the concepts behind each topic, and then provide a demonstration emphasizing the key points. The course is concluded by a brief question and answer session.

Content

  • Building Enterprise 2.0 applications
  • Implementing Ajax with REST, SOAP, Web services
  • Using secure Web services to connect to a cloud
  • Cloud computing architecture
  • Using SOA in cloud computing
  • Using a software as a service in cloud computing
  • Using virtualization in cloud computing
  • Using storage in cloud computing

Prerequisites
Some Web application development would be useful but not required

Objectives
Upon completion of this course, attendees should be able to build reasonably sophisticated Enterprise 2.0 applications that integrate to cloud computing.

Features of This Course

  • Code reviewed and demonstrated by the instructor will be available for download upon completion of the class
  • Attendees will receive printed copies of instructor slides
  • Instructor will be available to answer questions immediately following the course

Job Roles This Course Is Applicable To

  • Developers and architects

Java Certification Workshop: Review and Prep Session to Pass the Oracle Certified Java Programmer Certification Exam

Instructors: Evan Troyka, John Ranta
Course Level: Intermediate
Course Length: Full Day

Course Description
This course will prepare attendees for successful passage of the SCJP 6.0 exam.

Course Approach
The instructors will highlight, demonstrate, and discuss concepts and source code related to certification subjects when developing in the Java programming language.

Content

  • Java programming environment fundamentals such as CLASSPATH, compiler and runtime CLI flags; package/directory structures; JAR files; and garbage collection
  • Java language fundamentals such as pass-by-value vs. pass-by-reference; arithmetic, logical, assignment, and comparison operators; flow control and looping; try/catch and assertions; common language exceptions and errors; variable-length arguments
  • Coding concurrent applications with java.lang.Thread and java.lang.Runnable; object locking, Object.wait(), Object.notify(), and Object.notifyAll()
  • Object-oriented programming (OOP) and the Java language, encapsulation, inheritance polymorphism, overloading, overriding, this, static, super, constructors, interfaces, and inner and nested classes
  • API usage:
    • java.lang: Wrapper classes, auto-boxing and unboxing, interface Comparable interface, and class Class
    • java.util: Generics and collections, sorting and natural ordering, Comparator, NavigableSet, Navigable Map, Locale, and Scanner
    • java.util.regex: Basics of Pattern, Matcher, String.split(), and PrintStream.printf()
    • java.text: Formatters for dates, currency, and numbers, including default locale and specified locales
    • java.io: File, FileReader, FileWriter, buffered versions of i/o classes, PrintStream, PrintWriter, Console; serialization of objects, and the various streams used

Prerequisites
Attendees should have some prior Java technology programming experience.

Objectives
Upon completion of this course, attendees will have a better understanding of what they need to know to pass the SCJP 6.0 exam.

Features of This Course:

  • Code reviewed and demonstrated by the instructors will be available for download upon completion of the class
  • Attendees will receive printed copies of instructor slides
  • Material will be presented by a qualified instructor
  • Instructors will be available to answer questions immediately following the course

Job Roles This Course Is Applicable To

  • Java technology developers

Java Performance Tuning (JVM) Workshop

Instructor: Kirk Pepperdine
Course Level: Intermediate to Advanced
Course Length: Full Day

Course Description
This seminar blends theory and practices with tooling that has been proven to be effective in solving real performance problems. The objective is to demonstrate what steps are needed in order to quickly identify and eliminate performance bottlenecks. This course also helps you understand and avoid common and often costly mistakes that developers make when they embark on a tuning exercise.

Course Approach
The instructor will explain the concepts behind the art of performance tuning Java applications for low-latency responsiveness, introduce tools to help with performance tuning, and provide demonstrations emphasizing the key points. A brief question and answer session will also be included.

Content

  • Elements and dynamics of a software system
  • The performance tuning environment
  • A simple peformance-tuning process
  • Performance tooling
  • Java memory management

Prerequisites
Basic understanding of a Java Virtual Machine is useful, but not required. Java programming experience is also useful but not required.

Objectives
Upon completion of this course, attendees should be able to performance tune a Java application that has low-latency responsiveness requirements.

Features of This Course

  • Attendees will receive printed copies of instructor slides
  • Attendees will receive demo materials and instructions on how to use them
  • Instructor will be available to answer questions immediately following the course

Job Roles This Course Is Applicable To:

  • Software architects
  • Application developers
  • Applications systems engineers
  • Application deployment engineers

Learning How to Develop Java ME Applications for Mobile Devices

Instructor: Tim Miller
Course Level: Beginning to Intermediate
Course Length: Half Day, Morning

Course Description
With billions of Java devices all over the world, Java ME with a current Mobile Service Architecture (MSA) profile is one of today's hottest technologies. And with the enhancement in Java ME, developing applications for mobile devices is becoming even more attractive. In this course, participants get a basic introduction to the Java ME platform and then learn how to build an application by using the NetBeans IDE. The course also includes adding media to an application as well as testing and deploying it. Finally, attendees can apply what they've learned by building a sample application. The instructor demonstrates a variety of approaches for using common Java code and libraries with front ends built on Java ME/MSA.

Course Approach
The instructor details sections of code related to the development of the Java ME application and demonstrates how to use the NetBeans IDE to create, test, and deploy an application for mobile devices. Also provided are code samples, technical approaches, and information on the various ways to add media to a Java ME application.

Content

  • Introduction to the Java ME platform
  • Similarities and differences in application development
  • Setting up and using the NetBeans IDE for the Java ME project
  • Using media in your application
  • Creating interoperable code and shared libraries
  • Incorporating Web services into your application
  • Testing the application

Prerequisites
Attendees must provide their own laptop preloaded with

Objectives
Upon completion of this course, participants should have an understanding of how to create Java ME applications by using the NetBeans IDE and be able to incorporate media capability.

Features of This Course

  • Code reviewed and demonstrated by the instructor will be available for download upon completion of the class
  • Attendees will receive printed copies of instructor slides
  • Material will be presented by an Oracle-certified Java technology instructor
  • Instructor will be available to answer questions immediately following the course

Job Roles This Course Is Applicable To

  • Java ME application developers

More Than Skin Deep: JSF 2.0 Foundation and Practice

Instructors: Ed Burns
Course Level: Intermediate
Course Length: Half Day, Afternoon

Course Description
This course provides an in-depth survey of JavaServer Faces 2.0, the standard Web application framework for Java EE 6. Because many of the new features in JSF 2.0 provide a clean break from previous versions of the framework, this course does not assume prior experience with the framework. Experienced JSF users will also benefit from this course because migration strategies will be presented as sidebars. Typical JSF problems are also covered in context.

Course Approach
Because JSF is a technology that unifies several other layers of Java EE, the course approaches JSF from three distinct but related viewpoints: the application developer, the UI component developer, and the framework extender. The demos for this course feature the NetBeans integrated development environment.

Content
Introducing JSF: High-level subsystems block diagrams
Application developer viewpoint

  • Sample application traversal
  • Database layer, including JSR-299 WebBeans
  • Model layer, managed beans, JSR-303 BeanValidation
  • View and controller layer, including Ajax
UI component developer viewpoint
  • Composite Components, including JSR-276 metadata
  • Resource Libraries
  • Ajax integration
  • Scripting to save time
  • Component annotations
Framework extender viewpoint
  • Patterns that enable extension
  • Survey of extension points
  • Sample extensions

Prerequisites
Attendees should have Java technology programming and Web framework experience.

Objectives
Upon completion of this course, attendees should be able to create practical and effective Web applications using JSF.

Features of This Course

  • Code reviewed and demonstrated by the instructor will be available for download upon completion of the class
  • Attendees will receive printed copies of instructor slides
  • Material will be presented by Ed Burns, author and co-spec lead for JSF
  • Instructors will be available to answer questions immediately following the course

Job Roles This Course Is Applicable To

  • Java technology Web application developers

Rapid Web Application Development with Groovy and Grails

Instructor: Graeme Rocher
Course Level: Intermediate
Course Length: Half Day, Morning

Course Description
This course covers the features offered by the Groovy language and Grails framework and includes lab sessions that guide you through key elements of both. In addition, attendees learn how to integrate Grails with existing Java technology enterprise services, databases, and Web applications, and how to use an approach that blends static and dynamically typed code to maximize the scalability of your code base.

Course Approach
This Groovy and Grails course is authored by Graeme Rocher, project lead and founder of Grails. Attendees receive a copy of The Definitive Guide to Grails, by Graeme Rocher and Jeff Brown.

Content

  • Groovy for Java technology developers: the basics
    • The syntax similarities
    • New language constructs
    • Groovy strings
    • Closures
  • What makes Groovy tick?
    • Groovy dynamism
    • Meta-programming
    • Embedding Groovy
Getting started with Grails
  • The Grails introduction
    • Background, foundations, and motivations
    • Current project status
    • Why choose Grails for your project?
  • Grails basics
    • The project infrastructure
    • Running Grails scripts
    • Creating a basic CRUD application
  • The Grails domain model
    • Understanding domain models
      • Domain-driven development with Grails
      • Applying domain constraints
      • Defining domain relationships
    • Working with persistence methods
      • Saving, deleting and updating
      • Using dynamic finders
      • Advanced querying with criteria and HQL
  • The Web Layer
    • Orchestrating requests with controllers
      • Rendering responses
      • Handling data binding and validation
    • Groovy Views with GSP
      • Supplying the model
      • Logic, iteration, and filtering
      • Advanced site layouts with SiteMesh
    • Separating logic and content with tag libraries
      • Dynamic tag library basics
      • Logical and interactive tags
    • Grails plugins
      • Plugin basics
        • Discovery
        • Installation
      • Popular plugins
        • Searchable
        • Quartz
        • JMS
      • Creating plugins
        • Modularizing applications
        • Providing behavior
    • Java technology integration
      • Packaging and deployment onto Java EE containers
      • Grails and the servlet environment
      • Wiring it all together with the Spring DSL

Prerequisites
Attendees must have knowledge of Web application development using programming languages such as Java or JavaScript, and a basic understanding of HTML and Web technologies.

Objectives

  • Understand the basics of the Groovy language
  • Explore Groovy's power features
  • Learn about the background of Grails
  • Discover the possibilities with Grails' hibernate-powered Object Role Modeling layer
  • Learn about Grails' model-view-controller components
  • Understand how to integrate Grails with existing Java technology components and services

Features of This Course:

  • Attendees will receive printed copies of instructor slides
  • Instructor will be available to answer questions immediately following the course

Job Roles This Course Is Applicable To

  • Java technology developers interested in the dynamic language landscape, looking to explore the possibilities that powerful dynamic languages like Groovy offer.

Using the Power of JRuby and Rails to Develop Robust Applications

Instructor: Sang Shin
Course Level: Beginning to Intermediate
Course Length: Half Day, Afternoon

Course Description
Ruby on Rails is gaining popularity among developers and deployers of Web applications, and for good reasons. Ruby is a fun programming language and a well-thought-out Web application framework based on development principles that enable an agile yet practical development environment. JRuby on Rails provides another benefit by leveraging the stability, reliability, and scalability of the Java platform. This course briefly covers the interesting language characteristics of Ruby such as meta-programming, blocks, and closures. The rest of the course is devoted to learning Rails framework: Active Record, Action controller, Action View, testing, REST support, Ajax, and finally deployment options as time permits. This course is based on the "Ruby/JRuby/Rails Programming (with Passion!)" online course, which can be viewed at www.javapassion.com/rubyonrails/

Course Approach
The instructor explains the concept of each topic, and then provides a demonstration emphasizing the key points. The course also includes a brief question and answer session. Attendees are welcome to bring their own laptops to try the demos themselves during the course.

Content

  • Ruby language basics: symbol, metaprogramming, blocks, closure
  • Building a simple Rails application step by step
  • Environment, rake, generator, Rails console, migration
  • Active Record, ActionController, and ActionView
  • Ajax
  • Testing
  • REST support
  • Deployment

Prerequisites
Some Web application development would be useful but not required.

Objectives
Upon completion of this course, attendees should be able to build reasonably sophisticated Rails application.

Features of This Course

  • Code reviewed and demonstrated by the instructor will be provided on the instructor's Website (www.javapassion.com/courses/javaone2008.html) before, during, and after the course.
  • Attendees will receive printed copies of instructor slides
  • Instructor will be available to answer questions immediately following the course

Job Roles This Course Is Applicable To

  • Web application developers

Web 2.0: Building Dynamic Websites with Ajax and the Dojo Toolkit

Instructor: Neil Roberts
Course Level: Intermediate
Course Length: Half Day, Morning

Course Description
This course provides the attendees with the skills necessary to build rich, interactive Web applications using Ajax, Asynchronous JavaScript, and XML technologies. Topics covered include the popular the Dojo toolkit, which has Ajax components to simplify the creation of rich Web applications. The Dojo toolkit provides many UI components including list and tree pickers, tabbed panes, animated buttons, rich text editing, date and color pickers, and more.

Course Approach
The instructor highlights, demonstrates, and discusses concepts and source code related to the development of modern dynamic Web pages. The demos for this course feature the NetBeans integrated development environment.

Content:
Introduction to Dojo

  • Major components and a broad overview of capabilities
  • Getting started: Dojo configuration and setup
  • Dojo code structure
  • API documentation and Dojo Book
  • SitePen's Dojo Toolbox
Dojo fundamentals
  • Dojo's package system
  • Base tools (dojo.trim, etc.)
  • Project configuration
Document Object Model (DOM) with Dojo
  • Dojo's DOM APIs
  • dojo.attr
  • dojo.place
  • dojo.style
  • dojo.html
  • dojo.query
  • dojo.behavior
Events with Dojo
  • Using callbacks in Dojo
  • Event listeners with dojo.connect
Intro to Ajax
  • Ajax with Dojo
  • Dojo's Ajax APIs
  • Data serialization
  • Deferred use in Dojo
Dijit: the Dojo Widget System
  • What is a Dijit?
  • Dijit sections
  • Layout widgets
  • Form widgets
  • Editor
  • Tree
  • Dojo data
Overview of advanced topics
  • Unit testing in Dojo
  • Using the Dojo Objective Harness (DOH) for unit testing
  • Testing methods
  • What's in DojoX
  • GFX
  • Charting
  • Grid

Prerequisites
Attendees must have previous Java technology programming experience.

Objectives
Upon completion of this course, attendees should be able to create Web applications utilizing Ajax. They will also be able to integrate the Dojo toolkit Web components into their Web pages.

Features of This Course

  • Code reviewed and demonstrated by the instructor will be available for download upon completion of the class
  • Attendees will receive printed copies of instructor slides
  • Material will be presented by an Oracle-certified Java technology instructor
  • Instructor will be available to answer questions immediately following the course

Job Roles This Course Is Applicable To

  • Java technology Web application developers