Hibernate is an object-relational mapping framework that allows for object persistence and retrieval. It provides features such as mapping Java objects to database tables, lazy loading of collections, polymorphic queries, and transaction management. The document provides examples of configuring Hibernate, persisting and retrieving objects, and using named parameters in queries. It also outlines exercises for setting up a sample project using Hibernate with the Location domain object and its mapping.
The document discusses using Hibernate, an object-relational mapping framework, to provide object persistence and retrieval by mapping Java objects to database tables. It explains what Hibernate does, its features like object-relational mapping and transaction management, and provides examples of persisting and retrieving objects using Hibernate's API. The document also shows how to configure a Hibernate project and map classes and associations between objects and database tables.
Hibernate is an object-relational mapping tool for Java that allows developers to persist Java objects to a relational database in a transparent way. It provides transparent persistence without needing to flatten objects or write database specific code. Hibernate uses an object-oriented query language that closely resembles SQL to retrieve and manipulate persisted objects.
Hibernate is an object-relational mapping tool that allows Java objects to be persisted to a relational database. It provides transparent persistence by handling all database operations like insert, update, delete, and retrieval. Hibernate sits between the Java application and database, mapping objects to database tables and allowing developers to work with objects rather than directly with SQL statements. Configuration files define the mappings between Java classes and database tables. Hibernate uses these mappings to automatically generate SQL to load and store objects.
This document introduces GradleFx, a Flex build tool that uses Gradle. It discusses key features of GradleFx such as supporting SWC, SWF, and AIR compilation; tasks for cleaning, compiling, packaging, and testing; and conventions for project structure and dependencies. Advanced topics covered include compiler options, JVM arguments, dependency configurations, and additional steps for AIR projects and FlexUnit testing. An example Gradle build script is provided.
09.Local Database Files and Storage on WPNguyen Tuan
This document provides an overview of local data storage options for Windows apps, including isolated storage, file I/O, settings storage, SQLite database, and external storage. It discusses using the local, installation, and shared application folders to store files. It also covers serialization, file associations, and APIs for reading and writing files like IsolatedStorageFile and StorageFile. The document demonstrates saving data to isolated storage, settings, and a SQLite database and loading data from these sources. It recommends SQLite as a local database option and provides instructions for adding SQLite support to a project.
Hibernate is an object-relational mapping tool that allows developers to interact with a relational database (such as MySQL) using object-oriented programming. It provides functionality for persisting Java objects to tables in a database and querying those objects using HQL or native SQL. Hibernate utilizes XML mapping files or annotations to define how Java classes map to database tables. A typical Hibernate application includes entity classes that represent database tables, configuration files, and a controller class to manage persistence operations.
The document discusses using Hibernate, an object-relational mapping framework, to provide object persistence and retrieval by mapping Java objects to database tables. It explains what Hibernate does, its features like object-relational mapping and transaction management, and provides examples of persisting and retrieving objects using Hibernate's API. The document also shows how to configure a Hibernate project and map classes and associations between objects and database tables.
Hibernate is an object-relational mapping tool for Java that allows developers to persist Java objects to a relational database in a transparent way. It provides transparent persistence without needing to flatten objects or write database specific code. Hibernate uses an object-oriented query language that closely resembles SQL to retrieve and manipulate persisted objects.
Hibernate is an object-relational mapping tool that allows Java objects to be persisted to a relational database. It provides transparent persistence by handling all database operations like insert, update, delete, and retrieval. Hibernate sits between the Java application and database, mapping objects to database tables and allowing developers to work with objects rather than directly with SQL statements. Configuration files define the mappings between Java classes and database tables. Hibernate uses these mappings to automatically generate SQL to load and store objects.
This document introduces GradleFx, a Flex build tool that uses Gradle. It discusses key features of GradleFx such as supporting SWC, SWF, and AIR compilation; tasks for cleaning, compiling, packaging, and testing; and conventions for project structure and dependencies. Advanced topics covered include compiler options, JVM arguments, dependency configurations, and additional steps for AIR projects and FlexUnit testing. An example Gradle build script is provided.
09.Local Database Files and Storage on WPNguyen Tuan
This document provides an overview of local data storage options for Windows apps, including isolated storage, file I/O, settings storage, SQLite database, and external storage. It discusses using the local, installation, and shared application folders to store files. It also covers serialization, file associations, and APIs for reading and writing files like IsolatedStorageFile and StorageFile. The document demonstrates saving data to isolated storage, settings, and a SQLite database and loading data from these sources. It recommends SQLite as a local database option and provides instructions for adding SQLite support to a project.
Hibernate is an object-relational mapping tool that allows developers to interact with a relational database (such as MySQL) using object-oriented programming. It provides functionality for persisting Java objects to tables in a database and querying those objects using HQL or native SQL. Hibernate utilizes XML mapping files or annotations to define how Java classes map to database tables. A typical Hibernate application includes entity classes that represent database tables, configuration files, and a controller class to manage persistence operations.
Hibernate is an object-relational mapping tool that allows developers to interact with a relational database (such as MySQL) using object-oriented programming. It provides functionality for persisting Java objects to tables in a database and querying those objects using HQL or SQL. Hibernate utilizes XML mapping files or annotations to define how Java classes map to database tables. A typical Hibernate application includes entity classes, mapping files, configuration files, and a controller class to manage persistence operations.
DESIGNING A PERSISTENCE FRAMEWORK WITH PATTERNS.pptAntoJoseph36
The document discusses designing a persistence framework using patterns. It describes persistent objects that survive process termination and storage mechanisms like object and relational databases. A persistence framework provides functions to store/retrieve objects and commit/rollback transactions. Key concepts covered include mapping objects to tables, object identity, materialization/dematerialization, caches, and transactions. Common patterns used in persistence frameworks are also described, such as representing objects as tables, the database mapper pattern, template method for caching, and the state pattern for transaction management.
Hibernate is an object-relational mapping tool that allows Java objects to be persisted to a relational database transparently. It provides transparent persistence by mapping Java objects to database tables without requiring developers to write SQL or do object-relational impedance mismatch mapping manually. Hibernate uses an XML configuration file and mapping metadata to define how Java classes are mapped to database tables and columns. This allows Java objects to be treated as persistent domain models while Hibernate handles saving, updating, deleting and querying database data behind the scenes through its API.
This document provides an overview of Hibernate, an object-relational mapping tool. It explains that Hibernate maps database tables to Java classes and vice versa, allowing developers to work with objects rather than SQL. Key benefits include better application architecture through separation of concerns, reduced time spent on standard database operations, and access to advanced features like caching and transactions. The document also provides an example of how to define mappings between a Java class and database table and use Hibernate to save an object to the database.
Slides accompanying a presentation on Dropwizard I gave at the DevIgnition conference ( www.devignition.com ) on April 29, 2016. The sample code is on GitHub at https://github.com/sleberknight/dropwizard-devignition-2016
This document provides an overview of the key differences between Play Framework versions 1.0 and 2.1. It notes that Play 2.1 introduces support for Scala and Java, uses dynamic compilation via SBT, includes error reporting for JavaScript, and is designed for long browser connections. It also summarizes how to work with templates, HTML forms, databases, and JSON in Play 2.1 applications.
This document discusses several key questions to consider when creating an offline application, including what functionality should be available offline, how to store application data locally, and how to handle synchronization between offline and online data. It provides examples of different storage options for offline data, such as the Application Cache, Service Workers Cache API, web storage, web SQL, file system API, and IndexedDB. It also discusses approaches for resolving conflicts when synchronizing offline and online data, such as using timestamps or optimistic/pessimistic locking strategies. The document is an informative resource for developers building offline-capable web applications.
DWR, Hibernate and Dojo.E - A Tutorialjbarciauskas
This tutorial will walk you through the steps of creating a simple database-driven AJAX application using Direct Web Remoting (DWR) 2.0, Hibernate 3.0 and a new open source project from Nexaweb Technologies, dojo.E. dojo.E is an extensible markup processing engine that out-of-the-box will translate XML into dojo components.
Hibernate is an object-relational mapping tool that allows developers to work with relational data (like SQL databases) using object-oriented programming languages like Java. It eliminates manual data handling code by directly mapping Java objects to database tables. This reduces development time and effort. Hibernate configuration involves setting up XML mapping files that describe how Java classes and their fields are mapped to database tables and columns. It provides a simpler object-oriented approach for handling data persistence tasks versus direct SQL/JDBC coding.
The document discusses Android architecture components. It describes key components like Lifecycles, LiveData, ViewModel, Room, Navigation, Paging, ViewModel SavedState, and Data Binding. It also discusses using architecture components with the MVVM pattern and clean architecture, including layers for the data, presentation and domain. It provides examples of implementing use cases and repositories, and testing use cases. It emphasizes benefits like testable and collaborative code and outlines best practices like proof of concepts for new learning.
The document provides an overview of Hibernate, an object-relational mapping tool for Java. It discusses some typical problems with JDBC and how Hibernate addresses these issues. It then covers how to get started with Hibernate, including designing entities, mapping them to database tables, and writing data access code using Hibernate queries and sessions. The document also includes examples of mapping files, configuration files, build files, utility classes, and data access objects.
Introduction
Web Storage
WebSQL
IndexedDB
File System Access
Final Considerations
This presentation has been developed in the context of the Mobile Applications Development course, DISIM, University of L'Aquila (Italy), Spring 2015.
http://www.ivanomalavolta.com
The Past Year in Spring for Apache GeodeVMware Tanzu
The document provides an overview of developments in the Spring for Apache Geode project over the past year. It discusses improvements and new features for Spring Test, Spring Data, Spring Session, and Spring Boot integration with Apache Geode. Key updates include enhanced mocking support in Spring Test, transaction event publishing in Spring Data, disabling indexes for Spring Session, and examples of caching patterns and configurations using the Spring and Geode frameworks.
Hibernate provides object relational mapping and allows working with data at the object level rather than directly with SQL. It abstracts the underlying database, handles change detection and caching. The session factory handles connection pooling and caching of mappings. The session represents a unit of work and tracks changes to objects, flushing updates to the database at the end of the session. The first level cache tracks changes to objects within a session. Query caching caches query results to improve performance. The second level cache caches objects beyond a single session.
This document discusses dependency injection in Drupal 8. It begins by explaining the problems with Drupal 7 code, such as strong dependencies on globals and an inability to reuse or test code easily. It then introduces dependency injection as a design pattern that can help address these issues by reducing hard-coded dependencies. The document outlines how dependency injection works in Symfony and will work in Drupal 8 through the use of a service container that allows injecting dependencies into classes.
The document outlines an agenda for a Hibernate training that covers generator classes, SQL dialects, collection mapping, relationship mappings like one-to-one and many-to-one, cascade types, lazy loading, transactions, HQL, criteria queries, caching, and includes examples of creating a basic Hibernate project using annotations and performing CRUD operations.
This document provides an overview of key concepts for developing applications with Symfony2 including: setting up the framework, code flow, dependency injection, configuration, controllers, applications, Doctrine integration, caching, performance tips, asset management, testing, deployment, third party bundles, and resources for contributing to Symfony2. It discusses service definitions, controller choices, application choices, Doctrine examples, caching strategies, performance optimization techniques, testing approaches, deployment options, and how to work with third party bundles.
Hibernate is an object-relational mapping tool that allows developers to interact with a relational database (such as MySQL) using object-oriented programming. It provides functionality for persisting Java objects to tables in a database and querying those objects using HQL or SQL. Hibernate utilizes XML mapping files or annotations to define how Java classes map to database tables. A typical Hibernate application includes entity classes, mapping files, configuration files, and a controller class to manage persistence operations.
DESIGNING A PERSISTENCE FRAMEWORK WITH PATTERNS.pptAntoJoseph36
The document discusses designing a persistence framework using patterns. It describes persistent objects that survive process termination and storage mechanisms like object and relational databases. A persistence framework provides functions to store/retrieve objects and commit/rollback transactions. Key concepts covered include mapping objects to tables, object identity, materialization/dematerialization, caches, and transactions. Common patterns used in persistence frameworks are also described, such as representing objects as tables, the database mapper pattern, template method for caching, and the state pattern for transaction management.
Hibernate is an object-relational mapping tool that allows Java objects to be persisted to a relational database transparently. It provides transparent persistence by mapping Java objects to database tables without requiring developers to write SQL or do object-relational impedance mismatch mapping manually. Hibernate uses an XML configuration file and mapping metadata to define how Java classes are mapped to database tables and columns. This allows Java objects to be treated as persistent domain models while Hibernate handles saving, updating, deleting and querying database data behind the scenes through its API.
This document provides an overview of Hibernate, an object-relational mapping tool. It explains that Hibernate maps database tables to Java classes and vice versa, allowing developers to work with objects rather than SQL. Key benefits include better application architecture through separation of concerns, reduced time spent on standard database operations, and access to advanced features like caching and transactions. The document also provides an example of how to define mappings between a Java class and database table and use Hibernate to save an object to the database.
Slides accompanying a presentation on Dropwizard I gave at the DevIgnition conference ( www.devignition.com ) on April 29, 2016. The sample code is on GitHub at https://github.com/sleberknight/dropwizard-devignition-2016
This document provides an overview of the key differences between Play Framework versions 1.0 and 2.1. It notes that Play 2.1 introduces support for Scala and Java, uses dynamic compilation via SBT, includes error reporting for JavaScript, and is designed for long browser connections. It also summarizes how to work with templates, HTML forms, databases, and JSON in Play 2.1 applications.
This document discusses several key questions to consider when creating an offline application, including what functionality should be available offline, how to store application data locally, and how to handle synchronization between offline and online data. It provides examples of different storage options for offline data, such as the Application Cache, Service Workers Cache API, web storage, web SQL, file system API, and IndexedDB. It also discusses approaches for resolving conflicts when synchronizing offline and online data, such as using timestamps or optimistic/pessimistic locking strategies. The document is an informative resource for developers building offline-capable web applications.
DWR, Hibernate and Dojo.E - A Tutorialjbarciauskas
This tutorial will walk you through the steps of creating a simple database-driven AJAX application using Direct Web Remoting (DWR) 2.0, Hibernate 3.0 and a new open source project from Nexaweb Technologies, dojo.E. dojo.E is an extensible markup processing engine that out-of-the-box will translate XML into dojo components.
Hibernate is an object-relational mapping tool that allows developers to work with relational data (like SQL databases) using object-oriented programming languages like Java. It eliminates manual data handling code by directly mapping Java objects to database tables. This reduces development time and effort. Hibernate configuration involves setting up XML mapping files that describe how Java classes and their fields are mapped to database tables and columns. It provides a simpler object-oriented approach for handling data persistence tasks versus direct SQL/JDBC coding.
The document discusses Android architecture components. It describes key components like Lifecycles, LiveData, ViewModel, Room, Navigation, Paging, ViewModel SavedState, and Data Binding. It also discusses using architecture components with the MVVM pattern and clean architecture, including layers for the data, presentation and domain. It provides examples of implementing use cases and repositories, and testing use cases. It emphasizes benefits like testable and collaborative code and outlines best practices like proof of concepts for new learning.
The document provides an overview of Hibernate, an object-relational mapping tool for Java. It discusses some typical problems with JDBC and how Hibernate addresses these issues. It then covers how to get started with Hibernate, including designing entities, mapping them to database tables, and writing data access code using Hibernate queries and sessions. The document also includes examples of mapping files, configuration files, build files, utility classes, and data access objects.
Introduction
Web Storage
WebSQL
IndexedDB
File System Access
Final Considerations
This presentation has been developed in the context of the Mobile Applications Development course, DISIM, University of L'Aquila (Italy), Spring 2015.
http://www.ivanomalavolta.com
The Past Year in Spring for Apache GeodeVMware Tanzu
The document provides an overview of developments in the Spring for Apache Geode project over the past year. It discusses improvements and new features for Spring Test, Spring Data, Spring Session, and Spring Boot integration with Apache Geode. Key updates include enhanced mocking support in Spring Test, transaction event publishing in Spring Data, disabling indexes for Spring Session, and examples of caching patterns and configurations using the Spring and Geode frameworks.
Hibernate provides object relational mapping and allows working with data at the object level rather than directly with SQL. It abstracts the underlying database, handles change detection and caching. The session factory handles connection pooling and caching of mappings. The session represents a unit of work and tracks changes to objects, flushing updates to the database at the end of the session. The first level cache tracks changes to objects within a session. Query caching caches query results to improve performance. The second level cache caches objects beyond a single session.
This document discusses dependency injection in Drupal 8. It begins by explaining the problems with Drupal 7 code, such as strong dependencies on globals and an inability to reuse or test code easily. It then introduces dependency injection as a design pattern that can help address these issues by reducing hard-coded dependencies. The document outlines how dependency injection works in Symfony and will work in Drupal 8 through the use of a service container that allows injecting dependencies into classes.
The document outlines an agenda for a Hibernate training that covers generator classes, SQL dialects, collection mapping, relationship mappings like one-to-one and many-to-one, cascade types, lazy loading, transactions, HQL, criteria queries, caching, and includes examples of creating a basic Hibernate project using annotations and performing CRUD operations.
This document provides an overview of key concepts for developing applications with Symfony2 including: setting up the framework, code flow, dependency injection, configuration, controllers, applications, Doctrine integration, caching, performance tips, asset management, testing, deployment, third party bundles, and resources for contributing to Symfony2. It discusses service definitions, controller choices, application choices, Doctrine examples, caching strategies, performance optimization techniques, testing approaches, deployment options, and how to work with third party bundles.
LAND USE LAND COVER AND NDVI OF MIRZAPUR DISTRICT, UPRAHUL
This Dissertation explores the particular circumstances of Mirzapur, a region located in the
core of India. Mirzapur, with its varied terrains and abundant biodiversity, offers an optimal
environment for investigating the changes in vegetation cover dynamics. Our study utilizes
advanced technologies such as GIS (Geographic Information Systems) and Remote sensing to
analyze the transformations that have taken place over the course of a decade.
The complex relationship between human activities and the environment has been the focus
of extensive research and worry. As the global community grapples with swift urbanization,
population expansion, and economic progress, the effects on natural ecosystems are becoming
more evident. A crucial element of this impact is the alteration of vegetation cover, which plays a
significant role in maintaining the ecological equilibrium of our planet.Land serves as the foundation for all human activities and provides the necessary materials for
these activities. As the most crucial natural resource, its utilization by humans results in different
'Land uses,' which are determined by both human activities and the physical characteristics of the
land.
The utilization of land is impacted by human needs and environmental factors. In countries
like India, rapid population growth and the emphasis on extensive resource exploitation can lead
to significant land degradation, adversely affecting the region's land cover.
Therefore, human intervention has significantly influenced land use patterns over many
centuries, evolving its structure over time and space. In the present era, these changes have
accelerated due to factors such as agriculture and urbanization. Information regarding land use and
cover is essential for various planning and management tasks related to the Earth's surface,
providing crucial environmental data for scientific, resource management, policy purposes, and
diverse human activities.
Accurate understanding of land use and cover is imperative for the development planning
of any area. Consequently, a wide range of professionals, including earth system scientists, land
and water managers, and urban planners, are interested in obtaining data on land use and cover
changes, conversion trends, and other related patterns. The spatial dimensions of land use and
cover support policymakers and scientists in making well-informed decisions, as alterations in
these patterns indicate shifts in economic and social conditions. Monitoring such changes with the
help of Advanced technologies like Remote Sensing and Geographic Information Systems is
crucial for coordinated efforts across different administrative levels. Advanced technologies like
Remote Sensing and Geographic Information Systems
9
Changes in vegetation cover refer to variations in the distribution, composition, and overall
structure of plant communities across different temporal and spatial scales. These changes can
occur natural.
This presentation was provided by Steph Pollock of The American Psychological Association’s Journals Program, and Damita Snow, of The American Society of Civil Engineers (ASCE), for the initial session of NISO's 2024 Training Series "DEIA in the Scholarly Landscape." Session One: 'Setting Expectations: a DEIA Primer,' was held June 6, 2024.
How to Fix the Import Error in the Odoo 17Celine George
An import error occurs when a program fails to import a module or library, disrupting its execution. In languages like Python, this issue arises when the specified module cannot be found or accessed, hindering the program's functionality. Resolving import errors is crucial for maintaining smooth software operation and uninterrupted development processes.
A review of the growth of the Israel Genealogy Research Association Database Collection for the last 12 months. Our collection is now passed the 3 million mark and still growing. See which archives have contributed the most. See the different types of records we have, and which years have had records added. You can also see what we have for the future.
Leveraging Generative AI to Drive Nonprofit InnovationTechSoup
In this webinar, participants learned how to utilize Generative AI to streamline operations and elevate member engagement. Amazon Web Service experts provided a customer specific use cases and dived into low/no-code tools that are quick and easy to deploy through Amazon Web Service (AWS.)
Strategies for Effective Upskilling is a presentation by Chinwendu Peace in a Your Skill Boost Masterclass organisation by the Excellence Foundation for South Sudan on 08th and 09th June 2024 from 1 PM to 3 PM on each day.
2. What Hibernate Does
Object - Relational mapping
Transparent persistence & retrieval of objects
Persistence of associations and collections
Guaranteed uniqueness of an object (within a session)
3. Hibernate Features
O-R mapping using ordinary JavaBeans
Can set attributes using private fields or private setter
methods
Lazy instantiation of collections (configurable)
Polymorphic queries, object-oriented query language
Cascading persist & retrieve for associations, including
collections and many-to-many
Transaction management with rollback
Can integrate with other container-provided services
4. Application Architecture
User Interface
Application Logic
Domain Objects DAO
Hibernate
JDBC
Foundation Classes
UI event
data request
Hibernate API domain object
domain object
data xfer object
JDBC API ResultSet, etc.
hibernate.cfg.xml
*.hbm.xml class mappings
SessionFactory
6. Example of Persisting an Object
// get a Hibernate SessionFactory for Session management
sessionFactory = new Configuration()
.configure().buildSessionFactory();
// an Event object that we want to save
Location ku = new Location( "Kasetsart University" );
ku.setAddress( "90 Pahonyotin Road; Bangkok" );
Event event = new Event("Java Days");
event.setLocation( ku );
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
session.save( event );
tx.commit();
session.close();
7. Example of Retrieving an Object
// use the existing session factory
Session session = sessionFactory.openSession();
// query Event objects for "Java Days"
Transaction tx = session.beginTransaction();
Query query = session.createQuery(
"from Event where name='Java Days'" );
List events = query.list( );
out.println("Upcoming Java Days events: ");
for( Object obj : events ) {
Event event = (Event) obj;
String name = event.getName( );
Location loc = event.getLocation( );
...
}
tx.commit( );
8. Using Named Parameters in Query
// use the existing session factory
Session session = sessionFactory.openSession();
// Hibernate Query Language (HQL) can use named params
Query query = session.createQuery(
"from Event where name=:name");
query.setParameter( "name", "Java Days");
List events = query.list( );
out.println("Upcoming Java Days events: ");
for( Object obj : events ) {
Event event = (Event) obj;
String name = event.getName( );
Location loc = event.getLocation( );
...
9. Exercise 1
Configure a project with Hibernate
create an EventManager project
add Hibernate libraries to the project
add JAR for database driver
create a hibernate.cfg.xml file
create log4j.properties
10. Project Configuration for Hibernate
EventManager/ the project base directory
src/
hibernate.cfg.xml Hibernate configuration file
log4j.properties Log4J configuration file
eventmgr/ base package is "eventmgr"
domain/
Location.java
location.hbm.xml O-R mapping file for a class
build/
hibernate.cfg.xml copied here by IDE during build
log4j.properties copied here by IDE during build
eventmgr/
domain/
Location.class
location.hbm.xml copied here by IDE during build
lib/
hibernate3.jar Hibernate requires several jars
asm.jar
...
11. Where to Get Hibernate
http://www.hibernate.org Local copy:
http://se.cpe.ku.ac.th/download/hibernate
12. Required Hibernate Libraries
Libraries are in lib/ directory
of Hibernate distribution.
Which ones do you need?
See _README.txt or my
Using Hibernate notes.
In your IDE:
create a Hibernate "library"
add JARs to the library
better than copying JAR
files to your project
Required Libraries
hibernate3.jar
antlr-2.7.6.jar
asm.jar
cglib.jar
commons-collections.jar
commons-logging.jar
dom4j.jar
ehcache.jar
jta.jar
log4j.jar
// and maybe
xml-apis.jar
13. Create a Hibernate Library in Eclipse
1. Project -> Properties -> Java Build Path
2. select Libraries tab.
3. Click "Add Library..." and select "User Library", Next>
4. Create a new user library named "Hibernate"
5. Add Jar files
14. Add Library or jar for Database Driver
For Embedded Derby Database
/path-to-derby/lib/derby.jar
For HSQLDB
/path-to-hsqldb/lib/hsqldb.jar
15. hibernate.cfg.xml for Embedded Derby DB
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-
configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="dialect">
org.hibernate.dialect.DerbyDialect</property>
<property name="connection.driver_class">
org.apache.derby.jdbc.EmbeddedDriver</property>
<property name="connection.url">
jdbc:derby:/temp/eventmgr;create=true</property>
<property name="hbm2ddl.auto">create</property>
<!-- O-R mappings for persistent classes -->
<mapping resource="eventmgr/domain/Location.hbm.xml"/>
</session-factory>
</hibernate-configuration>
Remove after database created
16. hibernate.cfg.xml for MySQL
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC ... remainder omitted >
<hibernate-configuration>
<session-factory>
<property name="dialect">
org.hibernate.dialect.MySQLDialect </property>
<property name="connection.driver_class">
com.mysql.jdbc.Driver </property>
<property name="connection.username">student</property>
<property name="connection.password">secret </property>
<property name="connection.url">
jdbc:mysql://se.cpe.ku.ac.th/eventmgr </property>
<!-- Object-Relational mappings for classes -->
<mapping resource="eventmgr/domain/Location.hbm.xml"/>
... other mappings omitted
</session-factory>
</hibernate-configuration>
17. XML Syntax, 1
XML Declaration: "this file contains XML"
<?xml version='1.0' encoding='utf-8'?>
Root Element: "this whole file is a hibernate-configuration"
<hibernate-configuration>
content of document goes here
<hibernate-configuration>
Child Elements: define content, have a tree-like nested structure
<session-factory>
...
</session-factory>
Tree structure & Scope: all elements must have a closing tag
<class name="Event" table="EVENTS"> a start element
<property name="location" /> element start & end
</class> an end tag
18. XML Syntax, 2
Attributes: values must always be quotes, no duplicates
<class name="Event" table="EVENTS">
Special characters: < > & ' " must use reference except in CDATA
<message>
"Hello <b>world</b>"
</message>
Child Elements can be repeated (depends on DTD)
<courselist name="courses">
<course>object oriented programming</course>
<course>software spec & design</course>
</courselist>
Elements can sometimes be written as attributes
<course>
<id>219341</id> <course id="219341"/>
</course>
19. Logging
Hibernate apps will log errors and/or activity.
Two choices:
Java SDK logging (since JDK 1.4)
Log4j
if you use Log4j, create a log4j.properties in
your application source root directory.
Copy this file from the Hibernate etc/ directory.
20. Sample log4j.properties
Too long to print here
See an actual file, for example:
[hibernate.dir]/doc/tutorial/src/log4j.properties
Configuration logging of Hibernate:
log4j.logger.org.hibernate=warn
Log the SQL generated by Hibernate:
#log4j.logger.org.hibernate.SQL=debug
Log JDBC bind parameters (can be security leak):
log4j.logger.org.hibernate.type=info
21. Exercise 2
Define a Location class and LOCATIONS table
Write the class
Create a mapping file for Location: Location.hbm.xml
22. Create the Location class
Location class
Location
id: int
name: String
address: String
LOCATIONS
PK id INTEGER
name VARCHAR(80)
address VARCHAR(160)
LOCATIONS table (Hibernate can auto-generate this)
23. Write the Location class
package eventmgr.domain;
public class Location {
private int id;
private String name;
private String address;
public Location() { } // a no argument constructor
public int getId( ) { return id; }
public void setId( int id ) { this.id = id; }
public String getName( ) { return name; }
public void setName( String n ) { this.name = n; }
public String getAddress( ) { return address; }
public void setAddress( String a ) { address = a; }
}
Use JavaBean conventions
in Persistent object classes.
24. Hibernate can access private methods
package eventmgr.domain;
public class Location {
private int id;
private String name;
private String address;
public Location() { }
public int getId( ) { return id; }
private void setId( int id ) { this.id = id; }
public String getName( ) { return name; }
private void setName( String n ) { this.name = n; }
public String getAddress( ) { return address; }
private void setAddress( String a ) { address = a; }
}
OK to use "private" or
"protected" for mutators.
25. Hibernate can access private data, too
public class Location {
private int id;
private String name;
private void setName( String name ) {
if ( name.length() < 3 )
new RuntimeException("name too short");
...
} Some mutator methods contain data validity
checks or other complicated logic.
to tell Hibernate to set the field values directly (don't use the "set"
method) in the class mapping file write:
<hibernate-mapping default-access="field">
...
26. Schema to create Locations table
CREATE TABLE locations (
id INTEGER NOT NULL,
name VARCHAR(80) NOT NULL,
address VARCHAR(160),
PRIMARY KEY(id)
) DEFAULT CHARSET=utf8 ;
This works for MySQL.
Hibernate can generate table schema at runtime.
mysql> use eventmgr ;
mysql> source tableschema.sql ;
27. O-R Mapping for the Location class
Map between object attributes and table columns.
LOCATIONS
PK id INTEGER
name VARCHAR(80)
address VARCHAR(160)
Location
id: int
name: String
address: String
O-R Mapping requires a mapping file
28. Mapping File Location.hbm.xml
An XML file describing how to map object to table.
Filename: Location.hbm.xml
<!DOCTYPE hibernate-mapping PUBLIC ... remainder omitted >
<hibernate-mapping package="eventmgr.domain">
<class name="Location" table="LOCATIONS">
<id name="id" column="id">
<!-- let hibernate choose id for new entities -->
<generator class="native"/>
</id>
<property name="name" column="name" not-null="true"/>
<property name="address"/>
</class>
</hibernate-mapping>
29. Mapping File Explained
<hibernate-mapping>
<class name="eventmgr.domain.Location"
table="LOCATIONS"
options... >
<id name="id"
column="id"
unsaved-value="0">
<generator class="native"/>
</id>
object attribute mappings
</class>
</hibernate-mapping>
root element of a hibernate mapping
mapping for one class
Every persistent class needs an "identifier" attribute and column.
The identifier is used to establish object identity (obj1 == obj2) and locate the
table row for a persisted object. The id is usually the Primary Key of the table.
30. Attribute Mapping: <property .../>
<property name="name"
column="name“
type=“name“
not-null="true“
/>
You omit elements if Hibernate can guess the value itself:
<property name="address" column="ADDRESS" type="string"/>
<!-- omit data type and Hibernate will determine it -->
<property name="address" column="ADDRESS"/>
<!-- omit column if same as attribute (ignoring case)-->
<property name="address"/>
Name of the attribute in Java class
Column name in the
database table
Hibernate or Java data
type (usually you can
omit it)
Constraints
31. What you have so far
Project configured for Hibernate
Hibernate configuration file
Location class and mapping file Location.hbm.xml
Configure a database schema
(for learning, we will auto-generate schema)
32. HibernateUtil: a Session Factory (1)
HibernateUtil
-sessionFactory: SessionFactory
+getSessionFactory( ): SessionFactory
+getCurrentSession( ): Session
+openSession( ): Session
// always use the same sessionFactory (Singleton)
SessionFactory sessionFactory = new Configuration()
.configure().buildSessionFactory();
// use sessionFactory to get a Session
Session session = sessionFactory.openSession();
// or the more convenient:
Session session = sessionFactory.getCurrentSession();
1
33. HibernateUtil: a Session Factory (2)
public class HibernateUtil {
private static SessionFactory sessionFactory = null;
private static final Logger log = Logger.getLogger(..);
public static SessionFactory getSessionFactory() {
if ( sessionFactory == null ) {
try { // Create the SessionFactory
sessionFactory = new Configuration()
.configure().buildSessionFactory();
} catch (Exception e) {
System.err.println("sessionFactory error "+ ex);
log.error("SessionFactory creation failed", ex);
//throw new ExceptionInInitializerError(ex);
}
}
return sessionFactory;
34. HibernateUtil: a Session Factory (3)
/**
* Get the current Hibernate session.
* This creates a new session if no current session.
* @return the current Hibernate Session
*/
public static Session getCurrentSession() {
return getSessionFactory().getCurrentSession();
}
public static Session openSession() {
return getSessionFactory().openSession();
}
36. Persistence Test: LocationTest.java
public static void testQuery() {
System.out.println("Retrieving locations");
Session session = HibernateUtil.getCurrentSession();
Transaction tx = session.beginTransaction();
Query query = session.createQuery("from Location");
// query.list() returns objects, cast to List<Location>
List<Location> list = (List<Location>)query.list( );
tx.commit();
for(Location l : list ) out.printf("%d %s %sn",
l.getId(), l.getName(), l.getAddress() );
if ( session.isOpen() ) session.close();
}
public static void main( String [] args) {
testSave( ); testQuery( );
37. Exercise 3
Test object uniqueness:
In one session get the same location two times and
compare using (ku1 == ku2). Are they same?
In different sessions get the same location and
compare (ku1 == ku2). Are they same?
Test transparent persistence:
Modify a location inside a session. Does database
change?
Reattach a modified object to new session. Does
database change?
38. Getting a Unique Result
Session session = HibernateUtil.getCurrentSession();
Query query = session.createQuery(
"from Location where name=‘Kasetsart University’");
// query.uniqueResult() returns only first match
Location ku1 = (Location) query.uniqueResult( );
Session session = HibernateUtil.getCurrentSession();
Query query = session.createQuery(
"from Location l where l.name like 'Kasetsart%'");
// query.uniqueResult() returns only first match
Location ku1 = (Location) query.uniqueResult( );
Pattern matches "like" - use "%" as wildcard character
39. Mapping a Class with Associations
Simplified version of Event class.
Event
id: long
name: String
startDate: Date
location: Location
Location
id: int
name: String
address: String
1
*
40. O-R Mapping of n-to-1 Associations
Event
id: long
name: String
startDate: Date
location: Location
LOCATIONS
PK id INTEGER
name VARCHAR
address VARCHAR
Location
id: int
name: String
address: String
EVENTS
PK id BIGINT
name VARCHAR
start_date TIMESTAMP
FK location_id INTEGER
The Data Mapper converts a n-to-1
association to a foreign key relation (persist)
or foreign key to object (retrieve).
1
*
41. Mapping for Event (Event.hbm.xml)
Use <many-to-one name="attribute" ... />
to map a reference to another object.
<!DOCTYPE hibernate-mapping PUBLIC ... remainder omitted >
<hibernate-mapping package="eventmgr.domain">
<class name="Event" table="EVENTS">
...
<property name="startDate" column="start_date"
type="timestamp" />
<many-to-one name="location" column="location_id"
class="Location" />
</class>
</hibernate-mapping>
you can omit class (Hibernate can determine itself)
42. Test: Save an Event
public static void testSave() {
Location loc1 = new Location( );
loc1.setName("Kasetsart University");
loc1.setAddress("90 Pahonyotin Rd, Bangkok");
Event event = new Event( );
event.setName("Java Days");
event.setLocation( loc1 );
event.setStartDate( new Date(108,Calendar.JULY, 1) );
Session session = HibernateUtil.getCurrentSession();
Transaction tx = session.beginTransaction();
session.saveOrUpdate( event );
tx.commit();
System.out.println("Event saved");
}
43. Did you get an Error?
The Location doesn't exist in database (transient object).
Exception in thread "main“
org.hibernate.TransientObjectException:
object references an unsaved transient instance
- save the transient instance before flushing:
eventmgr.domain.Location
44. Persisting the Event location
Solutions:
1. save location during the transaction (manual save)
2. tell Hibernate to cascade the save operation
(automatically save Location)
<many-to-one name="location" column="location_id"
class="Location"
cascade="save-update" />
cascade="none" don't cascade operations
"all" cascade all operations (be careful)
"save-update" cascade save and updates
"delete-orphan" cascade all, delete unreferenced orphan children
45. Test: Retrieve an Event
public static void testRetrieve() {
System.out.println("Retrieving event");
Session session = HibernateUtil.getCurrentSession();
Transaction tx = session.beginTransaction();
Query query = session.createQuery(
"from Event e where e.name= :name");
query.setParameter("name", "Java Days");
// query.list() returns objects, cast to List<Location>
List<Event> list = (List<Event>)query.list( );
tx.commit();
for(Event e : list ) out.printf("%d %s %sn",
e.getId(), e.getName(), e.getLocation().getName()
);
}
46. Lazy Instances and Proxies
Transaction tx = session.beginTransaction();
Query query = session.createQuery(
"from Event e where e.name=:name");
query.setParameter("name", "Java Days");
List<Event> list = (List<Event>)query.list( );
tx.commit();
for(Event e : list ) out.printf("%d %s %sn",
e.getId(), e.getName(), e.getLocation().getName()
);
Error: LazyInstantiationException
• Hibernate uses lazy instantiation and proxy objects
• Hibernate instantiates the location object when it is first accessed
• We closed the transaction before accessing the location
47. Two Solutions
1. Modify our code: getLocation( ) before closing the
session.
2. Tell Hibernate not to use lazy instantiation of Location
objects (in Location.hbm.xml)
List<Event> list = (List<Event>)query.list( );
for(Event e : list ) out.printf("%d %s %sn",
e.getId(), e.getName(), e.getLocation().getName()
);
tx.commit( );
<class name="Location" table="LOCATIONS" lazy="false">
...
</class>
48. Creating a Component for Address
Address
street: String
city: String
province: String
Location
id: int
name: String
address: Address
1
*
LOCATIONS
id name address
101 Kasetsart University street city province
102 Seacon Square
50. A DAO for the Location class
The "useful" methods depend on the domain class and
the application.
LocationDao
findById(id: int) : Location
findByName(name : String): Location[*]
find(query: String) : Location[*]
save(loc: Location) : boolean
delete(loc: Location) : boolean
51. Java code for Simple LocationDao
package eventmgr.dao;
import ...;
public class SimpleLocationDao {
private static final Logger logger =
Logger.getLogger(LocationDao.class);
public LocationDao() { }
public Location findById( int id )
public List<Location> findByName( String name )
public List<Location> find( String query )
public boolean save( Location loc )
public boolean delete( Location loc )
}
52. The core of findById( ) - use "load"
public Location findById( int id ) {
Location result = null;
Session session = null;
Transaction tx = null;
try {
session = HibernateUtil.getCurrentSession();
tx = session.beginTransaction();
result =
(Location)session.load(Location.class, id);
tx.commit();
session.close( );
} catch ...
}
return result;
}
53. The details of findById( )
public Location findById( int id ) {
Location result = null;
Session session = null;
Transaction tx = null;
try {
session = HibernateUtil.getCurrentSession();
tx = session.beginTransaction();
result = (Location)session.load(Location.class,id);
tx.commit();
} catch (ObjectNotFoundException e) {
logger.info("Object not found. id = "+id, e);
if ( tx != null && ! tx.wasCommitted() ) tx.rollback();
} catch (HibernateException e) {
logger.error("Hibernate exception", e);
if ( tx != null && ! tx.wasCommitted() ) tx.rollback();
} finally {
if ( session != null && session.isOpen() ) session.close();
}
return result;
}
54. The core of findByName( ) - "query"
public List<Location> findByName( String name ) {
List<Location> result;
...
try {
session = HibernateUtil.getCurrentSession();
tx = session.beginTransaction();
Query query = session.createQuery(
"from Location where name=:name" );
query.setParameter( "name", name );
result = (List<Location>) query.list( );
tx.commit();
session.close( );
} catch ...
return result;
}
58. The core of delete( ) - "delete"
public boolean delete( Location location ) {
boolean result = false;
...
try {
session = HibernateUtil.getCurrentSession();
tx = session.beginTransaction();
session.delete( location );
tx.commit();
session.close( );
result = true;
} catch ...
return result;
}
59. Redundant Code
Every DAO method has the same boilerplate code:
Session session = null;
Transaction tx = null;
try {
session = HibernateUtil.getCurrentSession();
tx = session.beginTransaction();
do the work here
tx.commit();
} catch (ObjectNotFoundException e) {
logger.info("Object not found. "+id, e);
if ( tx != null && ! tx.wasCommitted() ) tx.rollback();
} catch (HibernateException e) {
logger.error("Hibernate exception", e);
if ( tx != null && ! tx.wasCommitted() ) tx.rollback();
} finally {
if ( session != null && session.isOpen() ) session.close();
}
60. Factor out Redundant Code
Class SimpleLocationDao {
private Session session; // declare as attributes
private Transaction tx;
public Location findById( int id ) {
try {
beginTransaction( );
do the work here
commitTransaction( );
} catch (ObjectNotFoundException e) {
handleError( e );
} catch (HibernateException e) {
handleError( e );
} finally {
if ( session != null && session.isOpen() )
session.close();
}
61. Duplicate Code Between DAO
In every DAO, the CRUD methods are almost the same
Consider save( ) ...
public boolean save( Location location ) {
boolean result = false;
...
try {
beginTransaction( );
session.saveOrUpdate( location );
commitTransaction( );
} catch ( ... ) {
handleException( e );
} finally { ... }
return result;
}
62. Apply the Layer Superclass Pattern
AbstractDao
#load( class, id ) : Object
#find( class, query ) : List
#saveOrUpdate( object: Object )
#delete( object: Object )
LocationDao EventDao SpeakerDao
64. LocationDao using Layer Superclass
public class LocationDao extends AbstractDao {
public boolean save( Location location ) {
return super.save( location );
}
65. AbstractDao.load
protected Object load( Class clazz,
Serializable id ) {
Object result = null;
try {
beginTransaction();
result = session.load( clazz, id);
commitTransaction()
} catch (ObjectNotFoundException e) {
handleError( e );
} catch (HibernateException e) {
handleError( e );
} finally {
closeSession( );
}
return result;
}
66. LocationDao using Layer Superclass
public class LocationDao extends AbstractDao {
public LocationDao( ) { super( ); }
public Location findById( int id ) {
return (Location) super.load(
Location.class, id );
}
67. Exercise
use your SimpleLocationDao to write a layer
superclass named AbstractDao.
write a LocationDao that extends AbstractDao
68. Hibernate Query Language (HQL)
Query query = session.createQuery(
"from Event where name='Java Days'");
Query query = session.createQuery(
"select e from Event e where e.name='Java Days'");
Hibernate queries you Hibernate Query Language (HQL).
HQL is object-centric - use class and property names, not SQL
table names.
69. HQL example
String query = "select e from Event e where
e.location.name = 'Kasetsart University'";
Query q = session.createQuery( query );
String sqlquery = "select * from EVENTS e
join LOCATIONS l ON e.location_id = l.id
where l.name = 'Kasetsart University'";
Statement stmt = connection.createStatement( sqlquery );
Problem: Find all events which are held at Kasetsart
HQL:
SQL and JDBC:
70. Many-to-one Associations
public class Event {
private long id;
private String name;
private Location location; // 1-to-many assoc.
private Date startDate;
private long duration;
public Event( ) { }
...
}
72. Cascading Save & Update
<class name="Event" table="EVENTS">
<id name="id" column="id">
<generator class="native"/>
</id>
...
<many-to-one name="location" column="location_id"
class="Location"
cascade="save-update"/>
</class>
When you save an Event, should Hibernate automatically
save the location, too?
• no: then you must save the location yourself
• Yes: specify cascade = "save-update"
Other choices for cascade: all, none, save-update, delete
73. Learning Hibernate
Tutorial at www.hibernate.org
Another good tutorial:
http://www.allapplabs.com/hibernate/hibernate_tutorials
.htm
Peak & Heudecker, Hibernate Quickly, 2006.
Baur & King, Java Persistence with Hibernate, 2007,
update of Hibernate in Action, and much longer.
Baur & King, Hibernate in Action, 2005, considered the
best Hibernate book, by one of the Hibernate creators.
74. Hibernate Tools
Hibernate Tools Eclipse plugin - HibernateConsole and
more
Test HQL queries, browse database
Middlegen - generates class mapping files (hbm.xml)
from an existing database schema. Has Eclipse plugin.
Hibernate Synchronizer - generates class mapping files
(hbm.xml) and Java classes from a database schema.
hbm2ddl - creates a database schema (in SQL) from a
hbm.xml file.
hbm2java - creates a Java class from a hbm.xml file.