SpringBoot、SpringData、Hibernate、MyBatis整合進行微、輕量級服務接口開發，然後結合freemarker和Jsp進行前後端結合。

1、開發準備

          開發工具：IntelliJ IDEA 2018.1；開發環境：jdk1.8_181 Version ; maven_3.5.3 Version (maven用遠程倉庫映射)

2、開始開發

      2.1 搭建開發環境

          點擊 ：File -->New -->Project

點擊project後，開始選擇要生成的project，這裏選擇spring Initializr

說明：我這裏本機配置了JDK1.7和1.8版本的SDK，這裏如果有小夥伴不知道SDK怎麼配置可以查看我去年5月份的一篇博客地址爲：https://blog.csdn.net/CDW2328/article/details/72627280

接着就點擊NEXT.然後按照下圖的搞：

點擊Next，這裏SpringBoot選擇1.5.17，選擇其他的版本會啓動報錯。

以下是瞭解的內容，不需要選擇：

Next後點擊Finish即可。

項目自動構建完畢以後，我們加一段代碼，然後用瀏覽器訪問，如果瀏覽器輸出我們定義的WelCome to SpringBootData。那就搭建成功了。

寫好以後，啓動這個main方法，這裏不需要指定Tomcat的路徑，因爲SpringBoot內嵌了Tomcat。

瀏覽器的地址欄輸入：http://localhost:8080/getSpringBootData，如我們所願正常輸出了。

3、開始集成SpringData

      3.1、添加SpringData的maven依賴：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

     3.2、既然SpringData是基於Jpa的持久化層框架，那麼一定會個數據庫交互，現在我們添加數據庫配置文件。在項目的resources下創建一個properties文件(DataBaseConfig.properties)與application.properties文件同級。

     3.3、開始往數據庫配置文件DataBaseConfig.properties中添加數據庫鏈接配置：

db.driverClassName = com.mysql.jdbc.Driver
db.url=jdbc:mysql://127.0.0.1:3306/betterlife_kaifa?useUnicode=true&characterEncoding=UTF-8
db.username = root
db.password = 123456
db.filters=stat  
db.initialSize=10  
db.maxWait=60000  
db.minIdle=100  
db.maxActive=200  
db.timeBetweenEvictionRunsMillis=60000  
db.minEvictableIdleTimeMillis=300000
db.validationQuery=SELECT 'x'  
db.testWhileIdle=true  
db.testOnBorrow=false  
db.testOnReturn=false  
db.poolPreparedStatements=true
db.maxOpenPreparedStatements=20 

至此數據庫配置完畢，下面我們開始寫基於無XML方式的IOC對象創建配置。

3.4創建一個包名字隨便這裏我取：Config

既然是SpringBoot的開發初衷是極大的簡化基於Spring的XML方式，而且我們要指定數據源也就是數據庫要用那個，所以我們採用創建java對象的方式來完成數據庫鏈接初始化和其他的操作。

在我們新建的Config包裏創建第一個java對象，這個java對象的左右是完成數據庫鏈接檢測和初始化數據庫資源與創建事務管理等，不多說直接上代碼。

package com.baidu.springbootdata.Config;

import com.alibaba.druid.pool.DruidDataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.YamlPropertiesFactoryBean;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
import org.springframework.core.env.Environment;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import java.io.IOException;

/**
 * @describe：數據庫連接池的配置
 * @author: chendawei
 * @date: 2018年11月6日10:41:22
 * @note:
 */
@Configuration
@ConfigurationProperties(prefix = "db")
@PropertySource(value = {"DataBaseConfig.properties"})
public class DataBaseConfig {

    @Autowired
    private Environment env;

    @Value("${db.initialSize}")
    private int initialSize;

    @Value("${db.maxWait}")
    private long maxWait;

    @Value("${db.maxActive}")
    private int maxActive;

    @Value("${db.timeBetweenEvictionRunsMillis}")
    private long timeBetweenEvictionRunsMillis;

    @Value("${db.maxOpenPreparedStatements}")
    private int maxOpenPreparedStatements;

    @Bean(name = "dataSource",initMethod = "init",destroyMethod = "close")
    public DruidDataSource dataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(env.getProperty("db.driverClassName"));
        druidDataSource.setUrl(env.getProperty("db.url"));
        druidDataSource.setUsername(env.getProperty("db.username"));
        druidDataSource.setPassword(env.getProperty("db.password"));
        druidDataSource.setInitialSize(initialSize);
        druidDataSource.setMaxWait(maxWait);
        druidDataSource.setMaxActive(maxActive);
        druidDataSource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        druidDataSource.setValidationQuery(env.getProperty("db.validationQuery"));
        druidDataSource.setTestWhileIdle(Boolean.getBoolean(env.getProperty("db.validationQuery")));
        druidDataSource.setTestOnBorrow(Boolean.getBoolean(env.getProperty("db.testOnBorrow")));
        druidDataSource.setTestOnReturn(Boolean.getBoolean(env.getProperty("db.testOnReturn")));
        druidDataSource.setPoolPreparedStatements(Boolean.getBoolean(env.getProperty("db.poolPreparedStatements")));
        druidDataSource.setMaxOpenPreparedStatements(maxOpenPreparedStatements);
        return druidDataSource;
    }
    /***************  讀取自定義的yml文件的bean  *****************/
    /**
     * 加載yml配置文件,根目錄爲resources
     * @return
     */
    @Bean
    public static PropertySourcesPlaceholderConfigurer properties() {
        PropertySourcesPlaceholderConfigurer pspc = new PropertySourcesPlaceholderConfigurer();
        YamlPropertiesFactoryBean yaml = new YamlPropertiesFactoryBean();
        yaml.setResources(new ClassPathResource("freemarkerConfig.yml"));
        pspc.setProperties(yaml.getObject());
        return pspc;
    }

    /***************  需要整合MyBatis時才用，不整合不用  *****************/
    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource());
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        sqlSessionFactoryBean.setMapperLocations(resolver.getResources("classpath:/MyBatisDaoMapper/*.xml"));
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBean.getObject();
        return sqlSessionFactory;
    }
}

這樣我們的數據庫鏈接的配置就已完成，對於讀取yml文件和myBatis的sqlSessionFactory的方法，這裏需要說明一下，我這裏由構建項目時自動生成的application.properties文件裏面目前是空的沒有寫任何的東西進去，而我自定義了一個yml文件用於配置freemarker模板引擎，所以我這裏需要將自定義的yml文件初始化，這裏也不是說用到freemarker的時候非要這樣做，如果我們想把上面數據庫相關的配置不想再properties文件裏存放，也不想在application.properties文件裏存放，就想自定義yml文件進行讀取這個操作也必須得做。

這個freemarker模板引擎的配置文件freemarkerConfig.yml位於resource下和application.properties文件同級，下面是具體配置。

spring:
  freemarker:
    request-context-attribute: req #req訪問request
    suffix: .html #後綴名也可以修改爲.ftl
    context-type: text/html
    enabled: true
    cache: false
    charset: UTF-8
    template-loader-path: classpath:/templates/ #模板路徑，按需配置可加二級目錄。默認爲templates，
    settings:
      number_format: '0.##' #數字格式化，無小數點

myBatis的sqlSessionFactory是myBatis的會話管理，這裏如果不需要整合這裏就不要配置了，但是如果要整合必須和數據庫的配置放置到一個對象中。

接下來，我們整合SpringData，整合springData的時候呢，我這裏重新創建一個對象，用於專門來創建SpringData，在創建SpringData的時候我們順便把Hibernate的會話代理也同樣給搞完。上代碼：

package com.baidu.springbootdata.Config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.annotation.Resource;
import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

/**
 * @describe：
 * @author: chendawei
 * @date: 2018年11月6日15:53:39
 * @note:
 */
@Configuration
@EnableJpaRepositories("com.baidu.springbootdata.SpringDataDao")
@EnableTransactionManagement
public class JpaConfig {

    @Resource
    DataSource dataSource;

    @Bean(name = "entityManagerFactory")
    public EntityManagerFactory entityManagerFactory() {
        HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();

        LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
        factory.setJpaVendorAdapter(vendorAdapter);
        //此處com.example.*.model是你的java bean所在的包名
        factory.setPackagesToScan("com.baidu.springbootdata.PO");
        factory.setDataSource(dataSource);

        Map<String, Object> jpaProperties = new HashMap<String, Object>();
        jpaProperties.put("hibernate.ejb.naming_strategy","org.hibernate.cfg.ImprovedNamingStrategy");
        jpaProperties.put("hibernate.jdbc.batch_size",50);

        factory.setJpaPropertyMap(jpaProperties);
        factory.afterPropertiesSet();
        return factory.getObject();
    }

    @Bean(name="transactionManager")
    public PlatformTransactionManager transactionManager() {
        JpaTransactionManager txManager = new JpaTransactionManager();
        txManager.setEntityManagerFactory(entityManagerFactory());
        return txManager;
    }
}

至此就高完了SpringData和Hibernate的JPA持久化配置，看到這有同行看到說，我沒有看到Hibernate的配置啊。在這裏

Map<String, Object> jpaProperties = new HashMap<String, Object>(); jpaProperties.put("hibernate.ejb.naming_strategy","org.hibernate.cfg.ImprovedNamingStrategy"); jpaProperties.put("hibernate.jdbc.batch_size",50);

這一段就是將Hiberane的持久化配置完成了。有人會問這叫什麼配置啊，好了不多說我們來看看這一段的意思和源碼怎麼配置的。這點我就不在這裏詳細描述，當寫完這篇心得後我將詳細探討。其實這個還是用的spring的orm持久化方式。

至此我們已經將主要也是最重要的配置就高完了，接下來我們就加入測試類的代碼：

我們來先展示一下項目下所有包和包下的文件。

src目錄下的：

resource下的：

項目啓動類的代碼：

package com.baidu.springbootdata;

import org.apache.ibatis.annotations.Mapper;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@EnableAutoConfiguration
@EnableTransactionManagement
public class SpringbootdataApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootdataApplication.class, args);
    }
}

controller層測試代碼：

package com.baidu.springbootdata.Controller;

import com.baidu.springbootdata.EO.CardVoucherEO;
import com.baidu.springbootdata.Service.CardVoucherService;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.List;

/**
 * @describe：
 * @author: chendawei
 * @date: {DATE}{TIME}
 * @note:
 */
@Controller
@RequestMapping("/TestController")
public class TestController {

    public static final Logger logger = LoggerFactory.getLogger(TestController.class);

    @Autowired
    CardVoucherService cardVoucherService;

    /**
     * 獲取用戶的卡券的信息
     * @param userId
     * @return
     */
    @RequestMapping("/getUserCardVoucherMsg")
    public @ResponseBody List<CardVoucherEO> getUserCardVoucherMsg(@RequestBody String userId){
        JSONObject jsonObject = JSONObject.fromObject(userId.substring(1,userId.length()-1));
        Long userid = Long.parseLong(jsonObject.getString("userId"));
        System.out.println(userid);
        return this.cardVoucherService.getUserCardVoucherMsg(userid);
    }
}

hibernateDao的代碼：

package com.baidu.springbootdata.HibernateDao;


import java.util.List;
import java.util.Map;

/**
 * @describe：
 * @author: chendawei
 * @date: {DATE}{TIME}
 * @note:
 */
public interface CardVoucherDao {

    List<Map> getUserCardVoucherMassage();
}

package com.baidu.springbootdata.HibernateDao.HibernateDaoImpl;


import com.baidu.springbootdata.HibernateDao.CardVoucherDao;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.transform.Transformers;
import org.springframework.stereotype.Repository;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import java.util.List;
import java.util.Map;

/**
 * @describe：
 * @author: chendawei
 * @date: {DATE}{TIME}
 * @note:
 */
@Repository
public class CardVoucherDaoIpml implements CardVoucherDao {

    protected EntityManager entityManager = null;

    @PersistenceContext
    public void setEntityManager(EntityManager entityManager) {
        this.entityManager = entityManager;
    }

    @Override
    public List<Map> getUserCardVoucherMassage(){
        Session session = entityManager.unwrap(Session.class);
        SQLQuery sqlQuery = session.createSQLQuery("SELECT * FROM mhsh_card_voucher_info t WHERE id=137");
       return  sqlQuery.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP).list();
    }
}

myBatisDao的代碼：

package com.baidu.springbootdata.MyBatisDao;

import com.baidu.springbootdata.PO.CardVoucherPO;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Repository;

import java.util.List;

/**
 * @describe：
 * @author: chendawei
 * @date: {DATE}{TIME}
 * @note:
 */
@Configuration
@Repository
@Mapper
public interface CardVouchersDao {

    Integer findCardVoucherMsg(Long userId);
}

SpringData的代碼：

package com.baidu.springbootdata.SpringDataDao;

import com.baidu.springbootdata.PO.CardVoucherPO;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;

import java.util.List;



/**
 * description:我的卡券的持久化層
 * @author chendawei
 * @authorTime 2018年7月17日上午10:29:13
 */
@Repository
public interface CardVoucherRepo extends JpaRepository<CardVoucherPO,Integer> {

    /**
     * 獲取某一個用戶卡券的所有信息
     * @param userId
     * @return
     */
    @Query("SELECT t FROM CardVoucherPO t WHERE t.userId=?1")
    List<CardVoucherPO> getUserCardVoucherMsg(Long userId);
}

PO的代碼：

package com.baidu.springbootdata.PO;

import java.io.Serializable;
import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

/**
 * description:我的卡券記錄 PO
 * @author chendawei
 * @authorTime 2018年7月16日下午7:56:29
 */

@Entity
@Table(name="mhsh_card_voucher_info")
public class CardVoucherPO implements Serializable{

    /**
     * @see Serializable
     */
    private static final long serialVersionUID = -5086715909814483831L;

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private Long id;//主鍵

    @Column(name="user_id")
    private Long userId;//用戶userid

    @Column(name="voucher_name")
    private String voucherName;//卡券名稱

    @Column(name="voucher_code")
    private String voucherCode;//卡券編碼

    @Column(name="voucher_type")
    private String voucherType;//卡券類型

    @Column(name="voucher_pic")
    private String voucherPic;//卡券對應的圖標地址

    @Column(name="voucher_use_flag")
    private String voucherUseFlag;//卡券是否使用的標誌

    @Column(name="voucher_look_flag")
    private String voucherLookFlag;//卡券是否查看的標誌

    @Column(name="fake_delete")
    private String fakeDelete;//卡券刪除標誌(僞刪除)

    @Column(name="voucher_germ_time")
    private Date voucherGermTime;//卡券使用起始時間

    @Column(name="voucher_end_time")
    private Date voucherEndTime;//卡券結束日期

    @Column(name="create_by")
    private String createBy;//創建用戶

    @Column(name="create_time")
    private Date createTime;//創建日期

    @Column(name="modify_by")
    private String modifyBy;//修改執行者

    @Column(name="update_time")
    private Date updateTime;//修改日期

    @Column(name="card_source_name")
    private String cardSourceName;//卡券根源名稱（卡券名稱上面的一排小字）

    @Column(name="watermark_pic")
    private String watermarkPic;//水印圖片的地址

    @Column(name="auxiliary_money")
    private String auxiliaryMoney;//抵用、優惠、代金等附屬券的價格

    @Column(name="reserved_one")
    private String reservedOne;//預留字段1

    @Column(name="reserved_two")
    private String reservedTwo;//預留字段2

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public Long getUserId() {
        return userId;
    }

    public void setUserId(Long userId) {
        this.userId = userId;
    }

    public String getVoucherName() {
        return voucherName;
    }

    public void setVoucherName(String voucherName) {
        this.voucherName = voucherName;
    }

    public String getVoucherCode() {
        return voucherCode;
    }

    public void setVoucherCode(String voucherCode) {
        this.voucherCode = voucherCode;
    }

    public String getVoucherType() {
        return voucherType;
    }

    public void setVoucherType(String voucherType) {
        this.voucherType = voucherType;
    }

    public String getVoucherPic() {
        return voucherPic;
    }

    public void setVoucherPic(String voucherPic) {
        this.voucherPic = voucherPic;
    }

    public String getVoucherUseFlag() {
        return voucherUseFlag;
    }

    public void setVoucherUseFlag(String voucherUseFlag) {
        this.voucherUseFlag = voucherUseFlag;
    }

    public String getVoucherLookFlag() {
        return voucherLookFlag;
    }

    public void setVoucherLookFlag(String voucherLookFlag) {
        this.voucherLookFlag = voucherLookFlag;
    }

    public String getFakeDelete() {
        return fakeDelete;
    }

    public void setFakeDelete(String fakeDelete) {
        this.fakeDelete = fakeDelete;
    }

    public Date getVoucherGermTime() {
        return voucherGermTime;
    }

    public void setVoucherGermTime(Date voucherGermTime) {
        this.voucherGermTime = voucherGermTime;
    }

    public Date getVoucherEndTime() {
        return voucherEndTime;
    }

    public void setVoucherEndTime(Date voucherEndTime) {
        this.voucherEndTime = voucherEndTime;
    }

    public String getCreateBy() {
        return createBy;
    }

    public void setCreateBy(String createBy) {
        this.createBy = createBy;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public String getModifyBy() {
        return modifyBy;
    }

    public void setModifyBy(String modifyBy) {
        this.modifyBy = modifyBy;
    }

    public Date getUpdateTime() {
        return updateTime;
    }

    public void setUpdateTime(Date updateTime) {
        this.updateTime = updateTime;
    }

    public String getCardSourceName() {
        return cardSourceName;
    }

    public void setCardSourceName(String cardSourceName) {
        this.cardSourceName = cardSourceName;
    }

    public String getWatermarkPic() {
        return watermarkPic;
    }

    public void setWatermarkPic(String watermarkPic) {
        this.watermarkPic = watermarkPic;
    }

    public String getAuxiliaryMoney() {
        return auxiliaryMoney;
    }

    public void setAuxiliaryMoney(String auxiliaryMoney) {
        this.auxiliaryMoney = auxiliaryMoney;
    }

    public String getReservedOne() {
        return reservedOne;
    }

    public void setReservedOne(String reservedOne) {
        this.reservedOne = reservedOne;
    }

    public String getReservedTwo() {
        return reservedTwo;
    }

    public void setReservedTwo(String reservedTwo) {
        this.reservedTwo = reservedTwo;
    }

    @Override
    public String toString() {
        return "CardVoucherPO [id=" + id + ", userId=" + userId + ", voucherName=" + voucherName + ", voucherCode="
                + voucherCode + ", voucherType=" + voucherType + ", voucherPic=" + voucherPic + ", voucherUseFlag="
                + voucherUseFlag + ", voucherLookFlag=" + voucherLookFlag + ", fakeDelete=" + fakeDelete
                + ", voucherGermTime=" + voucherGermTime + ", voucherEndTime=" + voucherEndTime + ", createBy="
                + createBy + ", createTime=" + createTime + ", modifyBy=" + modifyBy + ", updateTime=" + updateTime
                + ", cardSourceName=" + cardSourceName + ", watermarkPic=" + watermarkPic + ", auxiliaryMoney="
                + auxiliaryMoney + ", reservedOne=" + reservedOne + ", reservedTwo=" + reservedTwo + "]";
    }
}

myBatisDao包裏接口對象和接口方法對應的MapperXML：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://www.mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.baidu.springbootdata.MyBatisDao.CardVouchersDao">
    <select id="findCardVoucherMsg" parameterType="java.lang.Long" resultType="java.lang.Integer">
        select count(1) from mhsh_card_voucher_info where user_id=#{userId,jdbcType=BIGINT}
    </select>
</mapper>

service接口代碼：

package com.baidu.springbootdata.Service;

import com.baidu.springbootdata.EO.CardVoucherEO;

import java.util.List;

/**
 * author:chendawei
 * time:2018年10月31日15:58:32
 */
public interface CardVoucherService {

    List<CardVoucherEO> getUserCardVoucherMsg(Long userId);

}

serviceImpl實現類的代碼：

package com.baidu.springbootdata.Service.ServiceImpl;

import com.baidu.springbootdata.EO.CardVoucherEO;
import com.baidu.springbootdata.HibernateDao.CardVoucherDao;
import com.baidu.springbootdata.MyBatisDao.CardVouchersDao;
import com.baidu.springbootdata.PO.CardVoucherPO;
import com.baidu.springbootdata.Service.CardVoucherService;
import com.baidu.springbootdata.SpringDataDao.CardVoucherRepo;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@Service(value = "CardVoucherService")
public class CardVoucherServiceImpl implements CardVoucherService {

    @Autowired
    private CardVoucherRepo cardVoucherRepo;

    @Autowired
    private CardVoucherDao cardVoucherDao;

    @Autowired
    private CardVouchersDao cardVouchersDao;

    @SuppressWarnings("all")
    @Override
    public List<CardVoucherEO> getUserCardVoucherMsg(Long userId) {
        List<CardVoucherEO> cardVoucherEoList = new ArrayList<CardVoucherEO>();
        List<Map> listMap =  this.cardVoucherDao.getUserCardVoucherMassage();
        System.out.println(listMap);
        Integer listMap1 =  this.cardVouchersDao.findCardVoucherMsg(userId);
        System.out.println(listMap1);
        if (userId != null && userId > 0) {
            List<CardVoucherPO> cardVoucherPoList = this.cardVoucherRepo.getUserCardVoucherMsg(userId);
            if (cardVoucherPoList.size() > 0) {
                for (CardVoucherPO cardVoucherPO : cardVoucherPoList) {
                    CardVoucherEO cardVoucherEO = new CardVoucherEO();
                    BeanUtils.copyProperties(cardVoucherPO, cardVoucherEO);
                    cardVoucherEoList.add(cardVoucherEO);
                }
                return cardVoucherEoList;
            } else {
                cardVoucherEoList.add(null);
                return cardVoucherEoList;
            }
        } else {
            cardVoucherEoList.add(null);
            return cardVoucherEoList;
        }
    }


}

測試freemarker的html代碼：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>TestFreeMarker</title>
   <script type="text/javascript" src="/js/jquery-1.7.2.min.js"></script>
    <script type="text/javascript">
        function myCardVoucher() {
            var stringData = "{'userId':'137'}";
            var jsonData = JSON.stringify(stringData);
            alert(jsonData);
            alert("哈哈");
           $.ajax({
                type:"POST",
                data: jsonData,
                contentType: "application/json;charsetset=UTF-8",
                url:"/TestController/getUserCardVoucherMsg",
                async:true,
                success:function(data){
                    alert(data);
                },
                error:function(data){

                }
            });
        }
    </script>
</head>
<body>
    <button onclick="myCardVoucher()">點擊我訪問我的卡券信息</button>

</body>
</html>

pom.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.baidu</groupId>
    <artifactId>springbootdata</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>springbootdata</name>
    <description>Spring_BootDataDemo</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.17.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <!--SpringData的依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <!--mybatis的依賴-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>
        <!--freemarker的依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-freemarker</artifactId>
        </dependency>
        <!--讀取自定義的yml文件依賴-->
        <dependency>
            <groupId>org.yaml</groupId>
            <artifactId>snakeyaml</artifactId>
            <version>${snakeyaml.version}</version>
        </dependency>
        <!--數據庫驅動-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.34</version>
        </dependency>
        <!--數據庫連接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.27</version>
        </dependency>
        <!--日誌相關-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>
        <!--其他-->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.0.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>net.sf.json-lib</groupId>
            <artifactId>json-lib</artifactId>
            <version>2.4</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.8.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>javax.persistence</groupId>
            <artifactId>persistence-api</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.8.0</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.0</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
        <resources>
            <resource>
                <directory>src/main/java</directory><!--所在的目錄-->
                <includes><!--包括目錄下的.properties,.xml文件都會掃描到-->
                    <include>*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>
</project>

好至此呢，SpringBoot整合SpringData、Mybatis、Hibernate就已經結束了，Freemarker我只是進行了簡單配置，當然Feemarker的標籤還有很多比如，取值，循環，判斷等等。這裏都可以用在項目中。

最後我把整合Jsp的步驟記錄一下：

首先我們要知道SpringBoot對jsp的支持不太好，我們需要手動的把jsp相關的加進來。

第一在pom.xml中添加依賴（項目中不需要整合jsp則不需要添加這些依賴）：

<!--springboot tomcat jsp 支持開啓-->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <scope>compile</scope>
        </dependency>
第二手動創建webapp目錄以及子目錄WEB-INF、jsp和測試的Jsp頁面，注意webapp創建到和resource目錄的同級並列。

webapp的子目錄是WEB-INF，WEB-INF的子目錄是jsp目錄，jsp目錄裏面存放jsp頁面文件。

第三創建jsp文件的配置JspConfig.yml文件，這裏的配置是yml文件。文件位置位於resource目錄下和上面的freemarkerConfig.yml文件同級。

JspConfig.yml文件：

spring:
    mvc:
      view:
        prefix: /WEB-INF/jsp/
        suffix: .jsp

第四，編寫初始化配置文件的方法，在DataBaseConfig.java文件中添加這個方法：

@Bean
 public static PropertySourcesPlaceholderConfigurer propertie() {
     PropertySourcesPlaceholderConfigurer pspc = new PropertySourcesPlaceholderConfigurer();
     YamlPropertiesFactoryBean yaml = new YamlPropertiesFactoryBean();
     yaml.setResources(new ClassPathResource("JspConfig.yml"));
     pspc.setProperties(yaml.getObject());
     return pspc;
 }

注意：我在添加jsp頁面的初始化配置之前，已經添加過初始化freemarker模板引擎的方法，這兩個方法不能共存，要不然誰也訪問不到各自的頁面，說白了就是不能同時配置兩種視圖。當然要是嫌寫兩個方法麻煩每次還得註釋那就直接把上面代碼中的yaml.setResources(new ClassPathResource("JspConfig.yml"));裏的JspConfig.yml改爲FreemarkerConfig.yml。就行互相切換使用唄。

至此我整合完畢。如有錯誤處請大神指教。。。。QQ號：767611329，鮑家街58號