package com.foo.configura;

import org.apache.tomcat.jdbc.pool.DataSource;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.orm.hibernate5.HibernateTransactionManager;
import org.springframework.orm.hibernate5.LocalSessionFactoryBean;

import java.util.Properties;

/**
 * @author JasonLin
 * @version V1.0
 * @date 2017/12/1
 */
@Configuration
public class Conf {

    @Bean(name = "sessionFactory")
    public LocalSessionFactoryBean sessionFactory(DataSource dataSource) {
        LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        Properties properties = new Properties();
        properties.put("hibernate.dialect", "org.hibernate.dialect.MySQL5Dialect");
        properties.put("hibernate.show_sql", true);
        properties.put("hibernate.connection.release_mode", "after_transaction");
        properties.put("hibernate.cache.use_second_level_cache", false);
        properties.put("hibernate.cache.use_query_cache", false);
        sessionFactory.setHibernateProperties(properties);
        sessionFactory.setPackagesToScan("com.foo.model");
        return sessionFactory;
    }

    @Bean("transactionManager")
    HibernateTransactionManager getHibernateTransactionManager(@Qualifier("sessionFactory") SessionFactory sessionFactory){
        return new HibernateTransactionManager(sessionFactory);
    }

    @Bean("hibernateTemplate")
    HibernateTemplate getHibernateTemplate(@Qualifier("sessionFactory") SessionFactory sessionFactory) {
        HibernateTemplate hibernateTemplate = new HibernateTemplate();
        hibernateTemplate.setSessionFactory(sessionFactory);
        return hibernateTemplate;
    }
}
 

3. 業務程式碼

a.訂單實體和訂單項實體：

@Getter
@Setter
@Entity
@Table(name = "_order")
public class Order implements Serializable {

    private static final long serialVersionUID = 1854996605034612378L;

    @Id
    private String id;

    @Column(name = "total_list_price")
    private BigDecimal totalListPrice;

    @Column(name = "total_sale_price")
    private BigDecimal totalSalePrice;

    @Column(name = "purchase_quantity")
    private Integer purchaseQuantity;

    /**
     * 品種數量
     */
    @Column(name = "purchase_kinds")
    private Integer purchaseKinds;

    @Column
    //正常情況下儲存的是客戶ID
    private String customer;

    @OneToMany(cascade = CascadeType.ALL, mappedBy = "order", targetEntity = OrderItem.class)
    private Set<OrderItem> itemList;
}
 

@Getter
@Setter
@Entity
@Table(name = "order_item")
public class OrderItem implements Serializable{
    private static final long serialVersionUID = 8272679709545182358L;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne
    @JoinColumn(name = "_order")
    private Order order;

    /**
     * 商品ID
     */
    @Column(name = "product_sale")
    private Long productSale;

    /**
     * 購買數量
     */
    @Column(name = "purchase_quantity")
    private Integer purchaseQuantity;

    /**
     * 碼洋
     */
    @Column(name = "list_price")
    private BigDecimal listPrice;

    /**
     * 實洋
     */
    @Column(name = "sale_price")
    private BigDecimal salePrice;
}
 

b.service服務層：

@Service("orderService")
@Transactional(rollbackFor = Exception.class)
public class OrderServiceImpl implements OrderService {

    private static final Log LOG = LogFactory.getLog(OrderServiceImpl.class);

    @Autowired
    private OrderDao orderDao;

    @Override
    public void create(Order order) {
        checkOrder(order);
        initOrder(order);
        orderDao.save(order);
        LOG.info("create order successed,orderId:" + order.getId());
//        throw new RuntimeException("test exception");
    }

    private void checkOrder(Order order) {
        Preconditions.checkNotNull(order, "order is null.");
        Preconditions.checkArgument(!CollectionUtils.isEmpty(order.getItemList()), "OrderItem is empty.");
    }

    private void initOrder(Order order) {
        BigDecimal totalListPrice = BigDecimal.ZERO;
        BigDecimal totalSalePrice = BigDecimal.ZERO;
        Integer purchaseQuantity = 0;
        Integer purchaseKind = order.getItemList().size();
        for (OrderItem orderItem : order.getItemList()) {
            totalListPrice = totalListPrice.add(orderItem.getListPrice());
            totalSalePrice = totalSalePrice.add(orderItem.getSalePrice());
            purchaseQuantity += orderItem.getPurchaseQuantity();
        }
        order.setTotalListPrice(totalListPrice);
        order.setTotalSalePrice(totalSalePrice);
        order.setPurchaseKinds(purchaseKind);
        order.setPurchaseQuantity(purchaseQuantity);
    }
}

c. dao層：

@Repository("orderDao")
public class OrderDaoImpl implements OrderDao{

    @Autowired
    private HibernateTemplate hibernateTemplate;

    @Override
    public void save(Order order) {
        hibernateTemplate.save(order);
    }
}

4. 測試

在編寫測試類的時候會用到兩個註解：@RunWith，@SpringBootTest 。spring boot會自動載入啟動類進行測試。 測試類程式碼如下：

@RunWith(SpringRunner.class)
@SpringBootTest
public class TestOrderService {

    @Autowired
    private OrderService orderService;

    @Test
    public void testCreate(){
        Order order  = new Order();
        Set<OrderItem> orderItems = Sets.newHashSet();

        OrderItem orderItem1 = new OrderItem();
        orderItem1.setListPrice(new BigDecimal("11.02"));
        orderItem1.setSalePrice(new BigDecimal("9.99"));
        orderItem1.setOrder(order);
        orderItem1.setProductSale(1222021L);
        orderItem1.setPurchaseQuantity(1);

        OrderItem orderItem2 = new OrderItem();
        orderItem2.setListPrice(new BigDecimal("8.5"));
        orderItem2.setSalePrice(new BigDecimal("8.0"));
        orderItem2.setOrder(order);
        orderItem2.setProductSale(1222056L);
        orderItem2.setPurchaseQuantity(2);

        orderItems.add(orderItem1);
        orderItems.add(orderItem2);

        order.setId(String.valueOf(IdUtils.next()));
        order.setCustomer("jasonLin");
        order.setItemList(orderItems);
        orderService.create(order);
    }

}

執行測試方法，檢視資料庫：

資料已經成功插入。在service層裡面有行註釋了的程式碼，用於測試hibernate事物是否正確配置，必須配置HibernateTransactionManager否則使用使用hibernateTemplate事物將不會生效。 最後放上pom.xml檔案的依賴：

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>

ps:

1、使用jpa包自動新增hibernate依賴
2、使用hibernateTemplate需要設定sessionFactory
3、springboot會自動注入DataSource，但是在配置檔案中必須以sprping.datasource.*開頭的配置項，
4、預設使用Tomcat連線池
5、springboot自動注入JdbcTemplate

本文的其它詳細程式碼在：https://github.com/Json-Lin/spring-boot-practice/tree/master/spring-boot-paractice-data-jpa
end