如官方產品站點所述， DataNucleus Access Platform是現有的最符合標準的開源Java持久性產品。 它完全符合JDO1 ， JDO2 ， JDO2.1 ， JDO2.2 ， JDO3 ， JPA1和JPA2 Java標準。 它還符合OGC簡單功能規范，以將地理空間Java類型保留到RDBMS。 它使用基于OSGi的插件機制，這意味著它是非常可擴展的。

如產品官方“關于”頁面所述， Hibernate是一種高性能的對象/關系持久性和查詢服務。 Hibernate是市場上最靈活，功能最強大的對象/關系解決方案，它負責從Java類到數據庫表以及從Java數據類型到SQL數據類型的映射。 它提供了數據查詢和檢索功能，大大減少了開發時間。

出于本文的目的，我們將使用上述眾所周知的產品作為持久性API的實際實現。 我們的目標是能夠比較對數據庫應用CRUD（創建-檢索-更新-刪除）操作時的性能。

為此，我們將實現兩個不同的基于Spring的WEB應用程序，這些應用程序將充當我們的“測試基礎”。 這兩個應用程序的服務和數據訪問層定義（接口和實現類）將完全相同。 對于數據訪問，我們將利用JPA2作為Java Persistence API。 對于數據庫，我們將使用嵌入式Derby實例。 最后但并非最不重要的一點是，我們將針對以下所述的五個“基本”數據訪問操作實施并執行相同的性能測試：

• 保持記錄
• 通過其ID檢索記錄
• 檢索所有記錄
• 更新現有記錄
• 刪除記錄

所有測試均針對具有以下特征的Sony Vaio進行：

• 系統：openSUSE 11.1（x86_64）
• 處理器（CPU）：Intel（R）Core（TM）2 Duo CPU T6670 @ 2.20GHz
• 處理器速度：1,200.00 MHz
• 總內存（RAM）：2.8 GB
• Java：OpenJDK 1.6.0_0 64位

使用以下工具：

• Spring框架3.0.1
• Apache Derby 10.6.1.0
• 休眠 3.5.1
• DataNucleus 3.0.0-m1
• c3p0 0.9.1.2
• Brent Boyer的Java Benchmarking框架

最終通知：

• 您可以在此處和此處下載兩個“測試基礎”的完整源代碼。 這些是基于Eclipse – Maven的項目。
• 為了能夠自己編譯和運行測試，您需要將Java Benchmarking框架二進制– jar文件安裝到Maven存儲庫。 另外，作為“一鍵式”解決方案，您可以使用我們創建的Java Benchmarking Maven軟件包。 您可以從此處下載它，然后將其解壓縮到您的Maven存儲庫中，一切都很好。

“測試基地”…

我們將首先提供有關如何實施“測試基礎”項目的信息。 為了使我們的測試所針對的環境的細節清晰明了，這勢在必行。 如前所述，我們已經實現了兩個基于Spring的多層WEB應用程序。 在每個應用程序中，已經實現了兩層，即服務層和數據訪問層。 這些層具有相同的定義-接口和實現細節。

我們的領域模型僅包含一個“雇員”對象。 服務層提供了一個簡單的“業務”服務，該服務公開了“員工”對象的CRUD（創建-檢索-更新-刪除）功能，而數據訪問層則包括一個簡單的數據訪問對象，該對象利用Spring JpaDaoSupport抽象來提供與數據庫的實際互操作性。

以下是數據訪問層特定的類：

import javax.annotation.PostConstruct; import javax.persistence.EntityManagerFactory;import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Repository;import com.javacodegeeks.springdatanucleus.dto.EmployeeDTO;@Repository("employeeDAO") public class EmployeeDAO extends JpaDAO<Long, EmployeeDTO> {@AutowiredEntityManagerFactory entityManagerFactory;@PostConstructpublic void init() {super.setEntityManagerFactory(entityManagerFactory);}}

如您所見，我們的數據訪問對象（DAO）擴展了JpaDAO類。 該課程如下：

import java.lang.reflect.ParameterizedType; import java.util.List;import javax.persistence.EntityManager; import javax.persistence.PersistenceException; import javax.persistence.Query;import org.springframework.orm.jpa.JpaCallback; import org.springframework.orm.jpa.support.JpaDaoSupport;public abstract class JpaDAO<K, E> extends JpaDaoSupport {protected Class<E> entityClass;@SuppressWarnings("unchecked")public JpaDAO() {ParameterizedType genericSuperclass = (ParameterizedType) getClass().getGenericSuperclass();this.entityClass = (Class<E>) genericSuperclass.getActualTypeArguments()[1];}public void persist(E entity) {getJpaTemplate().persist(entity);}public void remove(E entity) {getJpaTemplate().remove(entity);}public E merge(E entity) {return getJpaTemplate().merge(entity);}public void refresh(E entity) {getJpaTemplate().refresh(entity);}public E findById(K id) {return getJpaTemplate().find(entityClass, id);}public E flush(E entity) {getJpaTemplate().flush();return entity;}@SuppressWarnings("unchecked")public List<E> findAll() {Object res = getJpaTemplate().execute(new JpaCallback() {public Object doInJpa(EntityManager em) throws PersistenceException {Query q = em.createQuery("SELECT h FROM " +entityClass.getName() + " h");return q.getResultList();}});return (List<E>) res;}@SuppressWarnings("unchecked")public Integer removeAll() {return (Integer) getJpaTemplate().execute(new JpaCallback() {public Object doInJpa(EntityManager em) throws PersistenceException {Query q = em.createQuery("DELETE FROM " +entityClass.getName() + " h");return q.executeUpdate();}});}}

以下是我們的域類EmployeeDTO類：

import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.Id; import javax.persistence.Table;@Entity @Table(name = "EMPLOYEE") public class EmployeeDTO implements java.io.Serializable {private static final long serialVersionUID = 7440297955003302414L;@Id@Column(name="employee_id")private long employeeId;@Column(name="employee_name", nullable = false, length=30)private String employeeName;@Column(name="employee_surname", nullable = false, length=30)private String employeeSurname;@Column(name="job", length=50)private String job;public EmployeeDTO() {}public EmployeeDTO(int employeeId) {this.employeeId = employeeId; }public EmployeeDTO(long employeeId, String employeeName, String employeeSurname,String job) {this.employeeId = employeeId;this.employeeName = employeeName;this.employeeSurname = employeeSurname;this.job = job;}public long getEmployeeId() {return employeeId;}public void setEmployeeId(long employeeId) {this.employeeId = employeeId;}public String getEmployeeName() {return employeeName;}public void setEmployeeName(String employeeName) {this.employeeName = employeeName;}public String getEmployeeSurname() {return employeeSurname;}public void setEmployeeSurname(String employeeSurname) {this.employeeSurname = employeeSurname;}public String getJob() {return job;}public void setJob(String job) {this.job = job;} }

最后但并非最不重要的是，下面提供了“業務”服務接口和實現類：

import java.util.List;import com.javacodegeeks.springdatanucleus.dto.EmployeeDTO;public interface EmployeeService {public EmployeeDTO findEmployee(long employeeId);public List<EmployeeDTO> findAllEmployees();public void saveEmployee(long employeeId, String name, String surname, String jobDescription) throws Exception;public void updateEmployee(long employeeId, String name, String surname, String jobDescription) throws Exception;public void saveOrUpdateEmployee(long employeeId, String name, String surname, String jobDescription) throws Exception;public void deleteEmployee(long employeeId) throws Exception;}import java.util.List;import javax.annotation.PostConstruct; import javax.annotation.PreDestroy;import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional;import com.javacodegeeks.springdatanucleus.dao.EmployeeDAO; import com.javacodegeeks.springdatanucleus.dto.EmployeeDTO; import com.javacodegeeks.springdatanucleus.services.EmployeeService;@Service("employeeService") public class EmployeeServiceImpl implements EmployeeService {@Autowiredprivate EmployeeDAO employeeDAO;@PostConstructpublic void init() throws Exception {}@PreDestroypublic void destroy() {}public EmployeeDTO findEmployee(long employeeId) {return employeeDAO.findById(employeeId);}public List<EmployeeDTO> findAllEmployees() {return employeeDAO.findAll();}@Transactional(propagation=Propagation.REQUIRED, rollbackFor=Exception.class)public void saveEmployee(long employeeId, String name, String surname, String jobDescription) throws Exception {EmployeeDTO employeeDTO = employeeDAO.findById(employeeId);if(employeeDTO == null) {employeeDTO = new EmployeeDTO(employeeId, name,surname, jobDescription);employeeDAO.persist(employeeDTO);}}@Transactional(propagation=Propagation.REQUIRED, rollbackFor=Exception.class)public void updateEmployee(long employeeId, String name, String surname, String jobDescription) throws Exception {EmployeeDTO employeeDTO = employeeDAO.findById(employeeId);if(employeeDTO != null) {employeeDTO.setEmployeeName(name);employeeDTO.setEmployeeSurname(surname);employeeDTO.setJob(jobDescription);}}@Transactional(propagation=Propagation.REQUIRED, rollbackFor=Exception.class)public void deleteEmployee(long employeeId) throws Exception {EmployeeDTO employeeDTO = employeeDAO.findById(employeeId);if(employeeDTO != null)employeeDAO.remove(employeeDTO);}@Transactional(propagation=Propagation.REQUIRED, rollbackFor=Exception.class)public void saveOrUpdateEmployee(long employeeId, String name, String surname, String jobDescription) throws Exception {EmployeeDTO employeeDTO = new EmployeeDTO(employeeId, name,surname, jobDescription);employeeDAO.merge(employeeDTO);}}

接下來是驅動Spring IoC容器的“ applicationContext.xml”文件。 在兩個“測試基礎”項目之間，該文件的內容也相同。

<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"xmlns:task="http://www.springframework.org/schema/task"xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsdhttp://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsdhttp://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsdhttp://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsdhttp://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd"><context:component-scan base-package="com.javacodegeeks.springdatanucleus" /><tx:annotation-driven /><bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean"><property name="persistenceUnitName" value="MyPersistenceUnit" /></bean><bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"><property name="entityManagerFactory" ref="entityManagerFactory" /></bean></beans>

為了能夠從Servlet容器啟動Spring應用程序（別忘了我們已經實現了基于Spring的WEB應用程序），我們在兩個“測試基礎”應用程序的“ web.xml”文件中都包含了以下偵聽器：

<listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener>

這兩個“測試基礎”項目之間唯一不同的文件是定義要使用的Java持久性API（JPA）的實際實現的文件-“ persistence.xml”文件。 以下是我們用來利用DataNucleus Access Platform的平臺：

<persistence xmlns="http://java.sun.com/xml/ns/persistence"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"version="2.0"><persistence-unit name="MyPersistenceUnit" transaction-type="RESOURCE_LOCAL"><provider>org.datanucleus.api.jpa.PersistenceProviderImpl</provider><class>com.javacodegeeks.springdatanucleus.dto.EmployeeDTO</class><exclude-unlisted-classes>true</exclude-unlisted-classes><properties><property name="datanucleus.storeManagerType" value="rdbms"/><property name="datanucleus.ConnectionDriverName" value="org.apache.derby.jdbc.EmbeddedDriver"/><property name="datanucleus.ConnectionURL" value="jdbc:derby:runtime;create=true"/><!-- <property name="datanucleus.ConnectionUserName" value=""/><property name="datanucleus.ConnectionPassword" value=""/>--><property name="datanucleus.autoCreateSchema" value="true"/><property name="datanucleus.validateTables" value="false"/><property name="datanucleus.validateConstraints" value="false"/><property name="datanucleus.connectionPoolingType" value="C3P0"/><property name="datanucleus.connectionPool.minPoolSize" value="5" /><property name="datanucleus.connectionPool.initialPoolSize" value="5" /><property name="datanucleus.connectionPool.maxPoolSize" value="20" /><property name="datanucleus.connectionPool.maxStatements" value="50" /></properties></persistence-unit></persistence>

接下來是用于將Hibernate用作JPA2實現框架的“ persistence.xml”文件：

<persistence xmlns="http://java.sun.com/xml/ns/persistence"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"version="2.0"><persistence-unit name="MyPersistenceUnit" transaction-type="RESOURCE_LOCAL"><provider>org.hibernate.ejb.hibernatePersistence</provider><class>com.javacodegeeks.springhibernate.dto.EmployeeDTO</class><exclude-unlisted-classes>true</exclude-unlisted-classes><properties><property name="hibernate.hbm2ddl.auto" value="update" /><property name="hibernate.show_sql" value="false" /><property name="hibernate.dialect" value="org.hibernate.dialect.DerbyDialect" /><property name="hibernate.connection.driver_class" value="org.apache.derby.jdbc.EmbeddedDriver" /><property name="hibernate.connection.url" value="jdbc:derby:runtime;create=true" /><!-- <property name="hibernate.connection.username" value="" /><property name="hibernate.connection.password" value="" />--><property name="hibernate.c3p0.min_size" value="5" /><property name="hibernate.c3p0.max_size" value="20" /><property name="hibernate.c3p0.timeout" value="300" /><property name="hibernate.c3p0.max_statements" value="50" /><property name="hibernate.c3p0.idle_test_period" value="3000" /></properties></persistence-unit></persistence>

最后，我們演示實現所有要執行的測試用例的類。 這兩個“測試基礎”項目的類是相同的：

import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; import static org.junit.Assert.fail;import java.util.List; import java.util.concurrent.Callable;import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;import bb.util.Benchmark;import com.javacodegeeks.springhibernate.dto.EmployeeDTO; import com.javacodegeeks.springhibernate.services.EmployeeService;@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations={"file:src/main/webapp/WEB-INF/applicationContext.xml"}) public class EmployeeServiceTest {@AutowiredEmployeeService employeeService;@Testpublic void testSaveEmployee() {try {employeeService.saveEmployee(1, "byron", "kiourtzoglou", "master software engineer");employeeService.saveEmployee(2, "ilias", "tsagklis", "senior software engineer");} catch (Exception e) {fail(e.getMessage());}}@Testpublic void testFindEmployee() {assertNotNull(employeeService.findEmployee(1));}@Testpublic void testFindAllEmployees() {assertEquals(employeeService.findAllEmployees().size(), 2);}@Testpublic void testUpdateEmployee() {try {employeeService.updateEmployee(1, "panagiotis", "paterakis", "senior software engineer");assertEquals(employeeService.findEmployee(1).getEmployeeName(), "panagiotis");} catch (Exception e) {fail(e.getMessage());}}@Testpublic void testDeleteEmployee() {try {employeeService.deleteEmployee(1);assertNull(employeeService.findEmployee(1));} catch (Exception e) {fail(e.getMessage());}}@Testpublic void testSaveOrUpdateEmployee() {try {employeeService.saveOrUpdateEmployee(1, "byron", "kiourtzoglou", "master software engineer");assertEquals(employeeService.findEmployee(1).getEmployeeName(), "byron");} catch (Exception e) {fail(e.getMessage());}}@Testpublic void stressTestSaveEmployee() {Callable<Integer> task = new Callable<Integer>() { public Integer call() throws Exception {int i;for(i = 3;i < 2048; i++) {employeeService.saveEmployee(i, "name-" + i, "surname-" + i, "developer-" + i);}return i;}};try {System.out.println("saveEmployee(...): " + new Benchmark(task, false, 2045));} catch (Exception e) {fail(e.getMessage());}assertNotNull(employeeService.findEmployee(1024));}@Testpublic void stressTestFindEmployee() {Callable<Integer> task = new Callable<Integer>() { public Integer call() { int i;for(i = 1;i < 2048; i++) {employeeService.findEmployee(i);}return i;}};try {System.out.println("findEmployee(...): " + new Benchmark(task, 2047));} catch (Exception e) {fail(e.getMessage());}}@Testpublic void stressTestFindAllEmployees() {Callable<List<EmployeeDTO>> task = new Callable<List<EmployeeDTO>>() { public List<EmployeeDTO> call() {return employeeService.findAllEmployees();}};try {System.out.println("findAllEmployees(): " + new Benchmark(task));} catch (Exception e) {fail(e.getMessage());}}@Testpublic void stressTestUpdateEmployee() {Callable<Integer> task = new Callable<Integer>() { public Integer call() throws Exception { int i;for(i=1;i<2048;i++) {employeeService.updateEmployee(i, "new_name-" + i, "new_surname-" + i, "new_developer-" + i);}return i;}};try {System.out.println("updateEmployee(...): " + new Benchmark(task, false, 2047));} catch (Exception e) {fail(e.getMessage());}assertEquals("new_name-1", employeeService.findEmployee(1).getEmployeeName());}@Testpublic void stressTestDeleteEmployee() {Callable<Integer> task = new Callable<Integer>() { public Integer call() throws Exception {int i;for(i = 1;i < 2048; i++) {employeeService.deleteEmployee(i);}return i;}};try {System.out.println("deleteEmployee(...): " + new Benchmark(task, false, 2047));} catch (Exception e) {fail(e.getMessage());}assertEquals(true, employeeService.findAllEmployees().isEmpty());}}

結果 …

下圖顯示了所有測試結果。 縱軸表示每個測試的平均執行時間（以微秒（us）為單位），因此值越低越好。 橫軸表示測試類型。 從上面的測試案例中可以看到，我們在數據庫中插入了總數為2047個“員工”記錄。 對于檢索測試用例（findEmployee（…）和findAllEmployees（…）），基準測試框架對每個測試用例進行了60次重復，以計算統計數據。 所有其他測試用例僅執行一次。

如您所見，在每個測試用例中， Hibernate的性能都優于DataNucleus 。 特別是在通過ID（查找）方案進行檢索時， Hibernate比DataNucleus快9倍！

我認為DataNucleus是一個很好的平臺。 當您要處理所有形式的數據（無論存儲在何處）時，可以使用它。 從數據持久性到異構數據存儲，到提供使用多種查詢語言進行檢索的方法。

使用這種多功能平臺來管理應用程序數據的主要優點是，您無需花費大量時間來學習特定數據存儲或查詢語言的特殊性。 另外，您可以對所有數據使用單個通用接口，因此您的團隊可以將他們的應用程序開發時間集中在添加業務邏輯上，并讓DataNucleus處理數據管理問題。

另一方面，多功能性要付出代價。 作為關系映射（ORM）框架的“硬核”對象， Hibernate在我們所有的ORM測試中均輕松勝過DataNucleus 。

像大多數時候一樣，由應用程序架構師決定最適合其需求的功能（多功能性或性能），直到DataNucleus團隊將其產品開發到可以勝過Hibernate的地步為止；-)

祝您編碼愉快，不要忘記分享！

拜倫

相關文章：

• 每個程序員都應該知道的事情
• 正確記錄應用程序的10個技巧
• 軟件設計法則
• Java最佳實踐系列
• 生存在狂野西部開發過程中的9條提示
• 如何在不到1ms的延遲內完成100K TPS
• 提升您的休眠引擎

翻譯自: https://www.javacodegeeks.com/2011/02/datanucleus-30-vs-hibernate-35.html

總結

以上是生活随笔為你收集整理的DataNucleus 3.0与Hibernate 3.5的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。