datanucleus

如官方產品站點所述， 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
• Hibernate 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>

兩個“測試基礎”項目之間唯一不同的文件是“ persistence.xml”文件，該文件定義了要使用的Java持久性API（JPA）的實際實現。 以下是我們用來利用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
• 提升您的Hibernate引擎

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

datanucleus

總結

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

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