Spring使用內存數據庫

　　有時候為了做些測試需要創建數據庫及相關表，安裝MySQL等輕量數據庫雖然簡單但還是有點麻煩？而且用於自己臨時測試的數據庫對象一般不會被多次使用，還是浪費？內存數據庫結合ORM可以很好解決這個問題。

　　H2,Derby,HSQLDB 都是很好的內存數據庫，大家可以根據自己的需要選擇：

	H2	Derby	HSQLDB	MySQL	PostgreSQL
Pure Java	Yes	Yes	Yes	No	No
Memory Mode	Yes	Yes	Yes	No	No
Encrypted Database	Yes	Yes	Yes	No	No
ODBC Driver	Yes	No	No	Yes	Yes
Fulltext Search	Yes	No	No	Yes	Yes
Multi Version Concurrency	Yes	No	Yes	Yes	Yes
Footprint (jar/dll size)	~1 MB	~2 MB	~1 MB	~4 MB	~6 MB

　　Spring已經對使用內存數據庫提供很完美的支持：

　　配置類：

@Configuration
public class HibernateConfiguration {
    @Autowired
    private DataSource dataSource;
    @Bean
    public AnnotationSessionFactoryBean sessionFactoryBean() {
        Properties props = new Properties();
        //配置H2方言
        props.put("hibernate.dialect", H2Dialect.class.getName());
        props.put("hibernate.format_sql", "true");
        AnnotationSessionFactoryBean bean = new AnnotationSessionFactoryBean();
        bean.setAnnotatedClasses(new Class[]{Item.class, Order.class});
        bean.setHibernateProperties(props);
        bean.setDataSource(this.dataSource);
        bean.setSchemaUpdate(true);
        return bean;
    }
    @Bean
    public HibernateTransactionManager transactionManager() {
        return new HibernateTransactionManager( sessionFactoryBean().getObject() );
    }
                                                    
    /**
     * 設置內存數據庫類型，可以更改為Derby,HSQL
     * @return
     */
    @Bean
    public DataSource dataSource(){
        EmbeddedDatabaseBuilder builder = new EmbeddedDatabaseBuilder();
        builder.setType(EmbeddedDatabaseType.H2);
        return builder.build();
    }

　　然后我們可以寫entity類及相關測試用例：

　　Order Entity類：

@Entity
@Table(name="T_ORDER")
public class Order {
                                                  
    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private Long id;
                                                  
    private String customer;
                                                  
    @OneToMany(cascade=CascadeType.ALL)
    @JoinColumn(name="ORDER_ID")
    private Collection<Item> items = new LinkedHashSet<Item>();
    /**
     * @return the customer
     */
    public String getCustomer() {
        return customer;
    }
    /**
     * @param customer the customer to set
     */
    public void setCustomer(String customer) {
        this.customer = customer;
    }
    /**
     * @return the items
     */
    public Collection<Item> getItems() {
        return items;
    }
    /**
     * @param items the items to set
     */
    public void setItems(Collection<Item> items) {
        this.items = items;
    }
    /**
     * @return the id
     */
    public Long getId() {
        return id;
    }
                                                  
}

　　Item Entity類

@Entity
public class Item {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    @ManyToOne
    private Order order;
    private String product;
    private double price;
    private int quantity;
    /**
     * @return the order
     */
    public Order getOrder() {
        return order;
    }
    /**
     * @return the product
     */
    public String getProduct() {
        return product;
    }
    /**
     * @param product
     *            the product to set
     */
    public void setProduct(String product) {
        this.product = product;
    }
    /**
     * @return the price
     */
    public double getPrice() {
        return price;
    }
    /**
     * @param price
     *            the price to set
     */
    public void setPrice(double price) {
        this.price = price;
    }
    /**
     * @return the quantity
     */
    public int getQuantity() {
        return quantity;
    }
    /**
     * @param quantity
     *            the quantity to set
     */
    public void setQuantity(int quantity) {
        this.quantity = quantity;
    }
    /**
     * @return the id
     */
    public Long getId() {
        return id;
    }
}

　　Junit測試類

@ContextConfiguration
@RunWith(SpringJUnit4ClassRunner.class)
public class OrderPersistenceTests {
    @Autowired
    private SessionFactory sessionFactory;
    @Test
    @Transactional
    public void testSaveOrderWithItems() throws Exception {
        Session session = sessionFactory.getCurrentSession();
        Order order = new Order();
        order.getItems().add(new Item());
        session.save(order);
        session.flush();
        assertNotNull(order.getId());
    }
    @Test
    @Transactional
    public void testSaveAndGet() throws Exception {
        Session session = sessionFactory.getCurrentSession();
        Order order = new Order();
        order.getItems().add(new Item());
        session.save(order);
        session.flush();
        // Otherwise the query returns the existing order (and we didn't set the
        // parent in the item)...
        session.clear();
        Order other = (Order) session.get(Order.class, order.getId());
        assertEquals(1, other.getItems().size());
        assertEquals(other, other.getItems().iterator().next().getOrder());
    }
    @Test
    @Transactional
    public void testSaveAndFind() throws Exception {
        Session session = sessionFactory.getCurrentSession();
        Order order = new Order();
        Item item = new Item();
        item.setProduct("foo");
        order.getItems().add(item);
        session.save(order);
        session.flush();
        // Otherwise the query returns the existing order (and we didn't set the
        // parent in the item)...
        session.clear();
        Order other = (Order) session
                .createQuery( "select o from Order o join o.items i where i.product=:product")
                .setString("product", "foo").uniqueResult();
        assertEquals(1, other.getItems().size());
        assertEquals(other, other.getItems().iterator().next().getOrder());
    }
}