Visão Geral

Curso Spring Hibernate , Hibernate e Spring são estruturas Java de software livre que simplificam o desenvolvimento de aplicativos Java/JEE, desde aplicativos simples e independentes executados em uma única JVM até aplicativos corporativos complexos executados em servidores de aplicativos completos. O Hibernate e o Spring permitem que os desenvolvedores produzam código escalável, confiável e eficaz. Ambos os frameworks suportam configuração declarativa e trabalham com um modelo de programação POJO (Plain Old Java Object) (discutido posteriormente neste artigo), minimizando a dependência do código do aplicativo nos frameworks e tornando o desenvolvimento mais produtivo e portátil.

Publico Alvo

• Crie aplicativos da Web Java básicos
• Compreensão básica dos conceitos de banco de dados relacional e JDBC

Materiais

Conteúdo Programatico

Introduction to Hibernate

1. Issues with Persistence layers and Object-Relational Mapping (ORM)
2. Hibernate Overview and Benefits
3. Hibernate architecture overview
4. POJO (Plain Old Java Object) Based Mapping

Getting started with Hibernate quickly

1. Overview of the Hibernate distribution
2. Configuring Hibernate
3. hibernate.cfg.xml file
4. SessionFactory configuration
5. Connection properties, Database dialect
6. Configuration class, Session Interface
7. Hello World Program for Hibernate
8. Mapping a Class
9. Persistent Entity Class, Hibernate Mapping
10. File, Mapping the Entity Class
11. Primary keys: Id property, Generated Id
12. Hibernate Type System
13. Working with sessions and Persistent Objects
14. Logging - log4j Overview and configuration for Hibernate

Querying

1. Inserting and Updating Entities
2. HQL - Hibernate Query Language Overview
3. The Query Interface
4. Creating and working with queries
5. Named Queries, Projection Queries, Aggregate Queries

The Persistence Lifecycle

1. Transaction Overview and Transactions in Hibernate
2. Hibernate Transaction API (in Managed and Non-managed Environments)
3. The lifecycle of managed objects
4. Persistent, transient, and detached objects
5. The Persistence (Session) Context (Lifespan, Relation to Managed Objects, Propagation)
6. Contextual Sessions
7. Synchronization to the Database
8. The Session as cache

Optimistic Locking / Versioning

1. Detached Objects and Optimistic Locking
2. Versioning overview and Using Versioning
3. Locking Objects

Relationships

1. Object Relationship Overview
2. Mapping Collections of Value Objects
3. Entity Relationships: 1-N, N-1, N-N, 1-1
4. Mapping Entity Relationships
5. Uni and Bi-directional Relationships
6. The Relationship "inverse"
7. Cascading Over Relationships
8. Queries Across Relationships (Lazy and Eager)

Inheritance Mapping

1. Entity Inheritance with Hibernate
2. Table-per-class mapping
3. Table per Subclass mapping
4. Table per Concrete Class mapping

Additional Querying Capabilities

1. Projection Queries, Aggregate queries
2. Bulk updates and deletes
3. Native SQL Queries
4. Query Filters

The Criteria API

1. Overview of the Criteria API
2. Working Querying with the Criteria API
3. Query by Example

Hibernate and Java Persistence / EJB 3

1. Overview of Java Persistence / EJB 3
2. Relationship between Java Persistence and Hibernate
3. Overview of Annotations
4. Mapping Entities with Hibernate Annotations
5. The EntityManager, Persistence Context and Persistence Unit
6. Working with Transactions - EntityTransaction, Managed, and Unmanaged Environments
7. Inserts and Updates
8. JPQL - Java Persistence Query Language
9. Versioning
10. Relationships

Advanced Topics

1. Components and Multi-Table Mapping
2. equals() and hashCode()
3. Caching and Efficiency
4. Design Considerations

TRACK II :

Overview

1. Java EE: The Good, The Bad, and the Ugly
2. Enter the Framework
3. Spring Modules
4. Controlling Object Creation
5. Web Applications
6. Persistence Support
7. Aspect-Oriented Programming
8. Integrating Other Frameworks

Core Techniques

1. Component-Based Software
2. JavaBeans, Reconsidered
3. The Factory Pattern
4. Inversion of Control
5. XML View: Declaring Beans
6. Java View: Using Beans
7. Singletons and Prototypes
8. Initializing Bean State

Dependency Injection

1. Complex Systems
2. Assembling Object Graphs
3. Dependency Injection
4. Single and Multiple Relationships
5. The Utility Schema
6. Autowiring
7. Bean Aliases
8. Order of Instantiation

Validation

1. Validators
2. The Errors Object
3. ValidationUtils
4. Error Messages and Localization
5. Nested Property Paths

The Web Module

1. Servlets and JSPs: What's Missing
2. The MVC Pattern
3. The Front Controller Pattern
4. DispatcherServlet
5. A Request/Response Cycle
6. The Strategy Pattern
7. JavaBeans as Web Components
8. Web Application Contexts
9. Handler Mappings
10. Creating a Model
11. View Resolvers

Customizing Spring MVC

1. HandlerMapping Options
2. ViewResolver Options
3. Chaining View Resolvers
4. Triggering Redirects

Controllers and Commands

1. Working with Forms
2. Command Objects
3. The Template Method Pattern
4. Command Controllers
5. Data Binding
6. MultiActionController
7. Scope and Granularity of Command Objects

Web Binding and Validation

1. Property Editors
2. Custom Property Editors
3. Registrars
4. Validating Form Input

Form Controllers

1. Form Controllers
2. AbstractFormController
3. SimpleFormController
4. Spring Custom Tags and Friends
5. Reporting Errors
6. Refining the Handling Cycle
7. The Intercepting Filter Pattern
8. Exception Handling
9. Interceptors
10. The Decorator Pattern
11. Context and Lifecycle
12. Awareness Interfaces
13. Support and Utility Classes
14. Death By XML

The Persistence Tier

1. The DAO Pattern
2. The DaoSupport Hierarchy
3. The DataAccessException Hierarchy
4. JDBC DAOs
5. JdbcTemplate and RowMapper
6. Object/Relational Mapping
7. Hibernate DAOs
8. Transaction Control
9. AOP vs. Annotations