用HSQLDB数据库测试Hibernate和Spring

最新推荐文章于 2020-06-17 22:06:55 发布

Herman-Hong

最新推荐文章于 2020-06-17 22:06:55 发布

阅读量2.1k

点赞数

分类专栏： java 数据库文章标签： hsqldb spring hibernate

java 同时被 2 个专栏收录

135 篇文章 1 订阅

订阅专栏

数据库

23 篇文章 0 订阅

订阅专栏

原文地址：

http://www.informit.com/guides/content.aspx?g=java&seqNum=507

用Hibernate编写应用程序时，你的首要目标是制定正确的域模型，包括对象和关系，然后让Hibernate担心这些持久化的对象到你选择的数据库方言的转变。它总是一个好主意，在您运行的应用程序中来测试您的对象与具体的数据库方言，但是从一个单元测试的角度来看，你真的只关注Hibernate的对象和它们之间的关系。正因为如此，Hypersonic SQL数据库（HSQLDB）提供了一种简单的机制来启动数据库单元测试，来验证您的域模型是正确的。

顺便插一句：HSQLDB(HyperSQL DataBase)是一个开放源代码的JAVA数据库，其具有标准的SQL语法和JAVA接口，它可以自由使用和分发，非常简洁和快速的。在其官网可以获得最新的程序源代码及jar包文件(当前版本为2.3.4)。

HSQLDB非常适合在用于快速的测试和演示的Java程序中。做单元测试也非常理想。

HSQLDB不适合管理大型数据，例如百万数量级记录的数据库应用。HSQLDB简介它具有Server模式，进程内模式(In-Process)和内存模式(Memory-Only)三种。运行HSQLDB需要hsqldb.jar包, 它包含了一些组件和程序。

Hypersonic可以在多种模式下运行，但本次讨论的最大的区别有以下两种模式：

Standalone server
In-Memory server

作为一个独立的服务器运行时，就像任何其他的数据库，您可以使用：启动数据库，然后连接和断开它作为必要HSQLDB运行。但是，从单元测试的角度来看，HSQLDB可以运行在内存中的数据库。这意味着，当你创建一个JDBC连接，创建在非数据库连接。HSQLDB的运行模式，在这种模式下，由您提供的JDBC URL。他们有下列口味：

Stand-alone server: jdbc:hsqldb:hsql://machine/dbname
In-memory: jdbc:hsqldb:mem:dbname
In-memory from a script: dbc:hsqldb:file:path-to-file

内存中的文件模式之间的区别是：在内存中的数据库是空的，但初始化数据文件模式。我已经在过去的战略是创建一个独立的数据库，允许Hibernate的创建表，并添加为我的数据，将数据保存到一个脚本，然后使用基于文件的URL指向的脚本。有关脚本的好处是，它是原始的SQL，所以你可以自由预先填充数据库中你要测试的任何数据。

例如，清单1显示了一个示例HSQLDB创建一个数据库，并预先填充产品，产品类别以及用户脚本。

清单1 、naturalfoods.script
[sql] view plain copy print ?
1. CREATE SCHEMA PUBLIC AUTHORIZATION DBA
3. CREATE MEMORY TABLE CUSTOMER(CUSTOMER_ID BIGINT GENERATED BY DEFAULT AS IDENTITY(START WITH 1) NOT NULL
4. PRIMARY KEY,CUSTOMER_FIRSTNAME VARCHAR(128),CUSTOMER_LASTNAME VARCHAR(128),CUSTOMER_EMAIL
5. VARCHAR(128),CUSTOMER_PASSWORD VARCHAR(64))
7. CREATE MEMORY TABLE ADDRESS(ADDRESS_ID BIGINT GENERATED BY DEFAULT AS IDENTITY(START WITH 1) NOT NULL
8. PRIMARY KEY,ADDRESS_ADDRESS1 VARCHAR(255),ADDRESS_ADDRESS2 VARCHAR(255),ADDRESS_CITY
9. VARCHAR(255),ADDRESS_STATE VARCHAR(255),ADDRESS_ZIP VARCHAR(255),CUSTOMER_ID BIGINT NOT NULL,CONSTRAINT
10. FKE66327D46DF50C34 FOREIGN KEY(CUSTOMER_ID) REFERENCES CUSTOMER(CUSTOMER_ID))
12. CREATE MEMORY TABLE CATEGORY(CATEGORY_ID BIGINT GENERATED BY DEFAULT AS IDENTITY(START WITH 1) NOT NULL
13. PRIMARY KEY,CATEGORY_NAME VARCHAR(255))
15. CREATE MEMORY TABLE ORDER_ITEM(ORDER_ITEM_ID BIGINT GENERATED BY DEFAULT AS IDENTITY(START WITH 1) NOT NULL
16. PRIMARY KEY,ORDER_ITEM_QUANTITY INTEGER,ORDER_ID BIGINT NOT NULL,PRODUCT_ID BIGINT NOT NULL)
18. CREATE MEMORY TABLE PRODUCT(PRODUCT_ID BIGINT GENERATED BY DEFAULT AS IDENTITY(START WITH 1) NOT NULL
19. PRIMARY KEY,PRODUCT_NAME VARCHAR(255),PRODUCT_PRICE DOUBLE,PRODUCT_DESCRIPTION VARCHAR(255),
20. PRODUCT_INVENTORY INTEGER)
22. CREATE MEMORY TABLE PRODUCT_CATEGORIES(PRODUCT_ID BIGINT NOT NULL,CATEGORY_ID BIGINT NOT NULL,
23. PRIMARY KEY(PRODUCT_ID,CATEGORY_ID),CONSTRAINT FK5A93E78C121E7834 FOREIGN KEY(CATEGORY_ID)
24. REFERENCES CATEGORY(CATEGORY_ID),CONSTRAINT FK5A93E78CF8BBB8E0 FOREIGN KEY(PRODUCT_ID) REFERENCES
25. PRODUCT(PRODUCT_ID))
27. CREATE MEMORY TABLE ORDERS(ORDER_ID BIGINT GENERATED BY DEFAULT AS IDENTITY(START WITH 1) NOT NULL
28. PRIMARY KEY,ORDER_SUBTOTAL DOUBLE,ORDER_TAX DOUBLE,ORDER_TOTAL DOUBLE,CUSTOMER_ID BIGINT NOT NULL,
29. ADDRESS_ID BIGINT NOT NULL,CONSTRAINT FK8B7256E5AE379EC0 FOREIGN KEY(ADDRESS_ID)
30. REFERENCES ADDRESS(ADDRESS_ID),CONSTRAINT FK8B7256E56DF50C34 FOREIGN KEY(CUSTOMER_ID)
31. REFERENCES CUSTOMER(CUSTOMER_ID))
33. ALTER TABLE ORDER_ITEM ADD CONSTRAINT FK4BBDE984F8BBB8E0 FOREIGN KEY(PRODUCT_ID)
34. REFERENCES PRODUCT(PRODUCT_ID)
36. ALTER TABLE ORDER_ITEM ADD CONSTRAINT FK4BBDE984715B5200 FOREIGN KEY(ORDER_ID)
37. REFERENCES ORDERS(ORDER_ID)
39. ALTER TABLE CUSTOMER ALTER COLUMN CUSTOMER_ID RESTART WITH 16
41. ALTER TABLE ADDRESS ALTER COLUMN ADDRESS_ID RESTART WITH 1
43. ALTER TABLE CATEGORY ALTER COLUMN CATEGORY_ID RESTART WITH 6
45. ALTER TABLE ORDER_ITEM ALTER COLUMN ORDER_ITEM_ID RESTART WITH 1
47. ALTER TABLE PRODUCT ALTER COLUMN PRODUCT_ID RESTART WITH 7
49. ALTER TABLE ORDERS ALTER COLUMN ORDER_ID RESTART WITH 1
51. CREATE USER SA PASSWORD ""
53. GRANT DBA TO SA
55. SET WRITE_DELAY 10
57. SET SCHEMA PUBLIC
59. INSERT INTO CUSTOMER VALUES(1,'Steven','Haines','steve@javasrc.com','steve')
61. INSERT INTO CATEGORY VALUES(1,'Fruit')
63. INSERT INTO CATEGORY VALUES(2,'Vegetables')
65. INSERT INTO CATEGORY VALUES(3,'Meat')
67. INSERT INTO CATEGORY VALUES(4,'Dairy')
69. INSERT INTO CATEGORY VALUES(5,'Organic')
71. INSERT INTO PRODUCT VALUES(1,'Apple',0.25E0,'Food',10)
73. INSERT INTO PRODUCT VALUES(2,'Orange',0.5E0,'Food',10)
75. INSERT INTO PRODUCT VALUES(3,'Banana',0.75E0,'Food',0)
77. INSERT INTO PRODUCT VALUES(4,'Peas',1.5E0,'Food',10)
79. INSERT INTO PRODUCT VALUES(5,'Carrots',1.0E0,'Food',10)
81. INSERT INTO PRODUCT VALUES(6,'Organic Apple',0.75E0,'Food',10)
83. INSERT INTO PRODUCT_CATEGORIES VALUES(1,1)
85. INSERT INTO PRODUCT_CATEGORIES VALUES(2,1)
87. INSERT INTO PRODUCT_CATEGORIES VALUES(3,1)
89. INSERT INTO PRODUCT_CATEGORIES VALUES(4,2)
91. INSERT INTO PRODUCT_CATEGORIES VALUES(5,2)
93. INSERT INTO PRODUCT_CATEGORIES VALUES(6,1)
95. INSERT INTO PRODUCT_CATEGORIES VALUES(6,5)
```
CREATE SCHEMA PUBLIC AUTHORIZATION DBA

CREATE MEMORY TABLE CUSTOMER(CUSTOMER_ID BIGINT GENERATED BY DEFAULT AS IDENTITY(START WITH 1) NOT NULL 
PRIMARY KEY,CUSTOMER_FIRSTNAME VARCHAR(128),CUSTOMER_LASTNAME VARCHAR(128),CUSTOMER_EMAIL 
VARCHAR(128),CUSTOMER_PASSWORD VARCHAR(64))

CREATE MEMORY TABLE ADDRESS(ADDRESS_ID BIGINT GENERATED BY DEFAULT AS IDENTITY(START WITH 1) NOT NULL 
PRIMARY KEY,ADDRESS_ADDRESS1 VARCHAR(255),ADDRESS_ADDRESS2 VARCHAR(255),ADDRESS_CITY 
VARCHAR(255),ADDRESS_STATE VARCHAR(255),ADDRESS_ZIP VARCHAR(255),CUSTOMER_ID BIGINT NOT NULL,CONSTRAINT
 FKE66327D46DF50C34 FOREIGN KEY(CUSTOMER_ID) REFERENCES CUSTOMER(CUSTOMER_ID))

CREATE MEMORY TABLE CATEGORY(CATEGORY_ID BIGINT GENERATED BY DEFAULT AS IDENTITY(START WITH 1) NOT NULL 
PRIMARY KEY,CATEGORY_NAME VARCHAR(255))

CREATE MEMORY TABLE ORDER_ITEM(ORDER_ITEM_ID BIGINT GENERATED BY DEFAULT AS IDENTITY(START WITH 1) NOT NULL
 PRIMARY KEY,ORDER_ITEM_QUANTITY INTEGER,ORDER_ID BIGINT NOT NULL,PRODUCT_ID BIGINT NOT NULL)

CREATE MEMORY TABLE PRODUCT(PRODUCT_ID BIGINT GENERATED BY DEFAULT AS IDENTITY(START WITH 1) NOT NULL 
PRIMARY KEY,PRODUCT_NAME VARCHAR(255),PRODUCT_PRICE DOUBLE,PRODUCT_DESCRIPTION VARCHAR(255),
PRODUCT_INVENTORY INTEGER)

CREATE MEMORY TABLE PRODUCT_CATEGORIES(PRODUCT_ID BIGINT NOT NULL,CATEGORY_ID BIGINT NOT NULL,
PRIMARY KEY(PRODUCT_ID,CATEGORY_ID),CONSTRAINT FK5A93E78C121E7834 FOREIGN KEY(CATEGORY_ID) 
REFERENCES CATEGORY(CATEGORY_ID),CONSTRAINT FK5A93E78CF8BBB8E0 FOREIGN KEY(PRODUCT_ID) REFERENCES 
PRODUCT(PRODUCT_ID))

CREATE MEMORY TABLE ORDERS(ORDER_ID BIGINT GENERATED BY DEFAULT AS IDENTITY(START WITH 1) NOT NULL 
PRIMARY KEY,ORDER_SUBTOTAL DOUBLE,ORDER_TAX DOUBLE,ORDER_TOTAL DOUBLE,CUSTOMER_ID BIGINT NOT NULL,
ADDRESS_ID BIGINT NOT NULL,CONSTRAINT FK8B7256E5AE379EC0 FOREIGN KEY(ADDRESS_ID) 
REFERENCES ADDRESS(ADDRESS_ID),CONSTRAINT FK8B7256E56DF50C34 FOREIGN KEY(CUSTOMER_ID) 
REFERENCES CUSTOMER(CUSTOMER_ID))

ALTER TABLE ORDER_ITEM ADD CONSTRAINT FK4BBDE984F8BBB8E0 FOREIGN KEY(PRODUCT_ID) 
REFERENCES PRODUCT(PRODUCT_ID)

ALTER TABLE ORDER_ITEM ADD CONSTRAINT FK4BBDE984715B5200 FOREIGN KEY(ORDER_ID) 
REFERENCES ORDERS(ORDER_ID)

ALTER TABLE CUSTOMER ALTER COLUMN CUSTOMER_ID RESTART WITH 16

ALTER TABLE ADDRESS ALTER COLUMN ADDRESS_ID RESTART WITH 1

ALTER TABLE CATEGORY ALTER COLUMN CATEGORY_ID RESTART WITH 6

ALTER TABLE ORDER_ITEM ALTER COLUMN ORDER_ITEM_ID RESTART WITH 1

ALTER TABLE PRODUCT ALTER COLUMN PRODUCT_ID RESTART WITH 7

ALTER TABLE ORDERS ALTER COLUMN ORDER_ID RESTART WITH 1

CREATE USER SA PASSWORD ""

GRANT DBA TO SA

SET WRITE_DELAY 10

SET SCHEMA PUBLIC

INSERT INTO CUSTOMER VALUES(1,'Steven','Haines','steve@javasrc.com','steve')

INSERT INTO CATEGORY VALUES(1,'Fruit')

INSERT INTO CATEGORY VALUES(2,'Vegetables')

INSERT INTO CATEGORY VALUES(3,'Meat')

INSERT INTO CATEGORY VALUES(4,'Dairy')

INSERT INTO CATEGORY VALUES(5,'Organic')

INSERT INTO PRODUCT VALUES(1,'Apple',0.25E0,'Food',10)

INSERT INTO PRODUCT VALUES(2,'Orange',0.5E0,'Food',10)

INSERT INTO PRODUCT VALUES(3,'Banana',0.75E0,'Food',0)

INSERT INTO PRODUCT VALUES(4,'Peas',1.5E0,'Food',10)

INSERT INTO PRODUCT VALUES(5,'Carrots',1.0E0,'Food',10)

INSERT INTO PRODUCT VALUES(6,'Organic Apple',0.75E0,'Food',10)

INSERT INTO PRODUCT_CATEGORIES VALUES(1,1)

INSERT INTO PRODUCT_CATEGORIES VALUES(2,1)

INSERT INTO PRODUCT_CATEGORIES VALUES(3,1)

INSERT INTO PRODUCT_CATEGORIES VALUES(4,2)

INSERT INTO PRODUCT_CATEGORIES VALUES(5,2)

INSERT INTO PRODUCT_CATEGORIES VALUES(6,1)

INSERT INTO PRODUCT_CATEGORIES VALUES(6,5)
```
这个脚本可能不是你想手工编写的（至少不是表的创建），但你应该简单的INSERT语句填充数据表。

在本节的例子中，我将演示如何测试一个Spring Hibernate的DAO类。如果你不熟悉Spring和Hibernate的集成，使用Spring的HibernateDaoSupport类，请参阅我的文章Spring和Hibernate Java集成参考指南。总之，Spring提供了一个非常优雅与Hibernate集成，允许你创建一个数据源，该数据源注入到会话工厂bean，并扩展HibernateDaoSupport成一个类，然后注入该会话工厂。然后，从实现的角度看，您只需致电getHibernateTemplate（）并执行类似的方法你可能会发现在Hibernate的Session类，如saveOrUpdate（）、find（）或delete（） 。清单2显示了我的applicationContext.xml的文件，我的测试案例的内容。

清单2、applicationContext.xml中
[html] view plain copy print ?
1. <?xml version="1.0" encoding="UTF-8"?>
2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
3. "http://www.springframework.org/dtd/spring-beans.dtd">
4. <beans>
6. <bean id="productDao" class="com.naturalfoods.product.dao.HibernateProductDaoImpl">
7. <property name="sessionFactory" ref="sessionFactory" />
8. </bean>
10. <bean id="customerDao" class="com.naturalfoods.customer.dao.HibernateCustomerDaoImpl">
11. <property name="sessionFactory" ref="sessionFactory" />
12. </bean>
14. 
15. <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
16. <property name="driverClassName" value="org.hsqldb.jdbcDriver" />
17. <property name="url" value="jdbc:hsqldb:mem:naturalfoods" />
18. <property name="username" value="sa" />
19. <property name="password" value="" />
20. <property name="initialSize" value="5" />
21. <property name="maxActive" value="10" />
22. <property name="poolPreparedStatements" value="true" />
23. <property name="maxOpenPreparedStatements" value="10" />
24. </bean>
26. 
27. <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
28. <property name="dataSource" ref="dataSource" />
29. <property name="annotatedClasses">
30. <list>
31. <value>com.naturalfoods.model.Address</value>
32. <value>com.naturalfoods.model.Category</value>
33. <value>com.naturalfoods.model.Customer</value>
34. <value>com.naturalfoods.model.Order</value>
35. <value>com.naturalfoods.model.OrderItem</value>
36. <value>com.naturalfoods.model.Product</value>
37. </list>
38. </property>
39. <property name="hibernateProperties">
40. <props>
41. <prop key="hibernate.dialect">org.hibernate.dialect.HSQLDialect</prop>
42. <prop key="hibernate.hbm2ddl.auto">update</prop>
43. <prop key="hibernate.show_sql">true</prop>
44. <prop key="hibernate.connection.autocommit">true</prop>
45. </props>
46. </property>
47. </bean>
49. <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
50. <property name="sessionFactory" ref="sessionFactory"/>
51. </bean>
52. </beans>
```
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
 "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>

 <bean id="productDao" class="com.naturalfoods.product.dao.HibernateProductDaoImpl">
	 	<property name="sessionFactory" ref="sessionFactory" />
 </bean>

 <bean id="customerDao" class="com.naturalfoods.customer.dao.HibernateCustomerDaoImpl">
	 	<property name="sessionFactory" ref="sessionFactory" />
 </bean>

	 
 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
		<property name="driverClassName" value="org.hsqldb.jdbcDriver" />
		<property name="url" value="jdbc:hsqldb:mem:naturalfoods" />
		<property name="username" value="sa" />
		<property name="password" value="" />
		<property name="initialSize" value="5" />
		<property name="maxActive" value="10" />
		<property name="poolPreparedStatements" value="true" />
		<property name="maxOpenPreparedStatements" value="10" />
	</bean> 

	
	<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="annotatedClasses">
			<list>
				<value>com.naturalfoods.model.Address</value>
				<value>com.naturalfoods.model.Category</value>
				<value>com.naturalfoods.model.Customer</value>
				<value>com.naturalfoods.model.Order</value>
				<value>com.naturalfoods.model.OrderItem</value>
				<value>com.naturalfoods.model.Product</value>
			</list>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">org.hibernate.dialect.HSQLDialect</prop>
				<prop key="hibernate.hbm2ddl.auto">update</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.connection.autocommit">true</prop>
			</props>
		</property>
	</bean>
		
	<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory"/>
	</bean>
</beans>
```
我的项目有其自己的一套Spring配置文件，但我只为我的测试类创建清单2。它创建了一个数据源，使用共享连接池（DBCP）注入到SessionFactory的数据源。SessionFactory有注解的类的列表，这代表了Hibernate的领域模型，以及一组属性。hibernate.hbm2ddl.auto属性设置为“ 更新 “让Hibernate来创建和更新表，需要匹配bean，它发现在其领域模式。transactionManager的bean这是指由一个HibernateTransactionManager，被SessionFactory的创建，这是我的两个DAO类，它扩展HibernateDaoSupport注入。

清单3显示了完整的源代码，为我CustomerDaoTest的类，它测试的CustomerDao实现。

清单3、CustomerDaoTest.java
[java] view plain copy print ?
1. package com.naturalfoods.customer.dao;
3. import java.util.List;
4. import junit.framework.Assert;
5. import org.apache.log4j.Logger;
6. import org.junit.After;
7. import org.junit.Before;
8. import org.junit.BeforeClass;
9. import org.junit.Test;
10. import org.springframework.context.ApplicationContext;
11. import org.springframework.context.support.ClassPathXmlApplicationContext;
13. import com.naturalfoods.model.Customer;
15. public class CustomerDaoTest
16. {
17. /**
18. * Logger for debugging purposes
19. */
20. private Logger logger = Logger.getLogger( CustomerDaoTest.class );
22. /**
23. * A Spring application context that we'll create from a test application context and use to create
24. * our DAO object (and data source, session factory, etc.)
25. */
26. private static ApplicationContext ctx = null;
28. /**
29. * The CustomerDao that we'll be testing
30. */
31. private CustomerDao dao;
33. @BeforeClass
34. public static void setUpBeforeClass() throws Exception
35. {
36. // Load the applicationContext.xml file
37. ctx = new ClassPathXmlApplicationContext( "applicationContext.xml" );
38. }
40. @Before
41. public void setUp()
42. {
43. dao = ( CustomerDao )ctx.getBean( "customerDao" );
44. }
46. @After
47. public void tearDown()
48. {
49. dao = null;
50. }
52. /**
53. * Tests to make sure that we can add
54. */
55. @Test
56. public void testAddCustomer()
57. {
58. // Create a customer
59. Customer customer = new Customer();
60. customer.setFirstName( "Test-First" );
61. customer.setLastName( "Test-Last" );
62. customer.setEmail( "test@test.com" );
63. customer.setPassword( "t3st" );
65. // Add a customer to the database
66. dao.addNewCustomer( customer );
68. // Load the customer into another object
69. Customer customer2 = dao.loadCustomer( customer.getId() );
70. Assert.assertNotNull( "The customer that was created was unable to be loaded from the database",
71. customer2 );
73. // Assert that the customer exists
74. Assert.assertEquals( "First names do not match", "Test-First", customer2.getFirstName() );
75. Assert.assertEquals( "Last names do not match", "Test-Last", customer2.getLastName() );
76. Assert.assertEquals( "Email addresses do not match", "test@test.com", customer2.getEmail() );
77. Assert.assertEquals( "Passwords do not match", "t3st", customer2.getPassword() );
79. // Remove the customer from the database
80. dao.removeCustomer( customer2 );
82. // Assert that the customer is no longer in the database
83. Customer customer3 = dao.loadCustomer( customer.getId() );
84. Assert.assertNull( "The customer should have been deleted but it was not", customer3 );
85. System.out.println( "Customer3: " + customer3 );
86. }
88. /**
89. * Tests querying customers by their last name
90. */
91. @Test
92. public void testQueryByLastName()
93. {
94. // Create four customers
95. Customer steve = new Customer( "Steven", "Haines", "steve@gomash.com", "mypass" );
96. Customer linda = new Customer( "Linda", "Haines", "linda@gomash.com", "mypass" );
97. Customer michael = new Customer( "Michael", "Haines", "michael@gomash.com", "mypass" );
98. Customer someone = new Customer( "Someone", "Else", "someone@somewhere.com", "notmypass" );
100. // Add the four customers to the database
101. dao.addNewCustomer( steve );
102. dao.addNewCustomer( linda );
103. dao.addNewCustomer( michael );
104. dao.addNewCustomer( someone );
106. // Query the database
107. List<Customer> customers = dao.findCustomersByLastName( "Haines" );
109. // Assert that we found all of the records that we expected to find
110. Assert.assertEquals( "Did not find the three customers we inserted into the database", 3,
111. customers.size() );
113. // Debug
114. if( logger.isDebugEnabled() )
115. {
116. logger.debug( "All customers with a lastname of Haines:" );
117. for( Customer customer : customers )
118. {
119. logger.debug( "Customer: " + customer );
120. }
121. }
123. // Clean up
124. dao.removeCustomer( steve );
125. dao.removeCustomer( linda );
126. dao.removeCustomer( michael );
127. dao.removeCustomer( someone );
128. }
129. }
```
package com.naturalfoods.customer.dao;

import java.util.List;
import junit.framework.Assert;
import org.apache.log4j.Logger;
import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.naturalfoods.model.Customer;

public class CustomerDaoTest
{
 /**
 * Logger for debugging purposes
 */
 private Logger logger = Logger.getLogger( CustomerDaoTest.class );
 
 /**
 * A Spring application context that we'll create from a test application context and use to create
 * our DAO object (and data source, session factory, etc.)
 */
 private static ApplicationContext ctx = null;
 
 /**
 * The CustomerDao that we'll be testing
 */
 private CustomerDao dao;

 @BeforeClass
 public static void setUpBeforeClass() throws Exception
 {
 // Load the applicationContext.xml file
 ctx = new ClassPathXmlApplicationContext( "applicationContext.xml" );
 }
 
 @Before
 public void setUp()
 {
 dao = ( CustomerDao )ctx.getBean( "customerDao" );
 }
 
 @After
 public void tearDown()
 {
 dao = null;
 }
 
 /**
 * Tests to make sure that we can add
 */
 @Test
 public void testAddCustomer()
 {
 // Create a customer
 Customer customer = new Customer();
 customer.setFirstName( "Test-First" );
 customer.setLastName( "Test-Last" );
 customer.setEmail( "test@test.com" );
 customer.setPassword( "t3st" );
 
 // Add a customer to the database
 dao.addNewCustomer( customer );
 
 // Load the customer into another object
 Customer customer2 = dao.loadCustomer( customer.getId() );
 Assert.assertNotNull( "The customer that was created was unable to be loaded from the database",
		 customer2 );
 
 // Assert that the customer exists
 Assert.assertEquals( "First names do not match", "Test-First", customer2.getFirstName() );
 Assert.assertEquals( "Last names do not match", "Test-Last", customer2.getLastName() );
 Assert.assertEquals( "Email addresses do not match", "test@test.com", customer2.getEmail() );
 Assert.assertEquals( "Passwords do not match", "t3st", customer2.getPassword() );

 // Remove the customer from the database
 dao.removeCustomer( customer2 );
 
 // Assert that the customer is no longer in the database
 Customer customer3 = dao.loadCustomer( customer.getId() );
 Assert.assertNull( "The customer should have been deleted but it was not", customer3 );
 System.out.println( "Customer3: " + customer3 );
 }
 
 /**
 * Tests querying customers by their last name
 */
 @Test
 public void testQueryByLastName()
 {
 // Create four customers 
 Customer steve = new Customer( "Steven", "Haines", "steve@gomash.com", "mypass" );
 Customer linda = new Customer( "Linda", "Haines", "linda@gomash.com", "mypass" );
 Customer michael = new Customer( "Michael", "Haines", "michael@gomash.com", "mypass" );
 Customer someone = new Customer( "Someone", "Else", "someone@somewhere.com", "notmypass" );
 
 // Add the four customers to the database
 dao.addNewCustomer( steve );
 dao.addNewCustomer( linda );
 dao.addNewCustomer( michael );
 dao.addNewCustomer( someone );
 
 // Query the database
 List<Customer> customers = dao.findCustomersByLastName( "Haines" );
 
 // Assert that we found all of the records that we expected to find
 Assert.assertEquals( "Did not find the three customers we inserted into the database", 3,
		 customers.size() );
 
 // Debug
 if( logger.isDebugEnabled() )
 {
 logger.debug( "All customers with a lastname of Haines:" );
 for( Customer customer : customers )
 {
 logger.debug( "Customer: " + customer );
 }
 }
 
 // Clean up
 dao.removeCustomer( steve );
 dao.removeCustomer( linda );
 dao.removeCustomer( michael );
 dao.removeCustomer( someone );
 }
}
```
applicationContext.xml的文件在CLASSPATH中，加载和加载CustomerDao bean真的只归结为两行代码：
[java] view plain copy print ?
1. ctx = new ClassPathXmlApplicationContext( "applicationContext.xml" );
2. dao = ( CustomerDao )ctx.getBean( "customerDao" );
```
 ctx = new ClassPathXmlApplicationContext( "applicationContext.xml" );
 dao = ( CustomerDao )ctx.getBean( "customerDao" );
```
XmlBeanFactory中的类看起来是命名的资源，在这种情况下让applicationContext.xml加载其所有的bean类。它暴露了一个方法叫做的getBean（） ，它作为一个参数的bean返回给调用者。无论您是否是使用Hibernate，你可以使用这两条线路由Spring管理加载任何资源。

这个例子中的美是测试用例的代码没有做任何事情比生产代码不同：，它加载bean类和执行他们的方法。使用Hibernate作为一个内存中的数据库的所有的工作是通过定义适当的JDBC URL。

通过数据源定义使用HSQLDB的内存数据库，你的测试用例，可以运行一个新的全新数据库每次执行的时候，并没有要求你保持自己启动该数据库。此外，如果你需要在你的数据库中的数据，你可以指定一个脚本文件HSQLDB启动时使用内存中的数据库可以使用已知的数据为你写你的测试案例预先填充。总之，HSQLDB让您轻松测试你的Hibernate DAO类以外的您的应用程序，写作时颗粒状的单元测试，这是理想的情况下。

Herman-Hong

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
用HSQLDB数据库测试Hibernate和Spring

原文地址：http://www.informit.com/guides/content.aspx?g=java&seqNum=507用Hibernate编写应用程序时，你的首要目标是制定正确的域模型，包括对象和关系，然后让Hibernate担心这些持久化的对象到你选择的数据库方言的转变。它总是一个好主意，在您运行的应用程序中来测试您的对象与具体的数据库方言，但是从一个单
复制链接

扫一扫