HARTMANN software group

Fast Track to Spring Framework 3 and Hibernate Training in Erfurt, Germany

Enroll in or hire us to teach our Fast Track to Spring Framework 3 and Hibernate class in Erfurt, Germany by calling us @303.377.6176. Like all HSG classes, Fast Track to Spring Framework 3 and Hibernate may be offered either onsite or via instructor led virtual training. Consider looking at our public training schedule to see if it is scheduled: Public Training Classes
Provided there are enough attendees, Fast Track to Spring Framework 3 and Hibernate may be taught at one of our local training facilities.
We offer private customized training for groups of 3 or more attendees.
get pricing information

Course Description

  
This is a demanding and full 5-day course that covers the Spring 3.0 and Hibernate 3 technologies. It includes a focused coverage of the most useful Spring technologies, including the Spring core, Database Access, and Transaction support. The Hibernate material covers all basic areas of Hibernate as well as some advanced topics. The course starts with a fairly comprehensive coverage of the Core features of Spring, including fairly detailed explanations of the motivation behind Spring, Dependency Inversion and Dependency Injection (IoC). It includes coverage of all the basic capabilities, including the various annotation-based configuration options. The data access sections start with coverage of using the Jdbc Template and DaoSupport classes, as well as configuring DataSources. The course then moves on to the basics of Hibernate and mapping classes, then covers Spring / Hibernate integration â?? mostly using the Hibernate 3 getCurrentSession() support and Dependency Injection of a Session to build Spring-free DAOs. The transaction section is fairly straightforward, and covers the use of Springâ??s @Transactional annotation and the XML tx namespace configuration as well as integration with Hibernate
Course Length: 5 Days
Course Tuition: $2090 (US)

Prerequisites
A good working knowledge of basic Java programming, interfaces, and JDBC.

Course Outline

  

Introduction to Spring
The Challenge of Enterprise Applications
Shortcomings of Java/Java EE
What is Spring?
The Spring Modules
The Spring Distribution
Spring Introduction
Managing Beans
A Basic Spring Application
Some Bean Classes
Configuration Metadata
Declaring Beans
The Spring Container
Working with Spring
Why Bother?
Some BeanFactory Methods
Dependencies and Dependency Injection
Dependencies Between Objects
Dependency Inversion Principal
Dependency Injection (DI) in Spring
Dependency Injection Configuration
Advantages of Dependency Injection
Dependency Injection Reduces Coupling

More about Bean Properties
Working with Properties
Configuring Value Based Properties
Using Value Based Properties
Property Conversions
Constructor Injections
Constructor Argument Resolution
Setter Injection vs. Constructor Injection
Collection Valued Properties
Working with Collections
Configuring and Properties
Configuring Collections of Bean References
Map Valued Properties
java.util.Properties Valued Properties
Additional Capabilities
Factory Methods
Instance Factory Methods
Bean Aliases
Bean Definition Inheritance
Autowiring
Autowiring byType
Pros and Cons of Autowiring
To Autowire or Not to Autowire

The Spring Container and API
ApplicationContext
Fast Track to Spring®3
and Hibernate
Fast Track to Spring 3 and Hibernate
ApplicationContext Interface
ApplicationContext Implementations
Constructors
Using an ApplicationContext
Spring Resource Access
Built-in Resource Implementations
Bean Scope and Lifecycle
Bean Scope
Specifying Bean Scope
Inner Beans
Compound Names
Depends On
Bean Creation Lifecycle
Bean Creation Lifecycle Details
Using the Lifecycle Interfaces for Beans
Bean Destruction Lifecycle
BeanPostProcessor
@PostConstruct and @PreDestroy
Event Handling
MessageSources
Issues with Messages
Resource Bundles
Defining Resource Bundles
Using Resource Bundles and MessageSource
Localization/Internationalization
Paramaterizing Messages
Annotation Driven Configuration
Annotations in Spring
Enabling Spring Annotations
@Component and Auto-Detecting Beans
DI Using @Resource
Complete Declarations Using Annotations
Other Stereotype Annotations
@Resource – Additional Uses
@AutoWired
Qualifiers
Lifecycle Annotations
XML Config – Annotations and Scanning
Annotation Configuration – Pro/Con
A Note on the XML Configuration
A Brief Note on Annotations
Other Capabilities
SpEL – Spring Expression Language
Other SpEL Capabilities
Validation
Using Validation
Configuring Validation
Validation Constraints
Additional Capabilities

Database Access with Spring
Issues with JDBC
Problems Using JDBC Directly
Let’s Review Some Simple JDBC Usage
Simple Query on the Database
Problems with the Previous Approach
Spring Support for the DAO Pattern
Spring DAO Support
The Spring Database API
The JdbcTemplate Class
The JdbcDaoSupport Class
DataSources
Spring Jdbc Exception Hierarchy
DAO Based on Spring Classes
Configuring a DataSource
Looking up a DataSource in JNDI
Building a DAO without the Support Class
Queries and Updates
Querying with JdbcTemplate
Mapping Result Rows to Objects
Defining a RowMapper Class
Inserting/Updating
Other Kinds of Query Methods
The SimpleJdbcTemplate
The SimpleJdbcTemplate Class

Introduction to Hibernate
Hibernate Overview
The Issues with Persistence Layers
Object-Relational Mapping (ORM) Issues
Issues with JDBC Alone
Hibernate Benefits
Hibernate Environments
Hibernate Architecture
More Detailed Architecture
Using Hibernate
Acquiring Hibernate
Configuring Hibernate
Fast Track to Spring 3 and Hibernate
Hibernate.cfg.xml Elements
SessionFactory Configuration
The Configuration Class
The SessionFactory Interface
SessionFactory API
The Session Interface
Sessions and Transactions
Mapping a Simple Class
Persistent Entity Classes
Persistent Classes
The Event Class
The id Property
The Hibernate Mapping File
The Element
The Element
The EVENTS Table
Mapping the id Property with
More About Primary Keys
Generating the id Value
Mapping Properties with
Hibernate Mapping Types
Common Hibernate Type Mappings
Field Access or Property Access
The Mapping File
Hibernate Sessions
The Session Interface
Retrieving Persistent Objects
Logging
Hibernate.show_sql
Simple Logging Façade for Java-SLF4J
Apache Log4J
Hibernate log4j.properties file
The log4j.properties file
Modifying log4j.properties for Hibernate
Hibernate Logging Categories

Spring / Hibernate Integration
Contextual Sessions
Session Propagation
First-Acquiring a SessionFactory Instance
Contextual Session
Using Contextual Sessions
What is the “Current” Context
Contextual Session Scope
Spring/Hibernate Integration
Spring Support for Hibernate
LocalSessionFactoryBean
Spring Configuration of SessionFactory
Spring Free DAO
HibernateDAOSupport
Querying with HibernateTemplate

Updates and Queries
Inserting and Updating
Inserting Instances
Modifying a Persistent Instance
Deleting an Instance
Querying and Hibernate Query Language (HQL)
HQL Basics
Executing a Query
Other Common Query Methods
Where Clause / Restriction
HQL Operators and Expressions
Query Parameters
Using Query Parameters
Named Queries
Projection Queries
Aggregate Functions

Transactions
Hibernate Transactions
Transaction Lifecycle
Hibernate and Transactions
Hibernate Transaction Demarcation
Working with Transactions
The Hibernate Transaction API
Working in a Managed Environment
Sprig Transaction Management
Transaction Managers
Configuring Transaction Managers
Spring Transactions and Hibernate
JTA Transaction Manager
Spring Declarative Transaction Management
Transactional Scope
Transaction Attributes for Propagation
MANDATORY
NESTED
NEVER
NOT_SUPPORTED
REQUIRED
REQUIRES_NEW
SUPPORTS
Fast Track to Spring 3 and Hibernate
Transaction Attributes
Rolling Back and Exceptions
Spring Proxies and Direct Invocation
[Optional] Spring Transactions - XML Configuration

Lifecycle
The Persistence Lifecycle
Hibernate Object States
Transient and Persistent State
Detached and Removed State
Hibernate Object States and Transitions
The Persistence Context
The Persistence Context as Cache
Synchronization to the Database
Flushing the Session
Persistence Context and Object Identity
Yes, It’s Complicated
Versioning and Optimistic Locking
Using a Detached Instance
Optimistic Locking and Versioning
Version Property in Java Class
Version Element in Mapping File
Automatic Version Maintenance
Updating a Detached Instance
Session.saveOrUpdate()
The unsaved-value Attribute
Locking Objects
Common Lock Modes

Relationships
Object Relationships
Characteristics of Relationships
Directionality
Collections of Value Objects
Modeling a Set of Values
Mapping the Set of Values
Using a Set of Values
More on the Java Collection Type
Using the Java Collection Types
Modeling a List of Values
Mapping a List of Values
Sorted and Ordered Collections
Collections of Components
Mapping Collections of Components
Mapping Entity Relationships
Inheritance
Entity Inheritance
Details of Entity Inheritance
Single-Table Strategy
Class Definitions for Single-Table
Mapping for Single-Table
Sample Table Entries
Single-Table: Pros and Cons
Table per Subclass (Joined Subclass)
Mapping for Table per Subclass
Joined: Pros and Cons
Table per Concrete Class

Spring and the Web
Spring and Java EE
Java EE Web Applications
Web Application Structure
Web Application Components
ApplicationContext and Web Apps
Configuring ContextLoaderListener
Using the Application Context

Additional Hibernate Topics
equals() and hashCode()
Defining equals() and hashCode()
Redefining equals()
Caching
Second-Level Cache
Data Appropriate for Caching
Cache Providers
Configuring Caching
Concurrency Strategies
Managing the Caches
Design Considerations
Long Conversations
Session-Per-Conversation
Problems with Web Applications
Open Session In View Pattern
Query Efficiency Techniques
Beware of n+1 Select Issue
Prefetching Data in Batches
Data Access Object (DAO)

Hibernate and the Java Persistence API (JPA)
JPA Persistence API Overview
Java Persistence Environments
Hibernate and JPA
Mapping a Simple Class
Entity Classes
Event Entity Mapped with JPA
Fast Track to Spring 3 and Hibernate
javax.persistence.Entity Annotation
The Event Class
The Id Property
Mapping Properties
Basic Mapping Types
Entity Manager and Persistence Context
The Entity Manager & Persistence Context
Persistence Unit
persistence.xml
Acquiring an EntityManager
Working with Transactions
Retrieving Persistent Objects
Inserts and Queries
Persisting a New Entity
Java Persistence Query Language
Executing a Query
WHERE Clause and Query Parameters
Named Queries
Version Property in Java Class
Versioned Class and Detached Objects
Relationships
JPA Support for Relationships
Mapping the Many-To-One Relationship
Mapping the One-To-Many Relationship
Loading and Cascading
Queries Across Relationships
Inheritance
Entity Definitions for Single-Table
Entity Definitions for Joined
Recap
Resources for More Learning

Course Directory [training on all levels]

Technical Training Courses
Software engineer/architect, System Admin ... Welcome!
Business Training Courses
Project Managers, Business Analysts, Paralegals ... Welcome!
Upcoming Classes
Gain insight and ideas from students with different perspectives and experiences.

Software Design/Development and System Integration Uses & Stats

Software Design/Development and System Integration is Used For:
Android & IOS Development Software Products Video Games Desktop GUI's
Difficulty
Popularity
Year Created
1995
Pros

Most Commonly Used: 
According to Oracle, three billion devices run on Java.  And, because of its real-world applications, it consistently ranks at the top of the TIOBE Programming Community Index. 

Great Career Choice: 
Some of the fastest-growing salaries in the U.S. in 2018 are for Java developers.  (Glassdoor)  

Android Apps Development:
Developers predominatly use their Java skills in building apps for Google's Android. The Android platform is the number one mobile paltform in the world

It Can Run On Any Platform:
Java can compile on Windows and run the same compiled file on Linux, Windows and Mac.

Great Supporting IDE's:
Over the years, coding in Java has become simpler with the introduction of open source development tools, i.e. Eclipse and NetBeans that use Java capabilities for debugging.  
 
Cons

Uses a Lot of Memory:
Performance can be significantly slower with Java and more memory-consuming than natively compiled languages such as C or C++.

Difficulty in Learning: 
Learning Java can be a bit challenging if you are a beginner.  However, once you get the hang of Object Oriented Programming and a decent grasp of the syntax, you will be well on your way.

Slow Start Up Times:
There is quite a bit of one-time initialization done by JDK classes before compiling as well as loading classes and verification (making sure code doesn't do evil things, all of which takes longer that some other languages such as C. 

Verbose and Complex Code:
Long, over-complicated sentences make code less readable and scannable. Compare to let's say Python, we can see how clear Python code appears: It doesn’t require semicolons; uses “and,” “or,” and “not” as operators instead of Java’s “&&,” “||,” and “!”; and generally has fewer bells and whistles such as parentheses or curly braces.

Commercial License Cost:
Companies have to prepare for the changes that Oracle will institute in 2019 . Today, the current version of Java is free and available for redistribution for general purpose computing. However, If you are a DEVELOPER, Oracle recommends you review the roadmap information for Java SE 8 and beyond and take appropriate action depending on the type of application you develop and your distribution mode.
Software Design/Development and System Integration Job Market
Average Salary
$102,000
Job Count
26,856
Top Job Locations

New York City 
San Jose
Washington D.C, 
Complimentary Skills to have along with Software Design/Development and System Integration

- If you are an experienced Java developer, learning a complimentary language to Java should come much more naturally.  As an example JetBrains recently created the Kotlin programming language which is officially supported by Google for mobile development.  Kotlin compiles to Java bytecode and runs on the JVM; it's purported to address many of Java's shortcomings...

Interesting Reads Take a class with us and receive a book of your choosing for 50% off MSRP.