Java Frameworks Architect - Struts, Spring, Hibernate

This couse teaches students three major Java Application Frameworks

• Struts
• Spring
• Hibernate

This course will teach students how to use Java Struts as a framework to develop web applications that follow the Model/View/Controller design pattern. The topics cover the components of Struts that are available from the Jakarta project of the Apache Foundation. The course illustrates what the components provide and use of them.

This course enables the experienced Java developer to use the Spring application framework to manage objects in a lightweight "IoC" (inversion-of-control) container. Spring is a far-reaching framework that aims to facilitate all sorts of Java development, including every level of multi-tier distributed systems. Here we focus on the "Core" module of the framework, developing facility in instantiating, configuring, and assembling Spring beans for various purposes.

This course teaches students the most popular object-relational mapping framework for Java environments. Object relational mapping in large enterprise applications is difficult. The task is so difficult that the problem of storing and retrieving objects to a relational database has its own name – impedance mismatch. In this class, students learn object-relational mapping concepts and the various issues and options available in Java to address object persistence. With these fundamentals, the course then explores the basics of Hibernate object persistence and configuration. It also digs into the details of Hibernate mapping, queries, transactions, and concurrency. After taking this class, developers will be able to build faster, more flexible and easier to maintain application persistence layers and overcome impedance mismatch with the Hibernate framework.

Duration : 80 Hrs | 40 Days | 6 - 8 Weeks

• What is Struts?
• Model 1 Design Pattern
• Model 2 / MVC Design Pattern
• Implementing MVC with a Framework
• The Struts Framework
• Basic Struts Components
• Struts Documentation
• A Struts-Based Application: Logon

• Stars Information Application
• List Stars Flow
• Display Star Flow
• ActionServlet: the Controller
• struts-config.xml
• ActionForm: Form State
• The execute Method of StarsListAction
• The execute Method of StarsDisplayAction
• Directing Processing Flow with an ActionForward
• Building a View with Tags
• Review: Flow through a Typical Struts-Based Application

• ActionServlet as a Controller
• RequestProcessor
• Developer Responsibilities
• Mapping
• Forwards
• Lifecycle of an ActionForm
• ActionForm Considerations
• The reset Method
• The validate Method

• The execute Method of Action
• execute() Method Considerations
• Handling an Error
• Threading Considerations
• Some Best Practices for Action
• More Best Practices for Action

• Command Pattern for Web Applications
• ActionServlet
• Action and Action Mappings
• Struts Configuration
• Selecting a Forward
• Global Forwards
• Declarative Exception Handling
• Global Exception Handlers

• Working with HTML Forms
• Action Forms, a/k/a Form Beans
• Relationship to Input
• Relationship to Actions
• Relationship to the Model
• Relationship to Output
• DynaActionForm and Map-Backed Forms
• Validation
• Coarse-Grained Form Beans

• Forwarding to a View
• Overview of Struts Tags
• Struts HTML Tags
• Form-Related Tags
• Dealing with URLs
• Using Error Tags
• Displaying Messages
• Struts Bean Tags
• Struts Logic Tags
• Some Struts View Best Practices

• I18N and L10N
• Resource Bundles
• Java's MessageFormat Class
• Internationalization in Struts
• I18N with Struts Tags
• I18N with JSTL tags
• I18N within Java Code

• Accessing Bean Properties
• DynaActionForm: A Configurable Form
• Indexed and Mapped Properties in a Form
• Using indexed='true'
• Preventing Duplicate Form Submits
• Using ForwardAction and IncludeAction
• DispatchAction
• LookupDispatchAction
• Implementing a LookupDispatchAction

• Building View Components
• Struts Tag Libraries
• Attributes and Struts Expressions
• Building Forms
• Forms
• Forms and Form Beans
• Scope and Duration of Form Data
• Managing Hyperlinks
• Error Messages
• Logic Tags

• JSTL Overview
• JSP Expression Language
• Core Tags
• Formatting Tags
• SQL Tags
• XML Tags
• Mixing JSTL, EL, Scripts and Actions
• Indexed Properties and Struts HTML Forms

• Struts Configuration in Depth
• Wildcards
• Extensions
• The Configuration Object Model
• Subclasses
• Plug-Ins
• Integrating Other Frameworks
• Role-Based Security
• Chaining Actions
• The ComposableRequestProcessor Class
• Configuring Command Chains
• Modules

• Global Objects
• Specialized Struts Actions
• The Utility Package
• The Commons BeanUtils Class
• Form Beans as Adapters to the Business Tier
• Reusing Validation Rules
• Graceful Validation

• Consistent Look and Feel
• Reusable Layouts and Content
• The Tiles Framework
• Instantiating Layouts
• Body-Wrap Insertions
• Tiles and Stylesheets
• Working with Tiles Attributes
• The Tiles Context
• Definitions
• Aggregation and Inheritance
• The Tiles Plug-In
• Forwarding to Definitions
• Performance Considerations

• Error Handling Options with Struts
• Documenting Errors with ActionMessage
• JSP Error Pages
• Declarative Java Exception Handling
• Logging in Struts

• Validator Overview
• Validator Requirements
• Configuring Validator Rules
• Struts Validators
• Configuring the Struts Validators
• Configuring Form Validation - global and formset
• Configuring Form Validation - form and field
• Configuring Form Validation - arg
• Configuring Form Validation - var
• Validation with Regular Expressions
• ValidatorForm verses ValidatorActionForm
• Implementing a Validator Method
• Other Validator Implications

• Tiles Overview
• Building a Tiles Template
• Basic Tiles Example
• Tiles Definitions
• Additional Options with Definitions
• Placing Definitions in a Configuration File
• Using the put Tag
• Enabling the Tiles Plug-In
• Using Tiles

• Why Nested Tags?
• Using Nested Tags
• Parent and Root Tags

• Java EE: The Good, The Bad, and the Ugly
• Enter the Framework
• Spring Value Proposition
• The Spring Container
• Web Applications
• Persistence Support
• Aspect-Oriented Programming
• The Java EE Module(s)
• Integrating Other Frameworks

• JavaBeans, Reconsidered
• The Factory Pattern
• Inversion of Control
• XML View: Declaring Beans
• Java View: Using Beans
• Singletons and Prototypes

• Configuring Through Properties
• Configuration Namespaces
• The p: Notation
• Bean (Configuration) Inheritance
• Configuring Through Constructors
• Bean Post-Processors
• Lifecycle Hooks
• Integrating Existing Factory Code

• Complex Systems
• Assembling Object Graphs
• Dependency Injection
• Single and Multiple Relationships
• The Utility Schema
• Bean Aliases
• Inner Beans
• Autowiring
• Auto-Detecting Beans
• @Autowired Properties
• Best Practices with Spring 2.5 Annotations

• Collections and Maps
• Support for Generics
• The Spring Utility Schema (util:)
• Autowiring to Multiple Beans
• Order of Instantiation
• Bean Factory vs. Application Context

• Validators
• The Errors Object
• ValidationUtils
• Error Messages and Localization
• Nested Property Paths

• Servlets and JSPs: What's Missing
• The MVC Pattern
• The Front Controller Pattern
• DispatcherServlet
• A Request/Response Cycle
• The Strategy Pattern
• JavaBeans as Web Components
• Web Application Contexts
• Handler Mappings
• "Creating" a Model
• View Resolvers

• HandlerMapping Options
• ViewResolver Options
• Chaining View Resolvers
• Triggering Redirects

• Working with Forms
• Command Objects
• The Template Method Pattern
• Command Controllers
• Data Binding
• MultiActionController
• Scope and Granularity of Command Objects
• Auto-Detecting @Controllers
• The @RequestMapping Annotation

• Property Editors
• Custom Property Editors
• Registrars
• Validating Form Input

• Form Controllers
• AbstractFormController
• SimpleFormController
• Spring Custom Tags
• Forms and Friends
• Form : Errors
• Reporting Errors
• @RequestMapping for Form Controllers
• @RequestMapping for Multi-Action Controllers
• Other Handler Annotations
• Controller vs. @Controller

• The Intercepting Filter Pattern
• Exception Handling
• Interceptors
• The Decorator Pattern
• Context and Lifecycle
• Awareness Interfaces
• Support and Utility Classes
• "Death By XML"

• The DAO Pattern
• The DaoSupport Hierarchy
• The DataAccessException Hierarchy
• JDBC DAOs
• JdbcTemplate and RowMapper

• Object/Relational Mapping
• The Java Persistence API
• Blending Spring and JPA
• Entity Manager Factories
• Configuration Issues

• Transaction Managers
• Transaction Advice
• AOP vs. Annotations
• JDBC Transaction Manager
• JPA Transaction Manager

• Object Persistence
• Object/Relational Paradigms
• Impedance Mismatch
• Object Relational Mapping ()ORM)
• Persistent Framework
• Hibernate
• Java ORM/Persistent Frameworks

• Hibernate Architecture and PI
• Hibernate Installation/Setup
• Configuration
• Configuration Properties
• Mapping Files
• Persistent Classes
• Persistent Classes
• POJOs
• JavaBeans
• Basic Mapping
• Class to Table Mappings
• Property Mapping
• Identifiers
• Generators
• Natural Keys
• Identifier Exposure
• Quoting SQL Tables and Columns

• Entity Lifecycle
• Transient Stat
• Persistent State
• Persistent Object Updates and Automatic Dirty Checking
• Detached State
• Deleted
• Object Identifiers Revisited
• Merge

• Domain Model
• Entities and Values
• Components

• Many-to-one
• Bidirectional Many-to-one
• Other Collections
• Many-to-one List
• Many-to-one Map
• Many-to-one Bag
• Many-to-one Array

• One-to-one
• Bidirectional One-to-one
• Many-to-many
• Bidirectional Many-to-many
• Many-to-many Identifier Bag

• Collections of Value Types
• Collections of Components
• Sorting Collections

• Inheritance Mapping Strategies
• Table per concrete class
• Table per subclass
• Table per hierarchy
• Inheritance Mapping Pros/Cons
• Polymorphism
• Table per concrete class with unions
• Choosing an Inheritance Strategy

• Transitive Persistence
• Lazy Loading
• Proxies
• Eager Loading
• What's a Proxy?
• Detached Objects and Proxies
• Polymorphic Associations Revisited

• Custom Mapping Types
• UserType
• Enumerations

• Hibernate Object Fetching Options
• Hibernate Query
• HQL
• HQL Parameters
• Named Queries
• Native SQL

• Hibernate Criteria
• Restrictions
• Query By Example
• Scrolling
• Pagination
• Query Hints
• Query Option Pros/Cons

• The Java Transaction
• Hibernate Transaction Configuration
• Hibernate Transaction API
• Concurrency
• Isolation Levels
• Optimistic Locking
• Versioning
• Optimistic Locking without Versioning
• Pessimistic Locking

• N + 1 Selects
• Fetching Strategies
• Join Fetching
• Subselect Fetching
• Batch Fetching
• Queries and Fetching Strategies
• Cartesian Product Problem

• The Promise of Cache
• Hibernate Caching Architecture
• First Level Cache
• Second Level Cache
• Cache Concurrency
• Configuring Second Level Cache
• Cache Regions
• Eviction

• Metadata
• Annotations Pros/Cons
• Configuring Hibernate Annotations
• EJB3/JPA Annotations
• Entity Annotations
• Embedded Object (Component) Annotations
• Inheritance Annotation

• Java Servlet and JSP developers who need to use Struts as a framework for MVC Web Application Development
• Java programmers with a need to understand the Hibernate framework and API
• Developers who want to learn Spring Framework

• A solid understanding of Java is required
• Java Servlet and JSP programming
• Basic understanding of HTML and XML
• Basic understanding of relational databases and SQL