Spring、SpringMVC、SpringData + JPA 整合詳解

 原創播客，如需轉載請注明出處。原文地址：http://www.cnblogs.com/crawl/p/7759874.html 

----------------------------------------------------------------------------------------------------------------------------------------------------------

筆記中提供了大量的代碼示例，需要說明的是，大部分代碼示例都是本人所敲代碼並進行測試，不足之處，請大家指正~

本博客中所有言論僅代表博主本人觀點，若有疑惑或者需要本系列分享中的資料工具，敬請聯系 [e-mail]

-----------------------------------------------------------------------------------------------------------------------------------------------------------

前言：之前詳細講解過了 JPA 和 SpringData，包括 Spring 和 SpringMVC 也進行了詳細的講述。很早就想來一個整合了，因為事情比較多，所以就一直拖着。

那么現在就來說說 Spring + SpringMVC + SpringData + JPA（下文中簡寫為 SSSP） 的整合，SSSP 的整合之后再來寫一個  CRUD 的小案例，樓主不打算把增刪改查都來一遍了，只介紹一個查詢所有員工信息，然后分頁顯示即可。大家可以對比在 JavaWeb 的過程中寫的分頁查詢，看一看是否簡單的許多。下面進行詳細的介紹~

一、加入 Spring

1. 首先當然要新建一個動態的 WEB 的工程了，取名 sssp

2. 加入 Spring 的 jar 包，觀察這些 jar 包，大家可以發現其中既包含了 Spring 的 jar 包，也包含了 SpringMVC 的 jar 包

3. web.xml 中配置啟動 Spring IOC 的 ContextLoaderListener：

<!-- 配置啟動 Spring IOC 的 Listener -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

其中 樓主配置的 Spring 的配置文件在 classpath 下，取名為 applicationContext.xml 

4. 這一步當然就是在類路徑下創建 Spring 的配置文件：applicationContext.xml 了，在這里先創建好，稍后進行配置。

二、加入 SpringMVC

1. 首先呢肯定要想到的是先導入 jar 包，這里在加入 Spring 的時候已經導入，前面也已經做了說明。

2. web.xml 中配置 SpringMVC 的 DispatcherServlet

<!-- 配置 SpringMVC 的 DispatcherServlet -->
    <!-- 使用默認的 SpringMVC 的配置文件，為 [servlet-name]-servlet.xml 放到 WEB-INF 目錄下 -->
    <servlet>
        <servlet-name>springDispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>springDispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

在這里呢 樓主刪除了一部分配置，我們使用默認的 SpringMVC 的配置文件，這個默認的 SpringMVC 的配置文件的名字為 ：springDispatcherServlet-servlet.xml ，需要注意的是，若使用默認的配置文件，文件的位置需要在 WEB-INF 目錄下

3. 在 WEB-INF 目錄下新建 SpringMVC 的配置文件： springDispatcherServlet-servlet.xml （注意：樓主的 Eclipse 中是安裝了 Spring 插件的，實質上樓主使用 Spring 的插件創建了 SpringMVC 的配置文件，只是文件名不同而已）

4. 然后我們對 SpringMVC 的配置文件 springDispatcherServlet-servlet.xml 進行配置

1）加入命名空間，因為我們在新建配置文件的時候沒有加入命名空間，所以先加入 context 和 mvc 的命名空間。那么如何加入呢，當我們打開 SpringMVC 的配置文件后，大家可以看到文件的左下角有一些選項卡（如下面圖片所示），大家點擊第二個選項 Namespaces，

點開后大家吧 context 和 mvc 選項挑上對勾即可。

2）配置自動掃描的包

<!-- 配置自動掃描的包：只掃描有 @Controller 和 @ControllerAdvice 注解的包 -->
    <context:component-scan base-package="com.software.sssp" use-default-filters="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller" />
        <context:include-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice" />
    </context:component-scan>

在配置自動掃描的包時，樓主使用了 context:include-filter 子標簽，目的就是讓 SpringMVC 只掃描帶有 @Controller 和 @ControllerAdvice 注解的包中的類，為什么要這樣做呢？因為我們加入 Spring 的時候只創建了 Spring 的配置文件，還沒有進行配置，一會我們配置的時候，也會先配置 Spring 的 IOC 掃描的包，這樣就有可能出現某些包 Spring 的容器掃描了一遍，SpringMVC 又掃描了一遍，這樣就會造成有些對象會創建多次，造成資源的浪費，配置 context:include-filter 標簽就是為了解決這個問題，讓 Spring 和 SpringMVC 只掃描各自關注的包即可。

3）配置視圖解析器：

<!-- 配置視圖解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>

這里我們使用的是默認的 InternalResourceViewResolver 視圖解析器，然后配置了一個前綴，一個后綴。這里 InternalResourceViewResolver 視圖解析器是如何解析工作的，我們配置的 prefix 和 suffix 有什么用，在樓主的 深入淺出 SpringMVC - 1 中已經詳細介紹，大家可以自行查看。

4）既然在配置視圖解析器的時候我們配置了 prefix 和 suffix ，那么就需要我們在 WEB-INF 目錄下新建一個 views 文件夾，用來存放我們需要的 jsp 頁面

 5）然后我們把 SpringMVC 的兩個標配配置上：處理靜態請求資源的 <mvc:default-servlet-handler/> 以及 <mvc:annotation-driven></mvc:annotation-driven>

<mvc:default-servlet-handler/>
<mvc:annotation-driven></mvc:annotation-driven>

三、加入 JPA

1）使用 JPA 需要導入 HIbernate 和 JPA 的 jar 包

Hibernate 的 jar 包：

JPA 的 jar 包：

2）加入 c3p0 和 MySQL 的驅動

c3p0：

MySQL 驅動：

3）其實在這個小案例中樓主還是用了 JPA 的二級緩存，所以還加入了二級緩存相關的 jar 包，和配置文件，這里就不詳細說明了。

關於 JPA 的知識呢，樓主也寫了幾篇播客，大家可以參考：

JPA + SpringData 操作數據庫原來可以這么簡單 ---- 深入了解 JPA - 1

JPA + SpringData 操作數據庫原來可以這么簡單 ---- 深入了解 JPA - 2

JPA + SpringData 操作數據庫原來可以這么簡單 ---- 深入了解 JPA - 3

手把手教你解決無法創建 JPA 工程的問題

 四、配置 Spring 的配置文件

1.加入 context 和 tx 的命名空間，關於如何加入命名空間，上文中進行了詳細的說明，此處不再贅述。

2.配置自動掃描的包

<!-- 配置自動掃描的包 -->
    <context:component-scan base-package="com.software.sssp">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
         <context:exclude-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice"/>
    </context:component-scan>

注意，此處我們使用 context:exclude-filter 來設置不進行掃描的包，原因在上文中也已經詳細說明。

3.配置數據源

1）在類路徑下新建一個 db.properties 文件，設置連接數據庫的基本信息，在這樓主只設置必須的屬性

jdbc.user=root
jdbc.password=qiqingqing
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql://localhost:3306/sssp

2）在 Spring 的配置文件中導入 db.properties 文件，進行數據源的配置

<!-- 配置數據源 -->
    <!-- 導入資源配置文件 -->
    <context:property-placeholder location="classpath:db.properties"/>
    
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
        <property name="driverClass" value="${jdbc.driverClass}"></property>
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
    </bean>

至此數據源的配置已經結束，在樓主的博客中，樓主不只強調了一次進行分步測試或單元測試的重要性，可以為我們避免不必要的麻煩，接下來就看看我們的數據源是否配置成功。樓主新建一個測試類 SSSPTest，先來測試一下數據源：

public class SSSPTest {
    
    private ApplicationContext ctx = null;
    
    {
        ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    }
    
    @Test
    public void testDataSource() throws SQLException {
        DataSource dataSource = ctx.getBean(DataSource.class);
        System.out.println(dataSource.getConnection());
    }

}

執行 testDataSource 方法，結果為：

這就證明我們的數據源獲取成功！

4. 配置 JPA 的 EntityManagerFactory 

<!-- 配置 JPA 的 EntityManagerFactory -->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="packagesToScan" value="com.software.sssp"></property>
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"></bean>
        </property>
        <property name="jpaProperties">
            <props>
                <prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">true</prop>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
                
                <prop key="hibernate.cache.use_second_level_cache">true</prop>
                <prop key="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</prop>
                <prop key="hibernate.cache.use_query_cache">true</prop>
            </props>
        </property>
        <!-- 配置使用二級緩存的模式：只允許帶有 @Cacheable 的類使用二級緩存 -->
        <property name="sharedCacheMode" value="ENABLE_SELECTIVE"></property>
    </bean>

解釋一下，第 3 行配置數據源，4 行配置掃描的包，5 行配置 JPA 提供商的適配器，8 行配置 JPA 實現產品即 Hibernate 的基本屬性，22 行配置二級緩存相關。

5. 配置 JPA 的注解和基於注解的事務操作

<!-- 配置 JPA 的注解 -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"></property>
    </bean>
    
    <!-- 配置基於注解的事務 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

到這里 JPA 的配置已經完成了，我們再來測試一下 JPA 是否配置成功

我們新建我們需要的兩個實體類，Employee 和 Department，為它們添加基本的 JPA 注解

package com.software.sssp.entity;

import java.util.Date;

import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

import org.springframework.format.annotation.DateTimeFormat;

@Table(name="SSSP_EMPLOYEES")
@Entity
public class Employee {
    
    private Integer id;
    
    private String lastName;
    
    private String email;
    
    @DateTimeFormat(pattern="yyyy-MM-dd")
    private Date Birth;
    
    private Date createTime;
    
    private Department department;

    @GeneratedValue
    @Id
    public Integer getId() {
        return id;
    }

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

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    @Temporal(TemporalType.DATE)
    public Date getBirth() {
        return Birth;
    }

    public void setBirth(Date birth) {
        Birth = birth;
    }

    @Temporal(TemporalType.TIMESTAMP)
    public Date getCreateTime() {
        return createTime;
    }

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

    @JoinColumn(name="DEPARTMENT_ID")
    @ManyToOne(fetch=FetchType.LAZY)
    public Department getDepartment() {
        return department;
    }

    public void setDepartment(Department department) {
        this.department = department;
    }
    
}

package com.software.sssp.entity;

import javax.persistence.Cacheable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Cacheable
@Table(name="SSSP_DEPARTMENT")
@Entity
public class Department {
    
    private Integer id;
    
    private String departmentName;

    @GeneratedValue
    @Id
    public Integer getId() {
        return id;
    }

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

    public String getDepartmentName() {
        return departmentName;
    }

    public void setDepartmentName(String departmentName) {
        this.departmentName = departmentName;
    }
    
}

然后同樣是在 SSSPTest 中執行測試數據源的那個方法，大家會發現，數據庫中多出了兩張表

這就證明 JPA 配置成功

6. 加入 SpringData

<!-- 配置 SpringData -->
    <jpa:repositories base-package="com.software.sssp" 
                                entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>

 五、web.xml 中雜項配置

1. 因為案例中會用到中文，我們配置一個字符編碼的過濾器

<!-- 配置字符編碼過濾器 -->
    <!-- 字符編碼過濾器必須配置在所有過濾器的最前面! -->
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>        
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

需要注意的是，這個字符編碼過濾器需要配置在所有過濾器的最前面。

2.因為我們的案例中使用 ResultFul 風格的 URL ，所以在配置一個將 POST 請求轉換為 PUT DELETE 請求的 Filter

<!-- 配置將 POST 請求轉換為 PUT DELETE 請求的 Filter -->
    <filter>
        <filter-name>HiddenHttpMethodFilter</filter-name>
        <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
    </filter>
    
    <filter-mapping>
        <filter-name>HiddenHttpMethodFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

至此呢，我們的 SSSP 整合所有的配置和測試就完成了！

六、實現分頁操作

SSSP 整合完成后呢，數據庫中也生成了對應的數據表，樓主向數據庫中寫入了十幾條測試數據。然后我們實現分頁查詢顯示的效果。

思路分析：

1.DAO 層：直接調用 PagingAndSortingRepository 的 findAll(Pageable pageable) 方法，返回 Page 對象即可（注：關於 PagingAndSortingRepository  的使用樓主在介紹 SpringData 的博客已經詳細講解過了）。

2.Service 層：把 Controller 傳入的 pageNo 和 pageSize 封裝成為 Pageable 對象，然后調用 DAO 層的方法即可。

3.Controller 層：獲取 pageNo 並對 pageNo 進行校驗，然后調用 Service  層的方法返回 Page 對象，將 Page 對象放入到 Request 域中進行頁面轉發。

4.JSP 頁面：數據的顯示

思路分析完成之后進行編碼實現。

EmployeeRepository：只定義一個繼承 JpaRepository 的接口即可。

public interface EmployeeRepository extends JpaRepository<Employee, Integer> {
    

}

EmployeeService：

@Service
public class EmployeeService {

    @Autowired
    private EmployeeRepository employeeRepository;
    
    @Transactional(readOnly=true)
    public Page<Employee> getPage(int pageNo, int pageSize) {
        PageRequest pageable = new PageRequest(pageNo - 1, pageSize);
        return employeeRepository.findAll(pageable);
    }
    
}

定義了一個 getPage 方法，為該方法添加只讀的事務操作注解，然后調用 DAO 的 findAll() 方法即可，注意 pageNo 是從 0 開始的，所以要對傳入的 pageNo 進行 - 1 的處理。

EmployeeHandler：

@Controller
public class EmployeeHandler {
    
    @Autowired
    private EmployeeService employeeService;
    
    @RequestMapping("/emps")
    public String list(@RequestParam(value="pageNo", required=false, defaultValue="1") String pageNoStr,
            Map<String, Object> map) {
        
        int pageNo = 1;
        
        try {
            //對 pageNo 的校驗
            pageNo = Integer.parseInt(pageNoStr);
            if(pageNo < 0) {
                pageNo = 1;
            }
        } catch (Exception e) {}
        
        Page<Employee> page = employeeService.getPage(pageNo, 5);
        map.put("page", page);
        
        return "emp/list";
    }

}

創建了一個 list 方法，傳入的 pageNoStr 被定義成了 String 類型的，11 行定義了一個 int 型的 pageNo，將 pageNoStr 強轉為 int 型，若傳入的是一個非數值型的字符串，則會出異常，出了異常不必理會，pageNo 還是一開始定義的那個 pageNo，為 1。然后調用 Service 層的方法，定義 pageSize 為 5，得到 Page 對象，放入到 request  域中。

list.jsp 進行數據的顯示即可：

<c:if test="${page == null || page.numberOfElements == 0 }">
        <h3>沒有員工記錄！</h3>
    </c:if>
    
    <c:if test="${page != null && page.numberOfElements > 0 }">
    
        <table border="1" cellspacing="0" cellpadding="10">
        
            <tr>
                <th>Id</th>
                <th>LastName</th>
                
                <th>Email</th>
                <th>Birth</th>
                
                <th>CreateTime</th>
                <th>DepartmentName</th>
                
                <th>Edit</th>
                <th>Delete</th>
            </tr>
            
            <c:forEach items="${page.content }" var="emp">
                
                <tr>
                    <td>${emp.id }</td>
                    <td>${emp.lastName }</td>
                    
                    <td>${emp.email }</td>
                    <td>${emp.birth }</td>
                    
                    <td>${emp.createTime }</td>
                    <td>${emp.department.departmentName }</td>
                    
                    <td>
                        <a href="${pageContext.request.contextPath }/emp/${emp.id}">Edit</a>
                    </td>
                    <td>
                        <a href="${pageContext.request.contextPath }/emp/${emp.id}" class="delete">Delete</a>
                        <input type="hidden" value="${emp.lastName }">
                    </td>
                </tr>
                
            </c:forEach>
            
            <tr>
                <td colspan="8">
                    共 ${page.totalElements} 條記錄  &nbsp;&nbsp;&nbsp;
                    共 ${page.totalPages} 頁  &nbsp;&nbsp;&nbsp;
                    當前為 ${page.number + 1 } 頁  &nbsp;&nbsp;&nbsp;
                    
                    <c:if test="${page.number + 1 > 1 }">
                        <a href="?pageNo=${page.number + 1 - 1 }">上一頁</a>  &nbsp;&nbsp;&nbsp;
                    </c:if>
                    
                    <c:if test="${page.number + 1 < page.totalPages}">
                        <a href="?pageNo=${page.number + 1 + 1 }">下一頁</a>  &nbsp;&nbsp;&nbsp;
                    </c:if>
                </td>
            </tr>
                        
        </table>
        
    </c:if>

我們注意第 33 行，在顯示 DepartmentName 時使用的是級聯屬性，為了提高效率，減少 SQL 語句，需要設置 Employee 中的 @ManyToOne(fetch=FetchType.LAZY),但是進行了如此設置使用級聯屬性會發生懶加載異常(添加了 @Transactional 注解的事務方法，entityManager 的作用范圍是從方法開始到方法結束，使用 fetch 為 LAZY，獲取的是一個代理對象，若再獲取級聯屬性，則會發生懶加載異常)，所以需要在 web.xml 中配置能夠解決懶加載異常問題的 OpenEntityManagerInViewFilter：

<!-- 配置 OpenEntityManagerInViewFilter,解決懶加載異常的問題 -->
    <filter>
        <filter-name>OpenEntityManagerInViewFilter</filter-name>
        <filter-class>org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter</filter-class>
    </filter>
    
    <filter-mapping>
        <filter-name>OpenEntityManagerInViewFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

最后呢定義一個程序的入口 index.jsp ,其中定義一個顯示員工的超鏈接：

<h4>
    <a href="emps">List All Employees</a>
</h4>

到此我們分頁顯示的功能就完成了，貼一下運行結果：

相比於原生的 JavaWeb 實現分頁操作是不是很簡單呢，效率也提高了很多。