1. Hibernate + Java אליהו חלסצ'י תכנות מתקדם 2 89-211 תרגול מספר 6
תש"ע
Hibernate + Java
אליהו חלסצ'י

2. הקדמה
בתוכניות מורכבות המחזיקות מידע רב, נרצה להשתמש במסד נתונים ולא להתעסק ברמת מבנה הנתונים.
נרצה אף להפריד בין שכבת מסד הנתונים לשכבת האפליקציה שעושה בו שימוש. (ויש לכך ארכיטקטורות שונות)
נרצה שהקוד שלנו לא ישתנה אם החלטנו להחליף למסד נתונים חדש בעל שפת שאילתות אחרת. למשל בין mysql ל oracle.

3. הקדמה
בעיה יותר חמורה היא שאנו נרצה לעבוד עם אובייקטים כחלק מתוכנית מונחית עצמים – ולא לעבוד עם טבלאות רלציוניות.
האם SQL מכיר את המושג ירושה? פולימורפיזם?
דרך אחת להתמודדות עם הבעיה תהיה לפתור אותה בעצמנו ע"י שימוש ב java.sql
נצטרך לפתוח תקשורת עם שרת ה mysql למשל, לשלוח לו פקודות בשפתו ולהמיר את המידע שהתקבל אל תוך אובייקטים...

4. הקדמה דוגמא האם שיטה זו עונה על הצרכים שהגדרנו?
יצירת תקשורת עם שרת ה mysql
Connection connection = null;
try {
// Load the JDBC driver
String driverName = "org.gjt.mm.mysql.Driver"; // MySQL MM JDBC driver
Class.forName(driverName);
// Create a connection to the database
String serverName = "localhost";
String mydatabase = "mydatabase";
String url = "jdbc:mysql://" + serverName + "/" + mydatabase;
// a JDBC url
String username = "username";
String password = "password";
connection = DriverManager.getConnection(url, username, password);
} catch (ClassNotFoundException e) {
// Could not find the database driver
{ catch (SQLException e) {
// Could not connect to the database {
שליחת פקודת sql וקבלת התוצאות כמחרוזות
try {
// Create a result set containing all data from my_table
Statement stmt = connection.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM my_table");
// Fetch each row from the result set
while (rs.next()) {
// Get the data from the row using the column index
String s = rs.getString(1);
// Get the data from the row using the column name
s = rs.getString("col_string"); }
} catch (SQLException e) {}

5. הקדמה למעשה אנו צריכים תשתית. תשתית בעלת ארכיטקטורת ORM.
Object / Relational Mapping
מתאם אוטומטי בין סכמה רלציונית למחלקה ובין תוכן הטבלה למופע של מחלקה זו.
כאן נכנס Hibernate לתמונה.

6. הקדמה Hibernate: קוד פתוח ספריות ORM ל java
צריך רק להגדיר את הקישור למסד הנתונים ואת מיפוי השדות - למשתני מחלקה בקובצי xml וכל העבודה מתבצעת באופן שקוף לנו.
אנו עובדים עם אובייקטים שנטענים או נשמרים במסד נתונים.
שאילות בשפת HQL
שפת שאילתות מונחית עצמים
אין צורך לשנות את הקוד שלנו אם השתנה מסד הנתונים

7. הקמת סביבת העבודה
נוריד את ה core package מהאתר ונפתח את ה zip במקום כלשהו.
נפתח פרויקט java חדש בשם HibernateExample
הוספת ה jars של Hibernate:
נוסיף lib בשם Hibernate
מאפייני הפרויקט  build path  לשונית libraries  add lib...  user lib…  new…
נוסיף jars (באותו החלון add jars)
נבחר את ה jars מהמקום בו פתחנו את ה zip וכן מתת-התיקייה lib/required
כמו כן צריך לצרף את slf4j-jdk jar מתוך עבור הלוג.

8. תוכנית לדוגמא תחילה ניצור את מסד הנתונים הבא:
כעת ניצור את קובץ הקונפיגורציה ל Hibernate תחת src בשם hibernate.cfg.xml
תוכן הקובץ ייקשר את הפרויקט למסד הנתונים שיצרנו
אילוצים
טיפוס
שדה
מפתח ראשי
מספר
USER_ID -
טקסט
FIRST_NAME
LAST_NAME
AGE
mysql

9. עלינו לצרף את ה jar המכיל את המחלקה שמבצעת את הקישור עבור mysql.
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "
<hibernate-configuration>
<session-factory>
<property name="connection.url">
jdbc:mysql://localhost:3306/myDatabase
</property>
<property name="connection.driver_class">
com.mysql.jdbc.Driver
<property name="connection.username">
root
<property name="connection.password">
write here your password
<!-- Set AutoCommit to true -->
<property name="connection.autocommit">
true
<!-- SQL Dialect to use. Dialects are database specific -->
<property name="dialect">
org.hibernate.dialect.MySQLDialect
<!-- Mapping files -->
<mapping resource="נמלא בשקפים הבאים" />
</session-factory>
</hibernate-configuration>
עלינו לצרף את ה jar המכיל את המחלקה שמבצעת את הקישור עבור mysql.
ניתן להורדה מ:
פתחו את ה zip במקום כלשהו וצרפו את ה jar
ל build path של הפרויקט.
כתובת מסד הנתונים שלנו בשרת ה mysql
המחלקה האחראית על על ביצוע הקישור – פרטים בצד
שם המשתמש
סיסמה
Auto commit = true שלא נצטרך לבצע ידנית לאחר כל פעולה, אלא אם נרצה בכך.
הפנייה לקובץ המיפוי

10. תוכנית לדוגמא כעת ניצור מחלקה ב java המתאימה לטבלה:
נוסיף getters ו setters מתאימים.
טיפ ל eclipse:
קליק ימני על המחלקה  Source  Generate getters and setters…
public class User {
private long userId = 0 ;
private String firstName = "";
private String lastName = "";
private int age = 0;
private String = ""; }
אילוצים
טיפוס
שדה
מפתח ראשי
מספר
USER_ID -
טקסט
FIRST_NAME
LAST_NAME
AGE

11. generator – השיטה ליצור מפתח
תוכנית לדוגמא
כעת ניצור את קובץ ה xml האחראי למיפוי השדות, נקרא לו User.hbm.xml
ב hibernate.cfg.xml נוסיף את ההפניה לקובץ המיפוי
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
" >
<hibernate-mapping>
<class name="User" table="USERS" >
<id name="userId" type="java.lang.Long" column="user_id" >
<generator class="increment" />
</id>
<property name="firstName" type="java.lang.String" column="first_name" length="20" />
<property name="lastName" type="java.lang.String" column="last_name" length="20" />
<property name="age" type="java.lang.Integer" column="age" length="-1" />
<property name=" " type="java.lang.String" column=" " length="40" />
</class>
</hibernate-mapping>
התאמת מחלקה לטבלה
השדה id מהווה מפתח ראשי
generator – השיטה ליצור מפתח
מיפוי שאר השדות
<mapping resource="User.hbm.xml" />

12. תוכנית לדוגמא עד כה יצרנו: כעת נלמד כיצד "לדבר" עם מסד הנתונים שלנו.
טבלה במסד הנתונים שלנו.
קובץ xml לקונפיגורציה.
מחלקה תואמת לטבלה ב java.
קובץ xml למיפוי השדות.
כעת נלמד כיצד "לדבר" עם מסד הנתונים שלנו.
לשם כך נצטרך לפתוח session לקוח מול שרת ה mysql שלנו.
המחלקה org.hibernate.Session עושה עבורנו את העבודה.
המחלקה UserManager תנהל אובייקטים של User במסד הנתונים שלנו באמצעות Session.
import org.hibernate.Session;
public class UserManager {
private Session session = null;
public UserManager(Session session) {
if(session == null)
throw new
RuntimeException("Invalid session object.");
this.session = session; }
public void saveUser(User user){
session.save(user);
public void updateUser(User user){
session.update(user);
public void deleteUser(User user) {
session.delete(user);

13. תוכנית לדוגמא כעת נראה קוד ששומר אובייקט user במסד הנתונים שלנו.
יצרנו מופע של SessionFactory שבעזרתו יצרנו מופע של Session
יצרנו מופע של UserManager וקראנו ל saveUser
הדפסנו את ה ID (=1)
התוצאה:
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class Main {
public static void main(String[] args) {
User user = new User();
user.setFirstName("Kermit");
user.setLastName("Frog");
user.setAge(54);
SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
Session session = sessionFactory.openSession();
UserManager manager = new UserManager(session);
manager.saveUser(user);
System.out.println("User saved with ID = "+ user.getUserId());
session.flush(); }
mysql

14. תוכנית לדוגמא כעת נראה קוד שיוצר אובייקטים מתוך הרשומות במסד הנתונים.
נשתמש במחלקה org.hibernate.Query כדי לכתוב שאילתות ל session
נקבל את רשימת התוצאות ונעבור עליה באמצעות iterator
User user;
SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
Session session = sessionFactory.openSession();
Query query = session.createQuery("from User");
List <User>list = query.list();
Iterator<User> it=list.iterator();
while (it.hasNext()){
user=it.next();
System.out.println("id: \t\t"+user.getUserId());
System.out.println("age: \t\t"+user.getAge());
System.out.println("first name: \t"+user.getFirstName());
System.out.println("last name: \t"+user.getLastName());
System.out.println(" \t\t"+user.get ()); }
id: 1
age: 54
first name: Kermit
last name: Frog

15. HQL Hibernate Query Language שפת שאילתות שדומה בכוונה ל SQL
אך אל תתנו לסינטקס להטעות אתכם, היא שפה בעלת תאימות מלאה ל object oriented
יכולת הבנה של:
ירושה
פולימורפיזם
קשר אסוציאטיבי
User user;
SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
Session session = sessionFactory.openSession();
Query query = session.createQuery("from User");
List <User>list = query.list();
Iterator<User> it=list.iterator();
while (it.hasNext()){
user=it.next();
System.out.println("id: \t\t"+user.getUserId());
System.out.println("age: \t\t"+user.getAge());
System.out.println("first name: \t"+user.getFirstName());
System.out.println("last name: \t"+user.getLastName());
System.out.println(" \t\t"+user.get ()); }
ניתן להחליף את מסד הנתונים, הקוד שלנו
יישאר אותו הדבר...

16. HQL
נראה מספר דוגמאות:
"from Cat” : השאילתה הבסיסית למופעים של Cat
“select u from User u ordered by u.firstName, u.lastName” : בחירת כל אובייקט מסוג User בצורה ממוינת תחילה לפי firstName ואח"כ לפי lastName.
"select cat.weight + sum(kitten.weight) from Cat cat join cat.kittens kitten group by cat.id, cat.weight" : מה הקוד הזה נותן?
ניתן לבקר במדריך הבא כדי להכיר את השפה:

17. הטמעה למה להשתמש ב hibernate? למה משמשת המחלקה Session?
מהם היתרונות של השימוש ב HQL?
היכנסו ל tutorial הבא: (ממנו נלקחו הדוגמאות) והמשיכו את הדוגמא כדי לראות כיצד מבצעים קשר אסוציאטיבי בין טבלאות שונות.
קשר one to many
קשר many to many