作為異軍突起的新型語言，Java定義了一個標准的運行環境，用戶定義的類在其中得到執行。這些用戶自定義類的實例代表了真實環境中的數據，包括儲存在數據庫、文件或某些大型事務處理系統中的數據，而小型系統通常也需要一種在本地負責控制數據存儲的機制。
由於數據訪問技術在不同的數據源類型中是不一樣的，因此對數據進行訪問成了給程序開發人員的一種挑戰，程序員需要對每一種類型的數據源使用特定的編程接口（API），即必須至少知道兩種語言來基於這些數據源開發業務應用：Java語言和由數據源所決定的數據訪問語言。這種數據訪問語言一般根據數據源的不同而不同，這使得學習使用某種數據源的開發成本相應提升。
在Java數據對象技術（JDO）發布之前，通常有三種方式用於存儲Java數據：串行化（即Serialization，也稱序列化）、JDBC和EJB中的CMP（容控存儲）方式。串行化用於將某個對象的狀態，以及它所指向的其它對象結構圖全部寫到一個輸出流中（比如文件、網絡等等），它保證了被寫入的對象之間的關系，這樣一來，在另一時刻，這個對象結構圖可以完整地重新構造出來。但串行化不支持事務處理、查詢或者向不同的用戶共享數據。它只答應在最初串行化時的粒度（指訪問對象的接口精細程度）基礎上進行訪問，並且當應用中需要處理多種或多次串行化時很難維護。串行化只適用於最簡單的應用，或者在某些無法有效地支持數據庫的嵌入式系統中。
JDBC要求你明確地處理數據字段，並且將它們映射到關系數據庫的表中。開發人員被迫與兩種區別非常大的數據模型、語言和數據訪問手段打交道：Java，以及SQL中的關系數據模型。在開發中實現從關系數據模型到Java對象模型的映射是如此的復雜，以致於多數開發人員從不為數據定義對象模型；他們只是簡單地編寫過程化的Java代碼來對底層的關系數據庫中的數據表進行操縱。最終結果是：他們根本不能從面向對象的開發中得到任何好處。
EJB組件體系是被設計為支持分布式對象計算的。它也包括對容器治理持續性Container Managed Persistence（參見術語表）的支持來實現持續性。主要由於它們的分布式特性，EJB應用比起JDO來復雜得多，對資源的消耗也大得多。不過，JDO被設計成具有一定的靈活性，這樣一來，JDO產品都可以用來在底層實現EJB的存儲處理，從而與EJB容器結合起來。假如你的應用需要對象存儲，但不需要分布式的特性，你可以使用JDO來代替EJB組件。在EJB環境中最典型的JDO使用方案就是讓EJB中的對話組件（Session Bean）直接訪問JDO對象，避免使用實體組件（Entity Bean）。EJB組件必須運行在一個受控（Managed，參見術語表）的應用服務環境。但JDO應用可以運行在受控環境中，也可以運行在不受控的獨立環境中，這些使你可以靈活地選擇最合適的應用運行環境。
假如你將精力集中在設計Java對象模型上，然後用JDO來進行存儲你的數據類的實例，你將大大提高生產力和開發效率。你只需要處理一種信息模型。而JDBC則要求你理解關系模型和SQL語言（譯者注：JDO並不是要取代JDBC，而是建立在JDBC基礎上的一個抽象的中間層，提供更簡單的數據存儲接口）。即使是在使用EJB CMP（即容控存儲，參見術語表）的時候，你也不得不學習與EJB體系相關的許多其它方面的內容，並且在建模方面還有一些JDO中不存在的局限性。
JDO規范了JDO運行環境和你的可存儲對象類之間的約定。JDO被設計成支持多種數據源，包括一般情況下考慮不到的數據庫之類的數據源。從現在開始，我們使用數據庫（參見術語表）這一概念來表示任何你通過JDO來訪問的底層數據源。
定義數據對象模型
我們將建立一個UML類圖，顯示一個公司的對象模型的相關類以及相互之間的關系。一個Movie（電影）對象表示一部特定的電影。每個至少在一部電影中出演角色的演員由一個Actor（演員）對象代表。而Role（角色）類表示某個演員在某部電影中扮演的特定角色，因此Role類也表示了電影和演員之間的一種關系，這種關系包含一個屬性（電影中的角色名）。每部電影包含一到多個角色。每個演員可以在不同的電影中扮演不同的角色，甚至在同一部電影中扮演多個角色。
我們會將這些數據類以及操縱這些數據類實例的的程序放到com.mecdiamania.prototype包中。
需要存儲的類
我們定義Movie、Actor和Role這幾個類為可持續的，表示它們的實例是可以被儲存到數據庫中的。首先我們看看每個類的完整的源代碼。每個類中有一個package語句，因此可以很清楚地看到本例用到的每個類分別在哪個包中。
例1-1顯示了Movie類的源代碼。JDO是定義在javax.jdo包中的，注重這個類並不一定要導入任何具體的JDO類。Java中的引用和java.util包中的Collection及相關子類（接口）被用來表示我們的類之間的關系，這是大多數Java應用中的標准方式。
Movie類中的屬性使用Java中的標准類型，如String、Date、int等等。你可以將屬性聲明為private的，不需要對每一屬性定義相應的get和set方法。Movie類中還有一些用於訪問這些私有屬性的方法，盡管這些方法在程序中的其它部分會用到，但它們並不是JDO所要求的。你可以使用屬性包裝來提供僅僅是抽象建模所需要的方法。這個類還有一些靜態屬性（static的），這些屬性並不存儲到數據庫。
"genres"屬性是一個String型的，內容是該電影所屬的電影風格（動作、愛情、詭異等等）。一個Set接口用來表示該電影的演員表中的角色集合。"addRole()"方法將元素加入到演員表中，而"getCast()"方法返回一個不可以更改的集合，該集合中包含演員表。這些方法並不是JDO規定的，只是為了方便應用編程而編寫的。"parseReleaseDate()"方法和"formatReleaseDate()"方法用於將電影的發行日期標准化（格式化）。為了保持代碼的簡單，假如parseReleaseDate()的參數格式不對，將會返回null。
例1-1 Movie.java
package com.mediamania.prototype;
import java.util.Set;
import java.util.HashSet;
import java.util.Collections;
import java.util.Date;
import java.util.Calendar;
import java.text.SimpleDateFormat;
import java.text.ParsePosition;
public class Movie {
private static SimpleDateFormat yearFmt = new SimpleDateFormat("yyyy");
public static final String[] MPAAratings = {
"G", "PG", "PG-13", "R", "NC-17", "NR"};
private String title;
private Date releaseDate;
private int runningTime;
private String rating;
private String webSite;
private String genres;
private Set cast; // element type: Role
private Movie() {}
public Movie(String title, Date release, int duration, String rating,
String genres) {
this.title = title;
releaseDate = release;
runningTime = duration;
this.rating = rating;
this.genres = genres;
cast = new HashSet();
}
public String getTitle() {
return title;
}
public Date getReleaseDate() {
return releaseDate;
}
public String getRating() {
return rating;
}
public int getRunningTime() {
return runningTime;
}
public void setWebSite(String site) {
webSite = site;
}
public String getWebSite() {
return webSite;
}
public String getGenres() {
return genres;
}
public void addRole(Role role) {
cast.add(role);
}
public Set getCast() {
return Collections.unmodifiableSet(cast);
}
public static Date parseReleaseDate(String val) {
Date date = null;
try {
date = yearFmt.parse(val);
} catch (java.text.ParseException exc) {}
return date;
}
public String formatReleaseDate() {
return yearFmt.format(releaseDate);
}
}
JDO對一個需要存儲的類強加了一個要求：一個無參數的構造器。假如你在類代碼中不定義任何構造器，編譯器會自動產生一個無參數的構造器；而假如你定義了帶參構造器，你就必須再定義一個無參構造器，可以將其聲明為private以禁止外部訪問。假如你不定義這個無參構造器，一些JDO產品會自動為你產生一個，但這只是具體的JDO產品提供的功能，是不可移植的。 QQRead.com 推出數據恢復指南教程 數據恢復指南教程 數據恢復故障解析 常用數據恢復方案 硬盤數據恢復教程 數據保護方法 數據恢復軟件 專業數據恢復服務指南
作為異軍突起的新型語言，Java定義了一個標准的運行環境，用戶定義的類在其中得到執行。這些用戶自定義類的實例代表了真實環境中的數據，包括儲存在數據庫、文件或某些大型事務處理系統中的數據，而小型系統通常也需要一種在本地負責控制數據存儲的機制。
由於數據訪問技術在不同的數據源類型中是不一樣的，因此對數據進行訪問成了給程序開發人員的一種挑戰，程序員需要對每一種類型的數據源使用特定的編程接口（API），即必須至少知道兩種語言來基於這些數據源開發業務應用：Java語言和由數據源所決定的數據訪問語言。這種數據訪問語言一般根據數據源的不同而不同，這使得學習使用某種數據源的開發成本相應提升。
在Java數據對象技術（JDO）發布之前，通常有三種方式用於存儲Java數據：串行化（即Serialization，也稱序列化）、JDBC和EJB中的CMP（容控存儲）方式。串行化用於將某個對象的狀態，以及它所指向的其它對象結構圖全部寫到一個輸出流中（比如文件、網絡等等），它保證了被寫入的對象之間的關系，這樣一來，在另一時刻，這個對象結構圖可以完整地重新構造出來。但串行化不支持事務處理、查詢或者向不同的用戶共享數據。它只答應在最初串行化時的粒度（指訪問對象的接口精細程度）基礎上進行訪問，並且當應用中需要處理多種或多次串行化時很難維護。串行化只適用於最簡單的應用，或者在某些無法有效地支持數據庫的嵌入式系統中。
JDBC要求你明確地處理數據字段，並且將它們映射到關系數據庫的表中。開發人員被迫與兩種區別非常大的數據模型、語言和數據訪問手段打交道：Java，以及SQL中的關系數據模型。在開發中實現從關系數據模型到Java對象模型的映射是如此的復雜，以致於多數開發人員從不為數據定義對象模型；他們只是簡單地編寫過程化的Java代碼來對底層的關系數據庫中的數據表進行操縱。最終結果是：他們根本不能從面向對象的開發中得到任何好處。
EJB組件體系是被設計為支持分布式對象計算的。它也包括對容器治理持續性Container Managed Persistence（參見術語表）的支持來實現持續性。主要由於它們的分布式特性，EJB應用比起JDO來復雜得多，對資源的消耗也大得多。不過，JDO被設計成具有一定的靈活性，這樣一來，JDO產品都可以用來在底層實現EJB的存儲處理，從而與EJB容器結合起來。假如你的應用需要對象存儲，但不需要分布式的特性，你可以使用JDO來代替EJB組件。在EJB環境中最典型的JDO使用方案就是讓EJB中的對話組件（Session Bean）直接訪問JDO對象，避免使用實體組件（Entity Bean）。EJB組件必須運行在一個受控（Managed，參見術語表）的應用服務環境。但JDO應用可以運行在受控環境中，也可以運行在不受控的獨立環境中，這些使你可以靈活地選擇最合適的應用運行環境。
假如你將精力集中在設計Java對象模型上，然後用JDO來進行存儲你的數據類的實例，你將大大提高生產力和開發效率。你只需要處理一種信息模型。而JDBC則要求你理解關系模型和SQL語言（譯者注：JDO並不是要取代JDBC，而是建立在JDBC基礎上的一個抽象的中間層，提供更簡單的數據存儲接口）。即使是在使用EJB CMP（即容控存儲，參見術語表）的時候，你也不得不學習與EJB體系相關的許多其它方面的內容，並且在建模方面還有一些JDO中不存在的局限性。
JDO規范了JDO運行環境和你的可存儲對象類之間的約定。JDO被設計成支持多種數據源，包括一般情況下考慮不到的數據庫之類的數據源。從現在開始，我們使用數據庫（參見術語表）這一概念來表示任何你通過JDO來訪問的底層數據源。
定義數據對象模型
我們將建立一個UML類圖，顯示一個公司的對象模型的相關類以及相互之間的關系。一個Movie（電影）對象表示一部特定的電影。每個至少在一部電影中出演角色的演員由一個Actor（演員）對象代表。而Role（角色）類表示某個演員在某部電影中扮演的特定角色，因此Role類也表示了電影和演員之間的一種關系，這種關系包含一個屬性（電影中的角色名）。每部電影包含一到多個角色。每個演員可以在不同的電影中扮演不同的角色，甚至在同一部電影中扮演多個角色。
我們會將這些數據類以及操縱這些數據類實例的的程序放到com.mecdiamania.prototype包中。
需要存儲的類
我們定義Movie、Actor和Role這幾個類為可持續的，表示它們的實例是可以被儲存到數據庫中的。首先我們看看每個類的完整的源代碼。每個類中有一個package語句，因此可以很清楚地看到本例用到的每個類分別在哪個包中。
例1-1顯示了Movie類的源代碼。JDO是定義在javax.jdo包中的，注重這個類並不一定要導入任何具體的JDO類。Java中的引用和java.util包中的Collection及相關子類（接口）被用來表示我們的類之間的關系，這是大多數Java應用中的標准方式。
Movie類中的屬性使用Java中的標准類型，如String、Date、int等等。你可以將屬性聲明為private的，不需要對每一屬性定義相應的get和set方法。Movie類中還有一些用於訪問這些私有屬性的方法，盡管這些方法在程序中的其它部分會用到，但它們並不是JDO所要求的。你可以使用屬性包裝來提供僅僅是抽象建模所需要的方法。這個類還有一些靜態屬性（static的），這些屬性並不存儲到數據庫。
"genres"屬性是一個String型的，內容是該電影所屬的電影風格（動作、愛情、詭異等等）。一個Set接口用來表示該電影的演員表中的角色集合。"addRole()"方法將元素加入到演員表中，而"getCast()"方法返回一個不可以更改的集合，該集合中包含演員表。這些方法並不是JDO規定的，只是為了方便應用編程而編寫的。"parseReleaseDate()"方法和"formatReleaseDate()"方法用於將電影的發行日期標准化（格式化）。為了保持代碼的簡單，假如parseReleaseDate()的參數格式不對，將會返回null。
例1-1 Movie.java
package com.mediamania.prototype;
import java.util.Set;
import java.util.HashSet;
import java.util.Collections;
import java.util.Date;
import java.util.Calendar;
import java.text.SimpleDateFormat;
import java.text.ParsePosition;
public class Movie {
private static SimpleDateFormat yearFmt = new SimpleDateFormat("yyyy");
public static final String[] MPAAratings = {
"G", "PG", "PG-13", "R", "NC-17", "NR"};
private String title;
private Date releaseDate;
private int runningTime;
private String rating;
private String webSite;
private String genres;
private Set cast; // element type: Role
private Movie() {}
public Movie(String title, Date release, int duration, String rating,
String genres) {
this.title = title;
releaseDate = release;
runningTime = duration;
this.rating = rating;
this.genres = genres;
cast = new HashSet();
}
public String getTitle() {
return title;
}
public Date getReleaseDate() {
return releaseDate;
}
public String getRating() {
return rating;
}
public int getRunningTime() {
return runningTime;
}
public void setWebSite(String site) {
webSite = site;
}
public String getWebSite() {
return webSite;
}
public String getGenres() {
return genres;
}
public void addRole(Role role) {
cast.add(role);
}
public Set getCast() {
return Collections.unmodifiableSet(cast);
}
public static Date parseReleaseDate(String val) {
Date date = null;
try {
date = yearFmt.parse(val);
} catch (java.text.ParseException exc) {}
return date;
}
public String formatReleaseDate() {
return yearFmt.format(releaseDate);
}
}
JDO對一個需要存儲的類強加了一個要求：一個無參數的構造器。假如你在類代碼中不定義任何構造器，編譯器會自動產生一個無參數的構造器；而假如你定義了帶參構造器，你就必須再定義一個無參構造器，可以將其聲明為private以禁止外部訪問。假如你不定義這個無參構造器，一些JDO產品會自動為你產生一個，但這只是具體的JDO產品提供的功能，是不可移植的。 QQRead.com 推出數據恢復指南教程 數據恢復指南教程 數據恢復故障解析 常用數據恢復方案 硬盤數據恢復教程 數據保護方法 數據恢復軟件 專業數據恢復服務指南
作為異軍突起的新型語言，Java定義了一個標准的運行環境，用戶定義的類在其中得到執行。這些用戶自定義類的實例代表了真實環境中的數據，包括儲存在數據庫、文件或某些大型事務處理系統中的數據，而小型系統通常也需要一種在本地負責控制數據存儲的機制。
由於數據訪問技術在不同的數據源類型中是不一樣的，因此對數據進行訪問成了給程序開發人員的一種挑戰，程序員需要對每一種類型的數據源使用特定的編程接口（API），即必須至少知道兩種語言來基於這些數據源開發業務應用：Java語言和由數據源所決定的數據訪問語言。這種數據訪問語言一般根據數據源的不同而不同，這使得學習使用某種數據源的開發成本相應提升。
在Java數據對象技術（JDO）發布之前，通常有三種方式用於存儲Java數據：串行化（即Serialization，也稱序列化）、JDBC和EJB中的CMP（容控存儲）方式。串行化用於將某個對象的狀態，以及它所指向的其它對象結構圖全部寫到一個輸出流中（比如文件、網絡等等），它保證了被寫入的對象之間的關系，這樣一來，在另一時刻，這個對象結構圖可以完整地重新構造出來。但串行化不支持事務處理、查詢或者向不同的用戶共享數據。它只答應在最初串行化時的粒度（指訪問對象的接口精細程度）基礎上進行訪問，並且當應用中需要處理多種或多次串行化時很難維護。串行化只適用於最簡單的應用，或者在某些無法有效地支持數據庫的嵌入式系統中。
JDBC要求你明確地處理數據字段，並且將它們映射到關系數據庫的表中。開發人員被迫與兩種區別非常大的數據模型、語言和數據訪問手段打交道：Java，以及SQL中的關系數據模型。在開發中實現從關系數據模型到Java對象模型的映射是如此的復雜，以致於多數開發人員從不為數據定義對象模型；他們只是簡單地編寫過程化的Java代碼來對底層的關系數據庫中的數據表進行操縱。最終結果是：他們根本不能從面向對象的開發中得到任何好處。
EJB組件體系是被設計為支持分布式對象計算的。它也包括對容器治理持續性Container Managed Persistence（參見術語表）的支持來實現持續性。主要由於它們的分布式特性，EJB應用比起JDO來復雜得多，對資源的消耗也大得多。不過，JDO被設計成具有一定的靈活性，這樣一來，JDO產品都可以用來在底層實現EJB的存儲處理，從而與EJB容器結合起來。假如你的應用需要對象存儲，但不需要分布式的特性，你可以使用JDO來代替EJB組件。在EJB環境中最典型的JDO使用方案就是讓EJB中的對話組件（Session Bean）直接訪問JDO對象，避免使用實體組件（Entity Bean）。EJB組件必須運行在一個受控（Managed，參見術語表）的應用服務環境。但JDO應用可以運行在受控環境中，也可以運行在不受控的獨立環境中，這些使你可以靈活地選擇最合適的應用運行環境。
假如你將精力集中在設計Java對象模型上，然後用JDO來進行存儲你的數據類的實例，你將大大提高生產力和開發效率。你只需要處理一種信息模型。而JDBC則要求你理解關系模型和SQL語言（譯者注：JDO並不是要取代JDBC，而是建立在JDBC基礎上的一個抽象的中間層，提供更簡單的數據存儲接口）。即使是在使用EJB CMP（即容控存儲，參見術語表）的時候，你也不得不學習與EJB體系相關的許多其它方面的內容，並且在建模方面還有一些JDO中不存在的局限性。
JDO規范了JDO運行環境和你的可存儲對象類之間的約定。JDO被設計成支持多種數據源，包括一般情況下考慮不到的數據庫之類的數據源。從現在開始，我們使用數據庫（參見術語表）這一概念來表示任何你通過JDO來訪問的底層數據源。
定義數據對象模型
我們將建立一個UML類圖，顯示一個公司的對象模型的相關類以及相互之間的關系。一個Movie（電影）對象表示一部特定的電影。每個至少在一部電影中出演角色的演員由一個Actor（演員）對象代表。而Role（角色）類表示某個演員在某部電影中扮演的特定角色，因此Role類也表示了電影和演員之間的一種關系，這種關系包含一個屬性（電影中的角色名）。每部電影包含一到多個角色。每個演員可以在不同的電影中扮演不同的角色，甚至在同一部電影中扮演多個角色。
我們會將這些數據類以及操縱這些數據類實例的的程序放到com.mecdiamania.prototype包中。
需要存儲的類
我們定義Movie、Actor和Role這幾個類為可持續的，表示它們的實例是可以被儲存到數據庫中的。首先我們看看每個類的完整的源代碼。每個類中有一個package語句，因此可以很清楚地看到本例用到的每個類分別在哪個包中。
例1-1顯示了Movie類的源代碼。JDO是定義在javax.jdo包中的，注重這個類並不一定要導入任何具體的JDO類。Java中的引用和java.util包中的Collection及相關子類（接口）被用來表示我們的類之間的關系，這是大多數Java應用中的標准方式。
Movie類中的屬性使用Java中的標准類型，如String、Date、int等等。你可以將屬性聲明為private的，不需要對每一屬性定義相應的get和set方法。Movie類中還有一些用於訪問這些私有屬性的方法，盡管這些方法在程序中的其它部分會用到，但它們並不是JDO所要求的。你可以使用屬性包裝來提供僅僅是抽象建模所需要的方法。這個類還有一些靜態屬性（static的），這些屬性並不存儲到數據庫。
"genres"屬性是一個String型的，內容是該電影所屬的電影風格（動作、愛情、詭異等等）。一個Set接口用來表示該電影的演員表中的角色集合。"addRole()"方法將元素加入到演員表中，而"getCast()"方法返回一個不可以更改的集合，該集合中包含演員表。這些方法並不是JDO規定的，只是為了方便應用編程而編寫的。"parseReleaseDate()"方法和"formatReleaseDate()"方法用於將電影的發行日期標准化（格式化）。為了保持代碼的簡單，假如parseReleaseDate()的參數格式不對，將會返回null。
例1-1 Movie.java
package com.mediamania.prototype;
import java.util.Set;
import java.util.HashSet;
import java.util.Collections;
import java.util.Date;
import java.util.Calendar;
import java.text.SimpleDateFormat;
import java.text.ParsePosition;
public class Movie {
private static SimpleDateFormat yearFmt = new SimpleDateFormat("yyyy");
public static final String[] MPAAratings = {
"G", "PG", "PG-13", "R", "NC-17", "NR"};
private String title;
private Date releaseDate;
private int runningTime;
private String rating;
private String webSite;
private String genres;
private Set cast; // element type: Role
private Movie() {}
public Movie(String title, Date release, int duration, String rating,
String genres) {
this.title = title;
releaseDate = release;
runningTime = duration;
this.rating = rating;
this.genres = genres;
cast = new HashSet();
}
public String getTitle() {
return title;
}
public Date getReleaseDate() {
return releaseDate;
}
public String getRating() {
return rating;
}
public int getRunningTime() {
return runningTime;
}
public void setWebSite(String site) {
webSite = site;
}
public String getWebSite() {
return webSite;
}
public String getGenres() {
return genres;
}
public void addRole(Role role) {
cast.add(role);
}
public Set getCast() {
return Collections.unmodifiableSet(cast);
}
public static Date parseReleaseDate(String val) {
Date date = null;
try {
date = yearFmt.parse(val);
} catch (java.text.ParseException exc) {}
return date;
}
public String formatReleaseDate() {
return yearFmt.format(releaseDate);
}
}
JDO對一個需要存儲的類強加了一個要求：一個無參數的構造器。假如你在類代碼中不定義任何構造器，編譯器會自動產生一個無參數的構造器；而假如你定義了帶參構造器，你就必須再定義一個無參構造器，可以將其聲明為private以禁止外部訪問。假如你不定義這個無參構造器，一些JDO產品會自動為你產生一個，但這只是具體的JDO產品提供的功能，是不可移植的。 QQRead.com 推出數據恢復指南教程 數據恢復指南教程 數據恢復故障解析 常用數據恢復方案 硬盤數據恢復教程 數據保護方法 數據恢復軟件 專業數據恢復服務指南
作為異軍突起的新型語言，Java定義了一個標准的運行環境，用戶定義的類在其中得到執行。這些用戶自定義類的實例代表了真實環境中的數據，包括儲存在數據庫、文件或某些大型事務處理系統中的數據，而小型系統通常也需要一種在本地負責控制數據存儲的機制。
由於數據訪問技術在不同的數據源類型中是不一樣的，因此對數據進行訪問成了給程序開發人員的一種挑戰，程序員需要對每一種類型的數據源使用特定的編程接口（API），即必須至少知道兩種語言來基於這些數據源開發業務應用：Java語言和由數據源所決定的數據訪問語言。這種數據訪問語言一般根據數據源的不同而不同，這使得學習使用某種數據源的開發成本相應提升。
在Java數據對象技術（JDO）發布之前，通常有三種方式用於存儲Java數據：串行化（即Serialization，也稱序列化）、JDBC和EJB中的CMP（容控存儲）方式。串行化用於將某個對象的狀態，以及它所指向的其它對象結構圖全部寫到一個輸出流中（比如文件、網絡等等），它保證了被寫入的對象之間的關系，這樣一來，在另一時刻，這個對象結構圖可以完整地重新構造出來。但串行化不支持事務處理、查詢或者向不同的用戶共享數據。它只答應在最初串行化時的粒度（指訪問對象的接口精細程度）基礎上進行訪問，並且當應用中需要處理多種或多次串行化時很難維護。串行化只適用於最簡單的應用，或者在某些無法有效地支持數據庫的嵌入式系統中。
JDBC要求你明確地處理數據字段，並且將它們映射到關系數據庫的表中。開發人員被迫與兩種區別非常大的數據模型、語言和數據訪問手段打交道：Java，以及SQL中的關系數據模型。在開發中實現從關系數據模型到Java對象模型的映射是如此的復雜，以致於多數開發人員從不為數據定義對象模型；他們只是簡單地編寫過程化的Java代碼來對底層的關系數據庫中的數據表進行操縱。最終結果是：他們根本不能從面向對象的開發中得到任何好處。
EJB組件體系是被設計為支持分布式對象計算的。它也包括對容器治理持續性Container Managed Persistence（參見術語表）的支持來實現持續性。主要由於它們的分布式特性，EJB應用比起JDO來復雜得多，對資源的消耗也大得多。不過，JDO被設計成具有一定的靈活性，這樣一來，JDO產品都可以用來在底層實現EJB的存儲處理，從而與EJB容器結合起來。假如你的應用需要對象存儲，但不需要分布式的特性，你可以使用JDO來代替EJB組件。在EJB環境中最典型的JDO使用方案就是讓EJB中的對話組件（Session Bean）直接訪問JDO對象，避免使用實體組件（Entity Bean）。EJB組件必須運行在一個受控（Managed，參見術語表）的應用服務環境。但JDO應用可以運行在受控環境中，也可以運行在不受控的獨立環境中，這些使你可以靈活地選擇最合適的應用運行環境。
假如你將精力集中在設計Java對象模型上，然後用JDO來進行存儲你的數據類的實例，你將大大提高生產力和開發效率。你只需要處理一種信息模型。而JDBC則要求你理解關系模型和SQL語言（譯者注：JDO並不是要取代JDBC，而是建立在JDBC基礎上的一個抽象的中間層，提供更簡單的數據存儲接口）。即使是在使用EJB CMP（即容控存儲，參見術語表）的時候，你也不得不學習與EJB體系相關的許多其它方面的內容，並且在建模方面還有一些JDO中不存在的局限性。
JDO規范了JDO運行環境和你的可存儲對象類之間的約定。JDO被設計成支持多種數據源，包括一般情況下考慮不到的數據庫之類的數據源。從現在開始，我們使用數據庫（參見術語表）這一概念來表示任何你通過JDO來訪問的底層數據源。
定義數據對象模型
我們將建立一個UML類圖，顯示一個公司的對象模型的相關類以及相互之間的關系。一個Movie（電影）對象表示一部特定的電影。每個至少在一部電影中出演角色的演員由一個Actor（演員）對象代表。而Role（角色）類表示某個演員在某部電影中扮演的特定角色，因此Role類也表示了電影和演員之間的一種關系，這種關系包含一個屬性（電影中的角色名）。每部電影包含一到多個角色。每個演員可以在不同的電影中扮演不同的角色，甚至在同一部電影中扮演多個角色。
我們會將這些數據類以及操縱這些數據類實例的的程序放到com.mecdiamania.prototype包中。
需要存儲的類
我們定義Movie、Actor和Role這幾個類為可持續的，表示它們的實例是可以被儲存到數據庫中的。首先我們看看每個類的完整的源代碼。每個類中有一個package語句，因此可以很清楚地看到本例用到的每個類分別在哪個包中。
例1-1顯示了Movie類的源代碼。JDO是定義在javax.jdo包中的，注重這個類並不一定要導入任何具體的JDO類。Java中的引用和java.util包中的Collection及相關子類（接口）被用來表示我們的類之間的關系，這是大多數Java應用中的標准方式。
Movie類中的屬性使用Java中的標准類型，如String、Date、int等等。你可以將屬性聲明為private的，不需要對每一屬性定義相應的get和set方法。Movie類中還有一些用於訪問這些私有屬性的方法，盡管這些方法在程序中的其它部分會用到，但它們並不是JDO所要求的。你可以使用屬性包裝來提供僅僅是抽象建模所需要的方法。這個類還有一些靜態屬性（static的），這些屬性並不存儲到數據庫。
"genres"屬性是一個String型的，內容是該電影所屬的電影風格（動作、愛情、詭異等等）。一個Set接口用來表示該電影的演員表中的角色集合。"addRole()"方法將元素加入到演員表中，而"getCast()"方法返回一個不可以更改的集合，該集合中包含演員表。這些方法並不是JDO規定的，只是為了方便應用編程而編寫的。"parseReleaseDate()"方法和"formatReleaseDate()"方法用於將電影的發行日期標准化（格式化）。為了保持代碼的簡單，假如parseReleaseDate()的參數格式不對，將會返回null。
例1-1 Movie.java
package com.mediamania.prototype;
import java.util.Set;
import java.util.HashSet;
import java.util.Collections;
import java.util.Date;
import java.util.Calendar;
import java.text.SimpleDateFormat;
import java.text.ParsePosition;
public class Movie {
private static SimpleDateFormat yearFmt = new SimpleDateFormat("yyyy");
public static final String[] MPAAratings = {
"G", "PG", "PG-13", "R", "NC-17", "NR"};
private String title;
private Date releaseDate;
private int runningTime;
private String rating;
private String webSite;
private String genres;
private Set cast; // element type: Role
private Movie() {}
public Movie(String title, Date release, int duration, String rating,
String genres) {
this.title = title;
releaseDate = release;
runningTime = duration;
this.rating = rating;
this.genres = genres;
cast = new HashSet();
}
public String getTitle() {
return title;
}
public Date getReleaseDate() {
return releaseDate;
}
public String getRating() {
return rating;
}
public int getRunningTime() {
return runningTime;
}
public void setWebSite(String site) {
webSite = site;
}
public String getWebSite() {
return webSite;
}
public String getGenres() {
return genres;
}
public void addRole(Role role) {
cast.add(role);
}
public Set getCast() {
return Collections.unmodifiableSet(cast);
}
public static Date parseReleaseDate(String val) {
Date date = null;
try {
date = yearFmt.parse(val);
} catch (java.text.ParseException exc) {}
return date;
}
public String formatReleaseDate() {
return yearFmt.format(releaseDate);
}
}
JDO對一個需要存儲的類強加了一個要求：一個無參數的構造器。假如你在類代碼中不定義任何構造器，編譯器會自動產生一個無參數的構造器；而假如你定義了帶參構造器，你就必須再定義一個無參構造器，可以將其聲明為private以禁止外部訪問。假如你不定義這個無參構造器，一些JDO產品會自動為你產生一個，但這只是具體的JDO產品提供的功能，是不可移植的。 QQRead.com 推出數據恢復指南教程 數據恢復指南教程 數據恢復故障解析 常用數據恢復方案 硬盤數據恢復教程 數據保護方法 數據恢復軟件 專業數據恢復服務指南
作為異軍突起的新型語言，Java定義了一個標准的運行環境，用戶定義的類在其中得到執行。這些用戶自定義類的實例代表了真實環境中的數據，包括儲存在數據庫、文件或某些大型事務處理系統中的數據，而小型系統通常也需要一種在本地負責控制數據存儲的機制。
由於數據訪問技術在不同的數據源類型中是不一樣的，因此對數據進行訪問成了給程序開發人員的一種挑戰，程序員需要對每一種類型的數據源使用特定的編程接口（API），即必須至少知道兩種語言來基於這些數據源開發業務應用：Java語言和由數據源所決定的數據訪問語言。這種數據訪問語言一般根據數據源的不同而不同，這使得學習使用某種數據源的開發成本相應提升。
在Java數據對象技術（JDO）發布之前，通常有三種方式用於存儲Java數據：串行化（即Serialization，也稱序列化）、JDBC和EJB中的CMP（容控存儲）方式。串行化用於將某個對象的狀態，以及它所指向的其它對象結構圖全部寫到一個輸出流中（比如文件、網絡等等），它保證了被寫入的對象之間的關系，這樣一來，在另一時刻，這個對象結構圖可以完整地重新構造出來。但串行化不支持事務處理、查詢或者向不同的用戶共享數據。它只答應在最初串行化時的粒度（指訪問對象的接口精細程度）基礎上進行訪問，並且當應用中需要處理多種或多次串行化時很難維護。串行化只適用於最簡單的應用，或者在某些無法有效地支持數據庫的嵌入式系統中。
JDBC要求你明確地處理數據字段，並且將它們映射到關系數據庫的表中。開發人員被迫與兩種區別非常大的數據模型、語言和數據訪問手段打交道：Java，以及SQL中的關系數據模型。在開發中實現從關系數據模型到Java對象模型的映射是如此的復雜，以致於多數開發人員從不為數據定義對象模型；他們只是簡單地編寫過程化的Java代碼來對底層的關系數據庫中的數據表進行操縱。最終結果是：他們根本不能從面向對象的開發中得到任何好處。
EJB組件體系是被設計為支持分布式對象計算的。它也包括對容器治理持續性Container Managed Persistence（參見術語表）的支持來實現持續性。主要由於它們的分布式特性，EJB應用比起JDO來復雜得多，對資源的消耗也大得多。不過，JDO被設計成具有一定的靈活性，這樣一來，JDO產品都可以用來在底層實現EJB的存儲處理，從而與EJB容器結合起來。假如你的應用需要對象存儲，但不需要分布式的特性，你可以使用JDO來代替EJB組件。在EJB環境中最典型的JDO使用方案就是讓EJB中的對話組件（Session Bean）直接訪問JDO對象，避免使用實體組件（Entity Bean）。EJB組件必須運行在一個受控（Managed，參見術語表）的應用服務環境。但JDO應用可以運行在受控環境中，也可以運行在不受控的獨立環境中，這些使你可以靈活地選擇最合適的應用運行環境。
假如你將精力集中在設計Java對象模型上，然後用JDO來進行存儲你的數據類的實例，你將大大提高生產力和開發效率。你只需要處理一種信息模型。而JDBC則要求你理解關系模型和SQL語言（譯者注：JDO並不是要取代JDBC，而是建立在JDBC基礎上的一個抽象的中間層，提供更簡單的數據存儲接口）。即使是在使用EJB CMP（即容控存儲，參見術語表）的時候，你也不得不學習與EJB體系相關的許多其它方面的內容，並且在建模方面還有一些JDO中不存在的局限性。
JDO規范了JDO運行環境和你的可存儲對象類之間的約定。JDO被設計成支持多種數據源，包括一般情況下考慮不到的數據庫之類的數據源。從現在開始，我們使用數據庫（參見術語表）這一概念來表示任何你通過JDO來訪問的底層數據源。
定義數據對象模型
我們將建立一個UML類圖，顯示一個公司的對象模型的相關類以及相互之間的關系。一個Movie（電影）對象表示一部特定的電影。每個至少在一部電影中出演角色的演員由一個Actor（演員）對象代表。而Role（角色）類表示某個演員在某部電影中扮演的特定角色，因此Role類也表示了電影和演員之間的一種關系，這種關系包含一個屬性（電影中的角色名）。每部電影包含一到多個角色。每個演員可以在不同的電影中扮演不同的角色，甚至在同一部電影中扮演多個角色。
我們會將這些數據類以及操縱這些數據類實例的的程序放到com.mecdiamania.prototype包中。
需要存儲的類
我們定義Movie、Actor和Role這幾個類為可持續的，表示它們的實例是可以被儲存到數據庫中的。首先我們看看每個類的完整的源代碼。每個類中有一個package語句，因此可以很清楚地看到本例用到的每個類分別在哪個包中。
例1-1顯示了Movie類的源代碼。JDO是定義在javax.jdo包中的，注重這個類並不一定要導入任何具體的JDO類。Java中的引用和java.util包中的Collection及相關子類（接口）被用來表示我們的類之間的關系，這是大多數Java應用中的標准方式。
Movie類中的屬性使用Java中的標准類型，如String、Date、int等等。你可以將屬性聲明為private的，不需要對每一屬性定義相應的get和set方法。Movie類中還有一些用於訪問這些私有屬性的方法，盡管這些方法在程序中的其它部分會用到，但它們並不是JDO所要求的。你可以使用屬性包裝來提供僅僅是抽象建模所需要的方法。這個類還有一些靜態屬性（static的），這些屬性並不存儲到數據庫。
"genres"屬性是一個String型的，內容是該電影所屬的電影風格（動作、愛情、詭異等等）。一個Set接口用來表示該電影的演員表中的角色集合。"addRole()"方法將元素加入到演員表中，而"getCast()"方法返回一個不可以更改的集合，該集合中包含演員表。這些方法並不是JDO規定的，只是為了方便應用編程而編寫的。"parseReleaseDate()"方法和"formatReleaseDate()"方法用於將電影的發行日期標准化（格式化）。為了保持代碼的簡單，假如parseReleaseDate()的參數格式不對，將會返回null。
例1-1 Movie.java
package com.mediamania.prototype;
import java.util.Set;
import java.util.HashSet;
import java.util.Collections;
import java.util.Date;
import java.util.Calendar;
import java.text.SimpleDateFormat;
import java.text.ParsePosition;
public class Movie {
private static SimpleDateFormat yearFmt = new SimpleDateFormat("yyyy");
public static final String[] MPAAratings = {
"G", "PG", "PG-13", "R", "NC-17", "NR"};
private String title;
private Date releaseDate;
private int runningTime;
private String rating;
private String webSite;
private String genres;
private Set cast; // element type: Role
private Movie() {}
public Movie(String title, Date release, int duration, String rating,
String genres) {
this.title = title;
releaseDate = release;
runningTime = duration;
this.rating = rating;
this.genres = genres;
cast = new HashSet();
}
public String getTitle() {
return title;
}
public Date getReleaseDate() {
return releaseDate;
}
public String getRating() {
return rating;
}
public int getRunningTime() {
return runningTime;
}
public void setWebSite(String site) {
webSite = site;
}
public String getWebSite() {
return webSite;
}
public String getGenres() {
return genres;
}
public void addRole(Role role) {
cast.add(role);
}
public Set getCast() {
return Collections.unmodifiableSet(cast);
}
public static Date parseReleaseDate(String val) {
Date date = null;
try {
date = yearFmt.parse(val);
} catch (java.text.ParseException exc) {}
return date;
}
public String formatReleaseDate() {
return yearFmt.format(releaseDate);
}
}
JDO對一個需要存儲的類強加了一個要求：一個無參數的構造器。假如你在類代碼中不定義任何構造器，編譯器會自動產生一個無參數的構造器；而假如你定義了帶參構造器，你就必須再定義一個無參構造器，可以將其聲明為private以禁止外部訪問。假如你不定義這個無參構造器，一些JDO產品會自動為你產生一個，但這只是具體的JDO產品提供的功能，是不可移植的。
作為異軍突起的新型語言，Java定義了一個標准的運行環境，用戶定義的類在其中得到執行。這些用戶自定義類的實例代表了真實環境中的數據，包括儲存在數據庫、文件或某些大型事務處理系統中的數據，而小型系統通常也需要一種在本地負責控制數據存儲的機制。
由於數據訪問技術在不同的數據源類型中是不一樣的，因此對數據進行訪問成了給程序開發人員的一種挑戰，程序員需要對每一種類型的數據源使用特定的編程接口（API），即必須至少知道兩種語言來基於這些數據源開發業務應用：Java語言和由數據源所決定的數據訪問語言。這種數據訪問語言一般根據數據源的不同而不同，這使得學習使用某種數據源的開發成本相應提升。
在Java數據對象技術（JDO）發布之前，通常有三種方式用於存儲Java數據：串行化（即Serialization，也稱序列化）、JDBC和EJB中的CMP（容控存儲）方式。串行化用於將某個對象的狀態，以及它所指向的其它對象結構圖全部寫到一個輸出流中（比如文件、網絡等等），它保證了被寫入的對象之間的關系，這樣一來，在另一時刻，這個對象結構圖可以完整地重新構造出來。但串行化不支持事務處理、查詢或者向不同的用戶共享數據。它只答應在最初串行化時的粒度（指訪問對象的接口精細程度）基礎上進行訪問，並且當應用中需要處理多種或多次串行化時很難維護。串行化只適用於最簡單的應用，或者在某些無法有效地支持數據庫的嵌入式系統中。
JDBC要求你明確地處理數據字段，並且將它們映射到關系數據庫的表中。開發人員被迫與兩種區別非常大的數據模型、語言和數據訪問手段打交道：Java，以及SQL中的關系數據模型。在開發中實現從關系數據模型到Java對象模型的映射是如此的復雜，以致於多數開發人員從不為數據定義對象模型；他們只是簡單地編寫過程化的Java代碼來對底層的關系數據庫中的數據表進行操縱。最終結果是：他們根本不能從面向對象的開發中得到任何好處。
EJB組件體系是被設計為支持分布式對象計算的。它也包括對容器治理持續性Container Managed Persistence（參見術語表）的支持來實現持續性。主要由於它們的分布式特性，EJB應用比起JDO來復雜得多，對資源的消耗也大得多。不過，JDO被設計成具有一定的靈活性，這樣一來，JDO產品都可以用來在底層實現EJB的存儲處理，從而與EJB容器結合起來。假如你的應用需要對象存儲，但不需要分布式的特性，你可以使用JDO來代替EJB組件。在EJB環境中最典型的JDO使用方案就是讓EJB中的對話組件（Session Bean）直接訪問JDO對象，避免使用實體組件（Entity Bean）。EJB組件必須運行在一個受控（Managed，參見術語表）的應用服務環境。但JDO應用可以運行在受控環境中，也可以運行在不受控的獨立環境中，這些使你可以靈活地選擇最合適的應用運行環境。
假如你將精力集中在設計Java對象模型上，然後用JDO來進行存儲你的數據類的實例，你將大大提高生產力和開發效率。你只需要處理一種信息模型。而JDBC則要求你理解關系模型和SQL語言（譯者注：JDO並不是要取代JDBC，而是建立在JDBC基礎上的一個抽象的中間層，提供更簡單的數據存儲接口）。即使是在使用EJB CMP（即容控存儲，參見術語表）的時候，你也不得不學習與EJB體系相關的許多其它方面的內容，並且在建模方面還有一些JDO中不存在的局限性。
JDO規范了JDO運行環境和你的可存儲對象類之間的約定。JDO被設計成支持多種數據源，包括一般情況下考慮不到的數據庫之類的數據源。從現在開始，我們使用數據庫（參見術語表）這一概念來表示任何你通過JDO來訪問的底層數據源。
定義數據對象模型
我們將建立一個UML類圖，顯示一個公司的對象模型的相關類以及相互之間的關系。一個Movie（電影）對象表示一部特定的電影。每個至少在一部電影中出演角色的演員由一個Actor（演員）對象代表。而Role（角色）類表示某個演員在某部電影中扮演的特定角色，因此Role類也表示了電影和演員之間的一種關系，這種關系包含一個屬性（電影中的角色名）。每部電影包含一到多個角色。每個演員可以在不同的電影中扮演不同的角色，甚至在同一部電影中扮演多個角色。
我們會將這些數據類以及操縱這些數據類實例的的程序放到com.mecdiamania.prototype包中。
需要存儲的類
我們定義Movie、Actor和Role這幾個類為可持續的，表示它們的實例是可以被儲存到數據庫中的。首先我們看看每個類的完整的源代碼。每個類中有一個package語句，因此可以很清楚地看到本例用到的每個類分別在哪個包中。
例1-1顯示了Movie類的源代碼。JDO是定義在javax.jdo包中的，注重這個類並不一定要導入任何具體的JDO類。Java中的引用和java.util包中的Collection及相關子類（接口）被用來表示我們的類之間的關系，這是大多數Java應用中的標准方式。
Movie類中的屬性使用Java中的標准類型，如String、Date、int等等。你可以將屬性聲明為private的，不需要對每一屬性定義相應的get和set方法。Movie類中還有一些用於訪問這些私有屬性的方法，盡管這些方法在程序中的其它部分會用到，但它們並不是JDO所要求的。你可以使用屬性包裝來提供僅僅是抽象建模所需要的方法。這個類還有一些靜態屬性（static的），這些屬性並不存儲到數據庫。
"genres"屬性是一個String型的，內容是該電影所屬的電影風格（動作、愛情、詭異等等）。一個Set接口用來表示該電影的演員表中的角色集合。"addRole()"方法將元素加入到演員表中，而"getCast()"方法返回一個不可以更改的集合，該集合中包含演員表。這些方法並不是JDO規定的，只是為了方便應用編程而編寫的。"parseReleaseDate()"方法和"formatReleaseDate()"方法用於將電影的發行日期標准化（格式化）。為了保持代碼的簡單，假如parseReleaseDate()的參數格式不對，將會返回null。
例1-1 Movie.java
package com.mediamania.prototype;
import java.util.Set;
import java.util.HashSet;
import java.util.Collections;
import java.util.Date;
import java.util.Calendar;
import java.text.SimpleDateFormat;
import java.text.ParsePosition;
public class Movie {
private static SimpleDateFormat yearFmt = new SimpleDateFormat("yyyy");
public static final String[] MPAAratings = {
"G", "PG", "PG-13", "R", "NC-17", "NR"};
private String title;
private Date releaseDate;
private int runningTime;
private String rating;
private String webSite;
private String genres;
private Set cast; // element type: Role
private Movie() {}
public Movie(String title, Date release, int duration, String rating,
String genres) {
this.title = title;
releaseDate = release;
runningTime = duration;
this.rating = rating;
this.genres = genres;
cast = new HashSet();
}
public String getTitle() {
return title;
}
public Date getReleaseDate() {
return releaseDate;
}
public String getRating() {
return rating;
}
public int getRunningTime() {
return runningTime;
}
public void setWebSite(String site) {
webSite = site;
}
public String getWebSite() {
return webSite;
}
public String getGenres() {
return genres;
}
public void addRole(Role role) {
cast.add(role);
}
public Set getCast() {
return Collections.unmodifiableSet(cast);
}
public static Date parseReleaseDate(String val) {
Date date = null;
try {
date = yearFmt.parse(val);
} catch (java.text.ParseException exc) {}
return date;
}
public String formatReleaseDate() {
return yearFmt.format(releaseDate);
}
}
JDO對一個需要存儲的類強加了一個要求：一個無參數的構造器。假如你在類代碼中不定義任何構造器，編譯器會自動產生一個無參數的構造器；而假如你定義了帶參構造器，你就必須再定義一個無參構造器，可以將其聲明為private以禁止外部訪問。假如你不定義這個無參構造器，一些JDO產品會自動為你產生一個，但這只是具體的JDO產品提供的功能，是不可移植的。
作為異軍突起的新型語言，Java定義了一個標准的運行環境，用戶定義的類在其中得到執行。這些用戶自定義類的實例代表了真實環境中的數據，包括儲存在數據庫、文件或某些大型事務處理系統中的數據，而小型系統通常也需要一種在本地負責控制數據存儲的機制。
由於數據訪問技術在不同的數據源類型中是不一樣的，因此對數據進行訪問成了給程序開發人員的一種挑戰，程序員需要對每一種類型的數據源使用特定的編程接口（API），即必須至少知道兩種語言來基於這些數據源開發業務應用：Java語言和由數據源所決定的數據訪問語言。這種數據訪問語言一般根據數據源的不同而不同，這使得學習使用某種數據源的開發成本相應提升。
在Java數據對象技術（JDO）發布之前，通常有三種方式用於存儲Java數據：串行化（即Serialization，也稱序列化）、JDBC和EJB中的CMP（容控存儲）方式。串行化用於將某個對象的狀態，以及它所指向的其它對象結構圖全部寫到一個輸出流中（比如文件、網絡等等），它保證了被寫入的對象之間的關系，這樣一來，在另一時刻，這個對象結構圖可以完整地重新構造出來。但串行化不支持事務處理、查詢或者向不同的用戶共享數據。它只答應在最初串行化時的粒度（指訪問對象的接口精細程度）基礎上進行訪問，並且當應用中需要處理多種或多次串行化時很難維護。串行化只適用於最簡單的應用，或者在某些無法有效地支持數據庫的嵌入式系統中。
JDBC要求你明確地處理數據字段，並且將它們映射到關系數據庫的表中。開發人員被迫與兩種區別非常大的數據模型、語言和數據訪問手段打交道：Java，以及SQL中的關系數據模型。在開發中實現從關系數據模型到Java對象模型的映射是如此的復雜，以致於多數開發人員從不為數據定義對象模型；他們只是簡單地編寫過程化的Java代碼來對底層的關系數據庫中的數據表進行操縱。最終結果是：他們根本不能從面向對象的開發中得到任何好處。
EJB組件體系是被設計為支持分布式對象計算的。它也包括對容器治理持續性Container Managed Persistence（參見術語表）的支持來實現持續性。主要由於它們的分布式特性，EJB應用比起JDO來復雜得多，對資源的消耗也大得多。不過，JDO被設計成具有一定的靈活性，這樣一來，JDO產品都可以用來在底層實現EJB的存儲處理，從而與EJB容器結合起來。假如你的應用需要對象存儲，但不需要分布式的特性，你可以使用JDO來代替EJB組件。在EJB環境中最典型的JDO使用方案就是讓EJB中的對話組件（Session Bean）直接訪問JDO對象，避免使用實體組件（Entity Bean）。EJB組件必須運行在一個受控（Managed，參見術語表）的應用服務環境。但JDO應用可以運行在受控環境中，也可以運行在不受控的獨立環境中，這些使你可以靈活地選擇最合適的應用運行環境。
假如你將精力集中在設計Java對象模型上，然後用JDO來進行存儲你的數據類的實例，你將大大提高生產力和開發效率。你只需要處理一種信息模型。而JDBC則要求你理解關系模型和SQL語言（譯者注：JDO並不是要取代JDBC，而是建立在JDBC基礎上的一個抽象的中間層，提供更簡單的數據存儲接口）。即使是在使用EJB CMP（即容控存儲，參見術語表）的時候，你也不得不學習與EJB體系相關的許多其它方面的內容，並且在建模方面還有一些JDO中不存在的局限性。
JDO規范了JDO運行環境和你的可存儲對象類之間的約定。JDO被設計成支持多種數據源，包括一般情況下考慮不到的數據庫之類的數據源。從現在開始，我們使用數據庫（參見術語表）這一概念來表示任何你通過JDO來訪問的底層數據源。
定義數據對象模型
我們將建立一個UML類圖，顯示一個公司的對象模型的相關類以及相互之間的關系。一個Movie（電影）對象表示一部特定的電影。每個至少在一部電影中出演角色的演員由一個Actor（演員）對象代表。而Role（角色）類表示某個演員在某部電影中扮演的特定角色，因此Role類也表示了電影和演員之間的一種關系，這種關系包含一個屬性（電影中的角色名）。每部電影包含一到多個角色。每個演員可以在不同的電影中扮演不同的角色，甚至在同一部電影中扮演多個角色。
我們會將這些數據類以及操縱這些數據類實例的的程序放到com.mecdiamania.prototype包中。
需要存儲的類
我們定義Movie、Actor和Role這幾個類為可持續的，表示它們的實例是可以被儲存到數據庫中的。首先我們看看每個類的完整的源代碼。每個類中有一個package語句，因此可以很清楚地看到本例用到的每個類分別在哪個包中。
例1-1顯示了Movie類的源代碼。JDO是定義在javax.jdo包中的，注重這個類並不一定要導入任何具體的JDO類。Java中的引用和java.util包中的Collection及相關子類（接口）被用來表示我們的類之間的關系，這是大多數Java應用中的標准方式。
Movie類中的屬性使用Java中的標准類型，如String、Date、int等等。你可以將屬性聲明為private的，不需要對每一屬性定義相應的get和set方法。Movie類中還有一些用於訪問這些私有屬性的方法，盡管這些方法在程序中的其它部分會用到，但它們並不是JDO所要求的。你可以使用屬性包裝來提供僅僅是抽象建模所需要的方法。這個類還有一些靜態屬性（static的），這些屬性並不存儲到數據庫。
"genres"屬性是一個String型的，內容是該電影所屬的電影風格（動作、愛情、詭異等等）。一個Set接口用來表示該電影的演員表中的角色集合。"addRole()"方法將元素加入到演員表中，而"getCast()"方法返回一個不可以更改的集合，該集合中包含演員表。這些方法並不是JDO規定的，只是為了方便應用編程而編寫的。"parseReleaseDate()"方法和"formatReleaseDate()"方法用於將電影的發行日期標准化（格式化）。為了保持代碼的簡單，假如parseReleaseDate()的參數格式不對，將會返回null。
例1-1 Movie.java
package com.mediamania.prototype;
import java.util.Set;
import java.util.HashSet;
import java.util.Collections;
import java.util.Date;
import java.util.Calendar;
import java.text.SimpleDateFormat;
import java.text.ParsePosition;
public class Movie {
private static SimpleDateFormat yearFmt = new SimpleDateFormat("yyyy");
public static final String[] MPAAratings = {
"G", "PG", "PG-13", "R", "NC-17", "NR"};
private String title;
private Date releaseDate;
private int runningTime;
private String rating;
private String webSite;
private String genres;
private Set cast; // element type: Role
private Movie() {}
public Movie(String title, Date release, int duration, String rating,
String genres) {
this.title = title;
releaseDate = release;
runningTime = duration;
this.rating = rating;
this.genres = genres;
cast = new HashSet();
}
public String getTitle() {
return title;
}
public Date getReleaseDate() {
return releaseDate;
}
public String getRating() {
return rating;
}
public int getRunningTime() {
return runningTime;
}
public void setWebSite(String site) {
webSite = site;
}
public String getWebSite() {
return webSite;
}
public String getGenres() {
return genres;
}
public void addRole(Role role) {
cast.add(role);
}
public Set getCast() {
return Collections.unmodifiableSet(cast);
}
public static Date parseReleaseDate(String val) {
Date date = null;
try {
date = yearFmt.parse(val);
} catch (java.text.ParseException exc) {}
return date;
}
public String formatReleaseDate() {
return yearFmt.format(releaseDate);
}
}
JDO對一個需要存儲的類強加了一個要求：一個無參數的構造器。假如你在類代碼中不定義任何構造器，編譯器會自動產生一個無參數的構造器；而假如你定義了帶參構造器，你就必須再定義一個無參構造器，可以將其聲明為private以禁止外部訪問。假如你不定義這個無參構造器，一些JDO產品會自動為你產生一個，但這只是具體的JDO產品提供的功能，是不可移植的。
作為異軍突起的新型語言，Java定義了一個標准的運行環境，用戶定義的類在其中得到執行。這些用戶自定義類的實例代表了真實環境中的數據，包括儲存在數據庫、文件或某些大型事務處理系統中的數據，而小型系統通常也需要一種在本地負責控制數據存儲的機制。
由於數據訪問技術在不同的數據源類型中是不一樣的，因此對數據進行訪問成了給程序開發人員的一種挑戰，程序員需要對每一種類型的數據源使用特定的編程接口（API），即必須至少知道兩種語言來基於這些數據源開發業務應用：Java語言和由數據源所決定的數據訪問語言。這種數據訪問語言一般根據數據源的不同而不同，這使得學習使用某種數據源的開發成本相應提升。
在Java數據對象技術（JDO）發布之前，通常有三種方式用於存儲Java數據：串行化（即Serialization，也稱序列化）、JDBC和EJB中的CMP（容控存儲）方式。串行化用於將某個對象的狀態，以及它所指向的其它對象結構圖全部寫到一個輸出流中（比如文件、網絡等等），它保證了被寫入的對象之間的關系，這樣一來，在另一時刻，這個對象結構圖可以完整地重新構造出來。但串行化不支持事務處理、查詢或者向不同的用戶共享數據。它只答應在最初串行化時的粒度（指訪問對象的接口精細程度）基礎上進行訪問，並且當應用中需要處理多種或多次串行化時很難維護。串行化只適用於最簡單的應用，或者在某些無法有效地支持數據庫的嵌入式系統中。
JDBC要求你明確地處理數據字段，並且將它們映射到關系數據庫的表中。開發人員被迫與兩種區別非常大的數據模型、語言和數據訪問手段打交道：Java，以及SQL中的關系數據模型。在開發中實現從關系數據模型到Java對象模型的映射是如此的復雜，以致於多數開發人員從不為數據定義對象模型；他們只是簡單地編寫過程化的Java代碼來對底層的關系數據庫中的數據表進行操縱。最終結果是：他們根本不能從面向對象的開發中得到任何好處。
EJB組件體系是被設計為支持分布式對象計算的。它也包括對容器治理持續性Container Managed Persistence（參見術語表）的支持來實現持續性。主要由於它們的分布式特性，EJB應用比起JDO來復雜得多，對資源的消耗也大得多。不過，JDO被設計成具有一定的靈活性，這樣一來，JDO產品都可以用來在底層實現EJB的存儲處理，從而與EJB容器結合起來。假如你的應用需要對象存儲，但不需要分布式的特性，你可以使用JDO來代替EJB組件。在EJB環境中最典型的JDO使用方案就是讓EJB中的對話組件（Session Bean）直接訪問JDO對象，避免使用實體組件（Entity Bean）。EJB組件必須運行在一個受控（Managed，參見術語表）的應用服務環境。但JDO應用可以運行在受控環境中，也可以運行在不受控的獨立環境中，這些使你可以靈活地選擇最合適的應用運行環境。
假如你將精力集中在設計Java對象模型上，然後用JDO來進行存儲你的數據類的實例，你將大大提高生產力和開發效率。你只需要處理一種信息模型。而JDBC則要求你理解關系模型和SQL語言（譯者注：JDO並不是要取代JDBC，而是建立在JDBC基礎上的一個抽象的中間層，提供更簡單的數據存儲接口）。即使是在使用EJB CMP（即容控存儲，參見術語表）的時候，你也不得不學習與EJB體系相關的許多其它方面的內容，並且在建模方面還有一些JDO中不存在的局限性。
JDO規范了JDO運行環境和你的可存儲對象類之間的約定。JDO被設計成支持多種數據源，包括一般情況下考慮不到的數據庫之類的數據源。從現在開始，我們使用數據庫（參見術語表）這一概念來表示任何你通過JDO來訪問的底層數據源。
定義數據對象模型
我們將建立一個UML類圖，顯示一個公司的對象模型的相關類以及相互之間的關系。一個Movie（電影）對象表示一部特定的電影。每個至少在一部電影中出演角色的演員由一個Actor（演員）對象代表。而Role（角色）類表示某個演員在某部電影中扮演的特定角色，因此Role類也表示了電影和演員之間的一種關系，這種關系包含一個屬性（電影中的角色名）。每部電影包含一到多個角色。每個演員可以在不同的電影中扮演不同的角色，甚至在同一部電影中扮演多個角色。
我們會將這些數據類以及操縱這些數據類實例的的程序放到com.mecdiamania.prototype包中。
需要存儲的類
我們定義Movie、Actor和Role這幾個類為可持續的，表示它們的實例是可以被儲存到數據庫中的。首先我們看看每個類的完整的源代碼。每個類中有一個package語句，因此可以很清楚地看到本例用到的每個類分別在哪個包中。
例1-1顯示了Movie類的源代碼。JDO是定義在javax.jdo包中的，注重這個類並不一定要導入任何具體的JDO類。Java中的引用和java.util包中的Collection及相關子類（接口）被用來表示我們的類之間的關系，這是大多數Java應用中的標准方式。
Movie類中的屬性使用Java中的標准類型，如String、Date、int等等。你可以將屬性聲明為private的，不需要對每一屬性定義相應的get和set方法。Movie類中還有一些用於訪問這些私有屬性的方法，盡管這些方法在程序中的其它部分會用到，但它們並不是JDO所要求的。你可以使用屬性包裝來提供僅僅是抽象建模所需要的方法。這個類還有一些靜態屬性（static的），這些屬性並不存儲到數據庫。
"genres"屬性是一個String型的，內容是該電影所屬的電影風格（動作、愛情、詭異等等）。一個Set接口用來表示該電影的演員表中的角色集合。"addRole()"方法將元素加入到演員表中，而"getCast()"方法返回一個不可以更改的集合，該集合中包含演員表。這些方法並不是JDO規定的，只是為了方便應用編程而編寫的。"parseReleaseDate()"方法和"formatReleaseDate()"方法用於將電影的發行日期標准化（格式化）。為了保持代碼的簡單，假如parseReleaseDate()的參數格式不對，將會返回null。
例1-1 Movie.java
package com.mediamania.prototype;
import java.util.Set;
import java.util.HashSet;
import java.util.Collections;
import java.util.Date;
import java.util.Calendar;
import java.text.SimpleDateFormat;
import java.text.ParsePosition;
public class Movie {
private static SimpleDateFormat yearFmt = new SimpleDateFormat("yyyy");
public static final String[] MPAAratings = {
"G", "PG", "PG-13", "R", "NC-17", "NR"};
private String title;
private Date releaseDate;
private int runningTime;
private String rating;
private String webSite;
private String genres;
private Set cast; // element type: Role
private Movie() {}
public Movie(String title, Date release, int duration, String rating,
String genres) {
this.title = title;
releaseDate = release;
runningTime = duration;
this.rating = rating;
this.genres = genres;
cast = new HashSet();
}
public String getTitle() {
return title;
}
public Date getReleaseDate() {
return releaseDate;
}
public String getRating() {
return rating;
}
public int getRunningTime() {
return runningTime;
}
public void setWebSite(String site) {
webSite = site;
}
public String getWebSite() {
return webSite;
}
public String getGenres() {
return genres;
}
public void addRole(Role role) {
cast.add(role);
}
public Set getCast() {
return Collections.unmodifiableSet(cast);
}
public static Date parseReleaseDate(String val) {
Date date = null;
try {
date = yearFmt.parse(val);
} catch (java.text.ParseException exc) {}
return date;
}
public String formatReleaseDate() {
return yearFmt.format(releaseDate);
}
}
JDO對一個需要存儲的類強加了一個要求：一個無參數的構造器。假如你在類代碼中不定義任何構造器，編譯器會自動產生一個無參數的構造器；而假如你定義了帶參構造器，你就必須再定義一個無參構造器，可以將其聲明為private以禁止外部訪問。假如你不定義這個無參構造器，一些JDO產品會自動為你產生一個，但這只是具體的JDO產品提供的功能，是不可移植的。
作為異軍突起的新型語言，Java定義了一個標准的運行環境，用戶定義的類在其中得到執行。這些用戶自定義類的實例代表了真實環境中的數據，包括儲存在數據庫、文件或某些大型事務處理系統中的數據，而小型系統通常也需要一種在本地負責控制數據存儲的機制。
由於數據訪問技術在不同的數據源類型中是不一樣的，因此對數據進行訪問成了給程序開發人員的一種挑戰，程序員需要對每一種類型的數據源使用特定的編程接口（API），即必須至少知道兩種語言來基於這些數據源開發業務應用：Java語言和由數據源所決定的數據訪問語言。這種數據訪問語言一般根據數據源的不同而不同，這使得學習使用某種數據源的開發成本相應提升。
在Java數據對象技術（JDO）發布之前，通常有三種方式用於存儲Java數據：串行化（即Serialization，也稱序列化）、JDBC和EJB中的CMP（容
