Spring–添加SpringMVC

歡迎來到本教程的第四部分。在這一部分中，我們將使用Spring MVC編寫控制器和視圖，并考慮我們的REST模型。

我們必須做的第一件事，就是根據目前的情況制作一個Web應用程序。我們將web / WEB-INF文件夾添加到我們的項目根目錄。在WEB-INF內創建jsp文件夾。我們將把JSP放在那個地方。在該文件夾內，我們將放置具有以下內容的部署描述符web.xml文件：

<?xml version='1.0' encoding='UTF-8'?>
<web-app xmlns='http://java.sun.com/xml/ns/javaee'xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'xsi:schemaLocation='http://java.sun.com/xml/ns/javaeehttp://java.sun.com/xml/ns/javaee/web-app_3_0.xsd'version='3.0'><display-name>timesheet-app</display-name><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:persistence-beans.xml</param-value></context-param><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><servlet><servlet-name>timesheet</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>timesheet</servlet-name><url-pattern>/</url-pattern></servlet-mapping></web-app>

注意，我們正在使用稱為時間表的servlet。這是一個調度程序servlet。下圖說明了Spring的調度程序servlet的工作方式（在下面的圖片中稱為Front控制器）：

請求由調度程序Servlet處理
分派器servlet決定將請求傳遞到哪個控制器（通過請求映射，我們將在后面看到），然后將請求委托
控制器創建模型并將其傳遞回調度程序Servlet
分派器Servlet解析視圖的邏輯名稱，在此綁定模型并呈現視圖

最后一步很神秘。調度程序Servlet如何解析視圖的邏輯名稱？它使用稱為ViewResolver的東西。但是我們不會手工創建自己的，而是只創建另一個配置文件，使用ViewResolver定義一個bean，并由Spring注入它。在WEB-INF中創建另一個Spring配置文件。按照約定，它必須命名為timesheet-servlet.xml ，因為我們將DispatcherServlet命名為“ timesheet”，并且這是文件名，Spring將在其中默認情況下查找config。還創建包org.timesheet.web 。這是我們將放置控制器的地方（它們也只是帶注釋的POJO）。

這是時間表-servlet.xml

<?xml version='1.0' encoding='UTF-8'?>
<beans xmlns='http://www.springframework.org/schema/beans'xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'xmlns:context='http://www.springframework.org/schema/context'xsi:schemaLocation='http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd'><context:component-scan base-package='org.timesheet.web' /><beanclass='org.springframework.web.servlet.view.InternalResourceViewResolver'><property name='prefix' value='/WEB-INF/jsp/' /><property name='suffix' value='.jsp' /></bean>
</beans>

我們定義了前綴和后綴來解析邏輯名。真的很簡單。我們這樣計算名稱：
全名=前綴+邏輯名+后綴
因此，使用我們的InternalResourceViewResolver，邏輯名稱“ index”將解析為“ /WEB-INF/jsp/index.jsp”。

對于視圖，我們將結合使用JSP技術和JSTL（標記庫），因此我們需要向pom.xml文件中添加另一個依賴項：

<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></dependency>

現在，我們想在/ timesheet-app / welcome上處理GET。因此，我們需要編寫視圖和控制器（對于Model，我們將使用Spring工具中的一個）。讓我們從控制器開始：

package org.timesheet.web;import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;import java.util.Date;@Controller
@RequestMapping('/welcome')
public class WelcomeController {@RequestMapping(method = RequestMethod.GET)public String showMenu(Model model) {model.addAttribute('today', new Date());return 'index';}}

因此，當有人訪問url歡迎（在我們的示例中為http：// localhost：8080 / timesheet-app / welcome ）時，此控制器將處理請求。我們還使用Model并在那里綁定名為“ today”的值。這就是我們如何獲得查看頁面的價值。

請注意，我的應用程序的根目錄是/ timesheet-app。這稱為應用程序上下文 。您當然可以更改它，但是假設您是應用程序上下文，則所有其余代碼都按這樣設置。如果要部署WAR，它將基于WAR的名稱。

從showMenu方法中，我們返回“索引”，它將被解析為WEB-INF / jsp / index.jsp，因此讓我們創建一個這樣的頁面并放置一些基本內容：

<%@ page contentType='text/html;charset=UTF-8' language='java' %>
<%@ taglib prefix='fmt' uri='http://java.sun.com/jsp/jstl/fmt' %>
<%@ taglib prefix='spring' uri='http://www.springframework.org/tags' %><html>
<head><title>Welcome to Timesheet app!</title>
</head>
<body><h1>Welcome to the Timesheet App!</h1><ul><li><a href='managers'>List managers</a></li><li><a href='employees'>List employees</a></li><li><a href='tasks'>List tasks</a></li><li><a href='timesheets'>List timesheets</a></li></ul><h2>Also check out <a href='timesheet-service'>extra services!</a></h2>Today is: <fmt:formatDate value='${today}' pattern='dd-MM-yyyy' />
</body>
</html>

回顧一下，我們添加了web.xml文件，timesheet-servlet.xml Spring配置文件，控制器類和jsp頁面。讓我們嘗試在某些Web容器上運行它。我將使用Tomcat7，但是如果您對其他Web容器甚至應用程序服務器更滿意，請隨時進行切換。現在，有很多方法可以運行Tomcat以及部署應用程序。您可以：

結合使用嵌入式Tomcat和Maven插件
直接從IntelliJ運行Tomcat
直接從Eclipse / STS運行Tomcat

無論選擇哪種方式，請確保您可以訪問上述URL，然后再繼續。坦白說，用Java進行部署對我來說并不是一件很有趣的事情，因此，如果您感到沮喪，請不要放棄，它可能不會第一次起作用。但是使用上面的教程，您可能不會有任何問題。另外，不要忘記設置正確的應用程序上下文。

在編寫更多控制器之前，讓我們準備一些數據。當Spring創建welcomeController bean時，我們想要一些數據。因此，現在，讓我們編寫虛擬生成器，它會創建一些實體。在本教程的后面，我們將看到一些更實際的解決方案。

將輔助程序包放在Web程序包下，然后將控制器放置在EntityGenerator類中：

package org.timesheet.web.helpers;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.timesheet.domain.Employee;
import org.timesheet.domain.Manager;
import org.timesheet.domain.Task;
import org.timesheet.domain.Timesheet;
import org.timesheet.service.GenericDao;
import org.timesheet.service.dao.EmployeeDao;
import org.timesheet.service.dao.ManagerDao;
import org.timesheet.service.dao.TaskDao;
import org.timesheet.service.dao.TimesheetDao;import java.util.List;/*** Small util helper for generating entities to simulate real system.*/
@Service
public final class EntityGenerator {@Autowiredprivate EmployeeDao employeeDao;@Autowiredprivate ManagerDao managerDao;@Autowiredprivate TaskDao taskDao;@Autowiredprivate TimesheetDao timesheetDao;public void generateDomain() {Employee steve = new Employee('Steve', 'Design');Employee bill = new Employee('Bill', 'Marketing');Employee linus = new Employee('Linus', 'Programming');// free employees (no tasks/timesheets)Employee john = new Employee('John', 'Beatles');Employee george = new Employee('George', 'Beatles');Employee ringo = new Employee('Ringo', 'Beatles');Employee paul = new Employee('Paul', 'Beatles');Manager eric = new Manager('Eric');Manager larry = new Manager('Larry');// free managersManager simon = new Manager('Simon');Manager garfunkel = new Manager('Garfunkel');addAll(employeeDao, steve, bill, linus, john, george, ringo, paul);addAll(managerDao, eric, larry, simon, garfunkel);Task springTask = new Task('Migration to Spring 3.1', eric, steve, linus);Task tomcatTask = new Task('Optimizing Tomcat', eric, bill);Task centosTask = new Task('Deploying to CentOS', larry, linus);addAll(taskDao, springTask, tomcatTask, centosTask);Timesheet linusOnSpring = new Timesheet(linus, springTask, 42);Timesheet billOnTomcat = new Timesheet(bill, tomcatTask, 30);addAll(timesheetDao, linusOnSpring, billOnTomcat);}public void deleteDomain() {List<Timesheet> timesheets = timesheetDao.list();for (Timesheet timesheet : timesheets) {timesheetDao.remove(timesheet);}List<Task> tasks = taskDao.list();for (Task task : tasks) {taskDao.remove(task);}List<Manager> managers = managerDao.list();for (Manager manager : managers) {managerDao.remove(manager);}List<Employee> employees = employeeDao.list();for (Employee employee : employees) {employeeDao.remove(employee);}}private <T> void addAll(GenericDao<T, Long> dao, T... entites) {for (T o : entites) {dao.add(o);}}
}

現在，讓我們使用WelcomeController的代碼。我們將在此處注入生成器，并放置使用@PostConstruct注釋進行注釋的特殊方法。這是用于bean生命周期的JSR-250注釋，Spring對此進行了支持。這意味著，在Spring IoC容器實例化welcomeController bean之后，將立即調用此方法。

package org.timesheet.web;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.timesheet.web.helpers.EntityGenerator;import javax.annotation.PostConstruct;
import java.util.Date;@Controller
@RequestMapping('/welcome')
public class WelcomeController {@Autowiredprivate EntityGenerator entityGenerator;@RequestMapping(method = RequestMethod.GET)public String showMenu(Model model) {model.addAttribute('today', new Date());return 'index';}@PostConstructpublic void prepareFakeDomain() {entityGenerator.deleteDomain();entityGenerator.generateDomain();}}

好吧，現在就為域邏輯編寫一些控制器！

我們將從編寫Employee的控制器開始。首先，在org.timesheet.web包下創建EmployeeController類。將class標記為Web控制器并處理“ /員工”請求：

@Controller
@RequestMapping('/employees')
public class EmployeeController { ...

為了處理持久性數據（在這種情況下為Employees），我們需要DAO并將其通過Spring的IoC容器自動連接，所以我們就可以這樣做：

private EmployeeDao employeeDao;@Autowiredpublic void setEmployeeDao(EmployeeDao employeeDao) {this.employeeDao = employeeDao;}

現在我們要處理HTTP GET方法。當用戶使用Web瀏覽器訪問http：// localhost：8080 / timesheet-app / employees時，控制器必須處理GET請求。只是聯系DAO并收集所有員工并將他們納入模型。

@RequestMapping(method = RequestMethod.GET)public String showEmployees(Model model) {List<Employee> employees = employeeDao.list();model.addAttribute('employees', employees);return 'employees/list';}

在jsp文件夾下，創建employees文件夾，我們將在其中放置所有相應的雇員JSP。可能您已經注意到，包含員工列表的頁面將解析為/WEB-INF/jsp/employees/list.jsp。因此，創建這樣的頁面。稍后，我們將查看內容，如果您愿意，可以暫時在其中放置隨機文本以查看其是否有效。

在JSP頁面中，我們將在員工個人頁面旁邊顯示一個鏈接，該鏈接看起來像http：// localhost：8080 / timesheet-app / employees / {id} ，其中ID是員工的ID。這是RESTful URL，因為它是面向資源的，我們正在直接標識資源。 RESTless URL類似于http：// localhost：8080 / timesheet-app / employees.html？id = 123。那是面向行動的，不能識別資源。

讓我們向控制器添加另一個方法來處理此URL：

@RequestMapping(value = '/{id}', method = RequestMethod.GET)public String getEmployee(@PathVariable('id') long id, Model model) {Employee employee = employeeDao.find(id);model.addAttribute('employee', employee);return 'employees/view';}

同樣，在/ jsp / employees文件夾下創建view.jsp頁面。在此頁面上，我們還想更改員工。我們只是訪問相同的URL，但使用不同的Web方法-POST。這意味著，我們正在從有限模型中提供數據以進行更新。

此方法處理員工更新：

@RequestMapping(value = '/{id}', method = RequestMethod.POST)public String updateEmployee(@PathVariable('id') long id, Employee employee) {employee.setId(id);employeeDao.update(employee);return 'redirect:/employees';}

在這種情況下，我們使用GET或POST方法訪問employee / {id}。但是，如果我們要刪除員工怎么辦？我們將訪問相同的URL，但使用不同的方法-DELETE 。我們將在EmployeeDao中使用其他業務邏輯。如果出現任何問題，我們將引發包含無法刪除的員工的異常。因此，在這種情況下，請添加控制器方法：

/*** Deletes employee with specified ID* @param id Employee's ID* @return redirects to employees if everything was ok* @throws EmployeeDeleteException When employee cannot be deleted*/@RequestMapping(value = '/{id}', method = RequestMethod.DELETE)public String deleteEmployee(@PathVariable('id') long id)throws EmployeeDeleteException {Employee toDelete = employeeDao.find(id);boolean wasDeleted = employeeDao.removeEmployee(toDelete);if (!wasDeleted) {throw new EmployeeDeleteException(toDelete);}// everything OK, see remaining employeesreturn 'redirect:/employees';}

注意，我們正在從該方法返回重定向 。 redirect：前綴表示應將請求重定向到它之前的路徑。

創建包org.timesheet.web.exceptions并將EmployeeDeleteException放在下面：

package org.timesheet.web.exceptions;import org.timesheet.domain.Employee;/*** When employee cannot be deleted.*/
public class EmployeeDeleteException extends Exception {private Employee employee;public EmployeeDeleteException(Employee employee) {this.employee = employee;}public Employee getEmployee() {return employee;}
}

可以說，可以直接從DAO拋出此異常。現在我們該如何處理？ Spring有一個特殊的注釋，稱為@ExceptionHandler 。我們將其放置在控制器中，并在拋出指定異常時，使用ExceptionHandler注釋的方法將對其進行處理并解析正確的視圖：

/*** Handles EmployeeDeleteException* @param e Thrown exception with employee that couldn't be deleted* @return binds employee to model and returns employees/delete-error*/@ExceptionHandler(EmployeeDeleteException.class)public ModelAndView handleDeleteException(EmployeeDeleteException e) {ModelMap model = new ModelMap();model.put('employee', e.getEmployee());return new ModelAndView('employees/delete-error', model);}

好的，時間到了JSP。我們將使用一些資源（例如* .css或* .js），以便在您的Web應用程序根目錄中創建resources文件夾。 WEB-INF不是root，它是上面的文件夾。因此，資源和WEB-INF現在應該在目錄樹中處于同一級別。我們已經將調度程序servlet配置為處理每個請求（使用/ url模式），但是我們不想讓它的atm處理靜態資源。我們將通過簡單地將默認servlet的映射放入我們的web.xml文件中來解決該問題：

<servlet-mapping><servlet-name>default</servlet-name><url-pattern>/resources/*</url-pattern></servlet-mapping>

在那些資源下創建styles.css文件。即使我們稍后將使用lota之類的東西，我們現在也將CSS放在整個應用程序中。

table, th {margin: 10px;padding: 5px;width: 300px;
}.main-table {border: 2px solid green;border-collapse: collapse;
}.wide {width: 600px;
}.main-table th {background-color: green;color: white;
}.main-table td {border: 1px solid green;
}th {text-align: left;
}h1 {margin: 10px;
}a {margin: 10px;
}label {display: block;text-align: left;
}#list {padding-left: 10px;position: relative;
}#list ul {padding: 0;
}#list li {list-style: none;margin-bottom: 1em;
}.hidden {display: none;
}.delete {margin: 0;text-align: center;
}.delete-button {border: none;background: url('/timesheet-app/resources/delete.png') no-repeat top left;color: transparent;cursor: pointer;padding: 2px 8px;
}.task-table {width: 150px;border: 1px solid #dcdcdc;
}.errors {color: #000;background-color: #ffEEEE;border: 3px solid #ff0000;padding: 8px;margin: 16px;
}

現在，讓我們創建employeeess / list.jsp頁面：

<%@ page contentType='text/html;charset=UTF-8' language='java' %>
<%@ taglib prefix='fmt' uri='http://java.sun.com/jsp/jstl/fmt' %>
<%@ taglib prefix='spring' uri='http://www.springframework.org/tags' %>
<%@ taglib prefix='c' uri='http://java.sun.com/jsp/jstl/core'%>
<%@ taglib prefix='sf' uri='http://www.springframework.org/tags/form'%><html>
<head><title>Employees</title><link rel='stylesheet' href='/timesheet-app/resources/style.css' type='text/css'>
</head>
<body><h1>List of employees</h1><a href='employees?new'>Add new employee</a><table cellspacing='5' class='main-table'><tr><th>Name</th><th>Department</th><th>Details</th><th>Delete</th></tr><c:forEach items='#{employees}' var='emp'><tr><td>${emp.name}</td><td>${emp.department}</td><td><a href='employees/${emp.id}'>Go to page</a></td><td><sf:form action='employees/${emp.id}' method='delete' cssClass='delete'><input type='submit' class='delete-button' value='' /></sf:form></td></tr></c:forEach></table><br /><a href='welcome'>Go back</a>
</body>
</html>

在該頁面上，我們正在資源下鏈接css（具有包括應用程序上下文的全名）。還有鏈接到員工詳細信息頁面（view.jsp）的鏈接，該頁面由員工的ID解析。
最有趣的部分是SF taglib的用法。為了保持對Web 1.0的友好，我們很遺憾不能直接使用DELETE。直到HTML4和XHTML1，HTML表單只能使用GET和POST。解決方法是，如果實際上應將POST用作DELETE，則使用標記的隱藏字段。這正是Spring免費為我們服務的-僅使用sf：form前綴。因此，我們正在通過HTTP POST隧道傳送DELETE，但它將被正確調度。為此，我們必須為此在web.xml中添加特殊的Spring過濾器：

<filter><filter-name>httpMethodFilter</filter-name><filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class></filter><filter-mapping><filter-name>httpMethodFilter</filter-name><url-pattern>/*</url-pattern></filter-mapping>

即使JSP是實際上已編譯為servlet的Java特定技術，我們也可以像使用任何HTML頁面一樣使用它。我們添加了一些CSS，現在我們添加了最受歡迎的javascript庫– jQuery。轉到https://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.js并下載jquery.js文件，并將其拖放到資源文件夾中。我們將允許用戶使用POST更新資源，因此我們將使用jQuery進行某些DOM操作-只是出于幻想。您可以在普通HTML頁面中使用幾乎所有內容。

現在讓我們創建/employees/view.jsp －這是員工的詳細頁面。

<%@ page contentType='text/html;charset=UTF-8' language='java' %>
<%@ taglib prefix='sf' uri='http://www.springframework.org/tags/form'%><html>
<head><title>Employee page</title><link rel='stylesheet' href='/timesheet-app/resources/style.css' type='text/css'>
</head>
<body><h2>Employee info</h2><div id='list'><sf:form method='post'><ul><li><label for='name'>Name:</label><input name='name' id='name' value='${employee.name}' disabled='true'/></li><li><label for='department'>Department:</label><input name='department' id='department' value='${employee.department}' disabled='true' /></li><li><input type='button' value='Unlock' id='unlock' /><input type='submit' value='Save' id='save' class='hidden' /></li></ul></sf:form></div><br /><br /><a href='../employees'>Go Back</a><script src='/timesheet-app/resources/jquery-1.7.1.js'></script><script>(function() {$('#unlock').on('click', function() {$('#unlock').addClass('hidden');// enable stuff$('#name').removeAttr('disabled');$('#department').removeAttr('disabled');$('#save').removeClass('hidden');});})();</script>
</body>
</html>

在頁面內部，我們引用jQuery文件，并具有自動調用的匿名功能-單擊具有ID“解鎖”的按鈕后，我們將其隱藏，顯示提交按鈕并解鎖字段，以便可以更新員工。按下“保存”按鈕后，我們將被重定向回員工列表，并且此列表已更新。

我們將在Employee上完成CRUD的最后一項功能是添加。我們將通過使用GET和我們稱之為new的額外參數來訪問員工來解決這一問題。因此，用于添加員工的URL將是： http：// localhost：8080 / timesheet-app / employees？new
讓我們為此修改控制器：

@RequestMapping(params = 'new', method = RequestMethod.GET)public String createEmployeeForm(Model model) {model.addAttribute('employee', new Employee());return 'employees/new';}

這將為新的JSP頁面提供服務-/ WEB-INF / jsp / employees / new.jsp ：

<%@ taglib prefix='sf' uri='http://www.springframework.org/tags/form' %>
<%@ page contentType='text/html;charset=UTF-8' language='java' %>
<html>
<head><title>Add new employee</title><link rel='stylesheet' href='/timesheet-app/resources/style.css' type='text/css'>
</head>
<body><h2>Add new Employee</h2><div id='list'><sf:form method='post' action='employees'><ul><li><label for='name'>Name:</label><input name='name' id='name' value='${employee.name}'/></li><li><label for='department'>Department:</label><input name='department' id='department'value='${employee.department}' /></li><li><input type='submit' value='Save' id='save' /></li></ul></sf:form></div><br /><br /><a href='employees'>Go Back</a>
</body>
</html>

該頁面與view.jsp非常相似。在現實世界的應用程序中，我們將使用Apache Tiles之類的方法來減少冗余代碼，但是現在讓我們不必擔心。

請注意，我們提交的表格帶有“員工”操作。回到我們的控制器，讓我們使用POST http方法處理員工：

@RequestMapping(method = RequestMethod.POST)public String addEmployee(Employee employee) {employeeDao.add(employee);return 'redirect:/employees';}

而且，當我們無法刪除雇員jsp / employees / delete-error.jsp時，請不要忘記錯誤的JSP頁面：

<html>
<head><title>Cannot delete employee</title>
</head>
<body>Oops! Resource <a href='${employee.id}'>${employee.name}</a> can not be deleted.<p>Make sure employee doesn't have assigned any task or active timesheet.</p><br /><br /><br /><a href='../welcome'>Back to main page.</a>
</body>
</html>

就是這樣，我們為員工提供了完整的CRUD功能。讓我們回顧一下我們剛剛做的基本步驟：

添加了EmployeeController類
在Web根目錄中為靜態內容創建資源文件夾
在web.xml中為默認servlet添加了映射
在資源文件夾中添加了styles.css
在web.xml中使用過濾器配置了POST-DELETE隧道
下載jQuery.js并添加到我們的資源文件夾中
添加了employeeess / list.jsp頁面
添加了employeeess / view.jsp頁面
添加了employeeess / new.jsp頁面
添加了employees / delete-error.jsp頁面

現在，這是控制器的完整代碼：

package org.timesheet.web;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
import org.timesheet.domain.Employee;
import org.timesheet.service.dao.EmployeeDao;
import org.timesheet.web.exceptions.EmployeeDeleteException;import java.util.List;/*** Controller for handling Employees.*/
@Controller
@RequestMapping('/employees')
public class EmployeeController {private EmployeeDao employeeDao;@Autowiredpublic void setEmployeeDao(EmployeeDao employeeDao) {this.employeeDao = employeeDao;}public EmployeeDao getEmployeeDao() {return employeeDao;}/*** Retrieves employees, puts them in the model and returns corresponding view* @param model Model to put employees to* @return employees/list*/@RequestMapping(method = RequestMethod.GET)public String showEmployees(Model model) {List<Employee> employees = employeeDao.list();model.addAttribute('employees', employees);return 'employees/list';}/*** Deletes employee with specified ID* @param id Employee's ID* @return redirects to employees if everything was ok* @throws EmployeeDeleteException When employee cannot be deleted*/@RequestMapping(value = '/{id}', method = RequestMethod.DELETE)public String deleteEmployee(@PathVariable('id') long id)throws EmployeeDeleteException {Employee toDelete = employeeDao.find(id);boolean wasDeleted = employeeDao.removeEmployee(toDelete);if (!wasDeleted) {throw new EmployeeDeleteException(toDelete);}// everything OK, see remaining employeesreturn 'redirect:/employees';}/*** Handles EmployeeDeleteException* @param e Thrown exception with employee that couldn't be deleted* @return binds employee to model and returns employees/delete-error*/@ExceptionHandler(EmployeeDeleteException.class)public ModelAndView handleDeleteException(EmployeeDeleteException e) {ModelMap model = new ModelMap();model.put('employee', e.getEmployee());return new ModelAndView('employees/delete-error', model);}/*** Returns employee with specified ID* @param id Employee's ID* @param model Model to put employee to* @return employees/view*/@RequestMapping(value = '/{id}', method = RequestMethod.GET)public String getEmployee(@PathVariable('id') long id, Model model) {Employee employee = employeeDao.find(id);model.addAttribute('employee', employee);return 'employees/view';}/*** Updates employee with specified ID* @param id Employee's ID* @param employee Employee to update (bounded from HTML form)* @return redirects to employees*/@RequestMapping(value = '/{id}', method = RequestMethod.POST)public String updateEmployee(@PathVariable('id') long id, Employee employee) {employee.setId(id);employeeDao.update(employee);return 'redirect:/employees';}/*** Creates form for new employee* @param model Model to bind to HTML form* @return employees/new*/@RequestMapping(params = 'new', method = RequestMethod.GET)public String createEmployeeForm(Model model) {model.addAttribute('employee', new Employee());return 'employees/new';}/*** Saves new employee to the database* @param employee Employee to save* @return redirects to employees*/@RequestMapping(method = RequestMethod.POST)public String addEmployee(Employee employee) {employeeDao.add(employee);return 'redirect:/employees';}}

如果您使用的是SpringSource Tool Suite，則可以直接在IDE中檢查映射。將“ Spring項目性質”添加到您的項目中，在Properties-> Spring-> Bean Support中配置Spring的配置文件。然后右鍵單擊項目，然后按Spring Tools-> Show Request Mappings，您應該看到類似以下內容：

關于員工的最后一件事是編寫JUnit測試。由于我們的WEB-INF中有timesheet-servlet.xml，因此無法在JUnit測試中訪問其bean。我們要做的是從timesheet-servlet.xml中 刪除以下行：

<context:component-scan base-package='org.timesheet.web' />

現在，我們在src / main / resources中創建新的Spring Bean配置，并將其稱為controllers.xml 。我們唯一關心的是將自動掃描控制器放在此處，因此內容非常簡單：

<?xml version='1.0' encoding='UTF-8'?>
<beans xmlns='http://www.springframework.org/schema/beans'xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'xmlns:context='http://www.springframework.org/schema/context'xsi:schemaLocation='http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd'><context:component-scan base-package='org.timesheet.web' /></beans>

為了使上下文知道那些spring bean，請像下面這樣更改web.xml中的context-param：

<context-param><param-name>contextConfigLocation</param-name><param-value>classpath:persistence-beans.xmlclasspath:controllers.xml</param-value></context-param>

另外，我們現在必須將bean從controllers.xml導入到timesheet-servlet.xml中，因此，我們添加了以下內容，而不是從timesheet-servlet.xml中刪除<context：component-scan…行：

<import resource='classpath:controllers.xml' />

這將使我們能夠將控制器自動連接到測試。好的，因此在測試源文件夾中，創建包org.timesheet.web，然后將EmployeeControllerTest放在那里。這非常簡單，我們僅將控制器測試為POJO，以及它如何影響持久層（通過DAO驗證）。但是，我們做了一個例外。在方法testDeleteEmployeeThrowsException中 ，我們將明確告訴DAO在嘗試刪除雇員時返回false。這將為我們節省復雜的對象創建和附加DAO的注入。我們將為此使用流行的模擬框架Mockito 。

向您的pom.xml添加依賴項：

<dependency><groupId>org.mockito</groupId><artifactId>mockito-all</artifactId><version>1.9.0</version></dependency>

測試EmployeeController：

package org.timesheet.web;import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.ui.ExtendedModelMap;
import org.springframework.ui.Model;
import org.springframework.web.servlet.ModelAndView;
import org.timesheet.DomainAwareBase;
import org.timesheet.domain.Employee;
import org.timesheet.service.dao.EmployeeDao;
import org.timesheet.web.exceptions.EmployeeDeleteException;import java.util.Collection;
import java.util.List;import static org.junit.Assert.*;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;@ContextConfiguration(locations = {'/persistence-beans.xml', '/controllers.xml'})
public class EmployeeControllerTest extends DomainAwareBase {@Autowiredprivate EmployeeDao employeeDao;@Autowiredprivate EmployeeController controller;private Model model; // used for controller@Beforepublic void setUp() {model = new ExtendedModelMap();}@Afterpublic void cleanUp() {List<Employee> employees = employeeDao.list();for (Employee employee : employees) {employeeDao.remove(employee);}}@Testpublic void testShowEmployees() {// prepare some dataEmployee employee = new Employee('Lucky', 'Strike');employeeDao.add(employee);// use controllerString view = controller.showEmployees(model);assertEquals('employees/list', view);List<Employee> listFromDao = employeeDao.list();Collection<?> listFromModel = (Collection<?>) model.asMap().get('employees');assertTrue(listFromModel.contains(employee));assertTrue(listFromDao.containsAll(listFromModel));}@Testpublic void testDeleteEmployeeOk() throws EmployeeDeleteException {// prepare ID to deleteEmployee john = new Employee('John Lennon', 'Singing');employeeDao.add(john);long id = john.getId();// delete & assertString view = controller.deleteEmployee(id);assertEquals('redirect:/employees', view);assertNull(employeeDao.find(id));}@Test(expected = EmployeeDeleteException.class)public void testDeleteEmployeeThrowsException() throws EmployeeDeleteException {// prepare ID to deleteEmployee john = new Employee('John Lennon', 'Singing');employeeDao.add(john);long id = john.getId();// mock DAO for this callEmployeeDao mockedDao = mock(EmployeeDao.class);when(mockedDao.removeEmployee(john)).thenReturn(false);EmployeeDao originalDao = controller.getEmployeeDao();try {// delete & expect exceptioncontroller.setEmployeeDao(mockedDao);controller.deleteEmployee(id);} finally {controller.setEmployeeDao(originalDao);}}@Testpublic void testHandleDeleteException() {Employee john = new Employee('John Lennon', 'Singing');EmployeeDeleteException e = new EmployeeDeleteException(john);ModelAndView modelAndView = controller.handleDeleteException(e);assertEquals('employees/delete-error', modelAndView.getViewName());assertTrue(modelAndView.getModelMap().containsValue(john));}@Testpublic void testGetEmployee() {// prepare employeeEmployee george = new Employee('George Harrison', 'Singing');employeeDao.add(george);long id = george.getId();// get & assertString view = controller.getEmployee(id, model);assertEquals('employees/view', view);assertEquals(george, model.asMap().get('employee'));}@Testpublic void testUpdateEmployee() {// prepare employeeEmployee ringo = new Employee('Ringo Starr', 'Singing');employeeDao.add(ringo);long id = ringo.getId();// user alters Employee in HTML formringo.setDepartment('Drums');// update & assertString view = controller.updateEmployee(id, ringo);assertEquals('redirect:/employees', view);assertEquals('Drums', employeeDao.find(id).getDepartment());}@Testpublic void testAddEmployee() {// prepare employeeEmployee paul = new Employee('Paul McCartney', 'Singing');// save but via controllerString view = controller.addEmployee(paul);assertEquals('redirect:/employees', view);// employee is stored in DBassertEquals(paul, employeeDao.find(paul.getId()));}
}

注意，我們如何在try / finally塊中使用模擬的dao進行設置。僅用于那一次調用以確保引發正確的異常。如果您從未見過嘲笑，我絕對建議您了解有關此技術的更多信息。有很多模擬框架。我們選擇的一種-Mockito-帶有非常簡潔的語法，該語法大量使用Java靜態導入。

現在，經理與員工非常相似，因此沒有任何大問題，讓我們為經理添加非常相似的內容：

首先，在WEB-INF / jsp中創建管理器文件夾。

現在讓我們編寫控制器并注入相應的DAO：

@Controller
@RequestMapping('/managers')
public class ManagerController {private ManagerDao managerDao;@Autowiredpublic void setManagerDao(ManagerDao managerDao) {this.managerDao = managerDao;}public ManagerDao getManagerDao() {return managerDao;}
}

列表管理員的添加方法：

/*** Retrieves managers, puts them in the model and returns corresponding view* @param model Model to put employees to* @return managers/list*/@RequestMapping(method = RequestMethod.GET)public String showManagers(Model model) {List<Manager> employees = managerDao.list();model.addAttribute('managers', employees);return 'managers/list';}

將list.jsp添加到jsp / managers：

<%@ page contentType='text/html;charset=UTF-8' language='java' %>
<%@ taglib prefix='fmt' uri='http://java.sun.com/jsp/jstl/fmt' %>
<%@ taglib prefix='spring' uri='http://www.springframework.org/tags' %>
<%@ taglib prefix='c' uri='http://java.sun.com/jsp/jstl/core'%>
<%@ taglib prefix='sf' uri='http://www.springframework.org/tags/form'%><html>
<head><title>Managers</title><link rel='stylesheet' href='/timesheet-app/resources/style.css' type='text/css'>
</head>
<body><h1>List of managers</h1><a href='managers?new'>Add new manager</a><table cellspacing='5' class='main-table'><tr><th>Name</th><th>Details</th><th>Delete</th></tr><c:forEach items='#{managers}' var='man'><tr><td>${man.name}</td><td><a href='managers/${man.id}'>Go to page</a></td><td><sf:form action='managers/${man.id}' method='delete' cssClass='delete'><input type='submit' value='' class='delete-button' /></sf:form></td></tr></c:forEach></table><br /><a href='welcome'>Go back</a>
</body>
</html>

添加刪除管理員的方法：

/*** Deletes manager with specified ID* @param id Manager's ID* @return redirects to managers if everything was OK* @throws ManagerDeleteException When manager cannot be deleted*/@RequestMapping(value = '/{id}', method = RequestMethod.DELETE)public String deleteManager(@PathVariable('id') long id)throws ManagerDeleteException {Manager toDelete = managerDao.find(id);boolean wasDeleted = managerDao.removeManager(toDelete);if (!wasDeleted) {throw new ManagerDeleteException(toDelete);}// everything OK, see remaining managersreturn 'redirect:/managers';}

刪除失敗時的異常：

package org.timesheet.web.exceptions;import org.timesheet.domain.Manager;/*** When manager cannot be deleted*/
public class ManagerDeleteException extends Exception {private Manager manager;public ManagerDeleteException(Manager manager) {this.manager = manager;}public Manager getManager() {return manager;}
}

處理此異常的方法：

/*** Handles ManagerDeleteException* @param e Thrown exception with manager that couldn't be deleted* @return binds manager to model and returns managers/delete-error*/@ExceptionHandler(ManagerDeleteException.class)public ModelAndView handleDeleteException(ManagerDeleteException e) {ModelMap model = new ModelMap();model.put('manager', e.getManager());return new ModelAndView('managers/delete-error', model);}

添加獲取經理頁面的方法：

/*** Returns manager with specified ID* @param id Managers's ID* @param model Model to put manager to* @return managers/view*/@RequestMapping(value = '/{id}', method = RequestMethod.GET)public String getManager(@PathVariable('id') long id, Model model) {Manager manager = managerDao.find(id);model.addAttribute('manager', manager);return 'managers/view';}

在jsp / managers下添加經理頁面view.jsp ：

<%@ page contentType='text/html;charset=UTF-8' language='java' %>
<%@ taglib prefix='sf' uri='http://www.springframework.org/tags/form'%><html>
<head><title>Manager page</title><link rel='stylesheet' href='/timesheet-app/resources/style.css' type='text/css'>
</head>
<body><h2>Manager info</h2><div id='list'><sf:form method='post'><ul><li><label for='name'>Name:</label><input name='name' id='name' value='${manager.name}' disabled='true'/></li><li><input type='button' value='Unlock' id='unlock' /><input type='submit' value='Save' id='save' class='hidden' /></li></ul></sf:form></div><br /><br /><a href='../managers'>Go Back</a><script src='/timesheet-app/resources/jquery-1.7.1.js'></script><script>(function() {$('#unlock').on('click', function() {$('#unlock').addClass('hidden');// enable stuff$('#name').removeAttr('disabled');$('#save').removeClass('hidden');});})();</script>
</body>
</html>

JSP頁面，用于處理刪除時的錯誤：

<html>
<head><title>Cannot delete manager</title>
</head>
<body>Oops! Resource <a href='${manager.id}'>${manager.name}</a> can not be deleted.<p>Make sure manager doesn't have assigned any task or active timesheet.</p><br /><br /><br /><a href='../welcome'>Back to main page.</a>
</body>
</html>

添加更新管理器的方法：

/*** Updates manager with specified ID* @param id Manager's ID* @param manager Manager to update (bounded from HTML form)* @return redirects to managers*/@RequestMapping(value = '/{id}', method = RequestMethod.POST)public String updateManager(@PathVariable('id') long id, Manager manager) {manager.setId(id);managerDao.update(manager);return 'redirect:/managers';}

添加用于返回新經理表格的方法：

/*** Creates form for new manager* @param model Model to bind to HTML form* @return manager/new*/@RequestMapping(params = 'new', method = RequestMethod.GET)public String createManagerForm(Model model) {model.addAttribute('manager', new Manager());return 'managers/new';}

在jsp / managers下為新經理new.jsp添加頁面：

<%@ taglib prefix='sf' uri='http://www.springframework.org/tags/form' %>
<%@ page contentType='text/html;charset=UTF-8' language='java' %>
<html>
<head><title>Add new manager</title><link rel='stylesheet' href='/timesheet-app/resources/style.css' type='text/css'>
</head>
<body><h2>Add new Manager</h2><div id='list'><sf:form method='post' action='managers'><ul><li><label for='name'>Name:</label><input name='name' id='name' value='${manager.name}'/></li><li><input type='submit' value='Save' id='save' /></li></ul></sf:form></div><br /><br /><a href='managers'>Go Back</a>
</body>
</html>

最后，添加用于添加管理器的方法：

/*** Saves new manager to the database* @param manager Manager to save* @return redirects to managers*/@RequestMapping(method = RequestMethod.POST)public String addManager(Manager manager) {managerDao.add(manager);return 'redirect:/managers';}

好了，這部分的最后一段代碼是ManagerController的測試用例：

package org.timesheet.web;import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.ui.ExtendedModelMap;
import org.springframework.ui.Model;
import org.springframework.web.servlet.ModelAndView;
import org.timesheet.DomainAwareBase;
import org.timesheet.domain.Manager;
import org.timesheet.service.dao.ManagerDao;
import org.timesheet.web.exceptions.ManagerDeleteException;import java.util.Collection;
import java.util.List;import static org.junit.Assert.*;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;@ContextConfiguration(locations = {'/persistence-beans.xml', '/controllers.xml'})
public class ManagerControllerTest extends DomainAwareBase {@Autowiredprivate ManagerDao managerDao;@Autowiredprivate ManagerController controller;private Model model; // used for controller@Beforepublic void setUp() {model = new ExtendedModelMap();}@Afterpublic void cleanUp() {List<Manager> managers = managerDao.list();for (Manager manager : managers) {managerDao.remove(manager);}}@Testpublic void testShowManagers() {// prepare some dataManager manager = new Manager('Bob Dylan');managerDao.add(manager);// use controllerString view = controller.showManagers(model);assertEquals('managers/list', view);List<Manager> listFromDao = managerDao.list();Collection<?> listFromModel = (Collection<?>) model.asMap().get('managers');assertTrue(listFromModel.contains(manager));assertTrue(listFromDao.containsAll(listFromModel));}@Testpublic void testDeleteManagerOk() throws ManagerDeleteException {// prepare ID to deleteManager john = new Manager('John Lennon');managerDao.add(john);long id = john.getId();// delete & assertString view = controller.deleteManager(id);assertEquals('redirect:/managers', view);assertNull(managerDao.find(id));}@Test(expected = ManagerDeleteException.class)public void testDeleteManagerThrowsException() throws ManagerDeleteException {// prepare ID to deleteManager john = new Manager('John Lennon');managerDao.add(john);long id = john.getId();// mock DAO for this callManagerDao mockedDao = mock(ManagerDao.class);when(mockedDao.removeManager(john)).thenReturn(false);ManagerDao originalDao = controller.getManagerDao();try {// delete & expect exceptioncontroller.setManagerDao(mockedDao);controller.deleteManager(id);} finally {controller.setManagerDao(originalDao);}}@Testpublic void testHandleDeleteException() {Manager john = new Manager('John Lennon');ManagerDeleteException e = new ManagerDeleteException(john);ModelAndView modelAndView = controller.handleDeleteException(e);assertEquals('managers/delete-error', modelAndView.getViewName());assertTrue(modelAndView.getModelMap().containsValue(john));}@Testpublic void testGetManager() {// prepare managerManager george = new Manager('George Harrison');managerDao.add(george);long id = george.getId();// get & assertString view = controller.getManager(id, model);assertEquals('managers/view', view);assertEquals(george, model.asMap().get('manager'));}@Testpublic void testUpdateManager() {// prepare managerManager ringo = new Manager('Ringo Starr');managerDao.add(ringo);long id = ringo.getId();// user alters manager in HTML formringo.setName('Rango Starr');// update & assertString view = controller.updateManager(id, ringo);assertEquals('redirect:/managers', view);assertEquals('Rango Starr', managerDao.find(id).getName());}@Testpublic void testAddManager() {// prepare managerManager paul = new Manager('Paul McCartney');// save but via controllerString view = controller.addManager(paul);assertEquals('redirect:/managers', view);// manager is stored in DBassertEquals(paul, managerDao.find(paul.getId()));}
}

請求映射現在看起來像這樣：

因此，在這一部分中，我們學習了什么是Spring MVC，如何將實體用作模型，如何以POJO風格編寫控制器，RESTful設計的外觀，如何使用JSP創建視圖以及如何使用CSS和JavaScript設置應用程序。

我們為員工和經理編寫了控制器。在下一部分中，我們將繼續為“任務和時間表”編寫控制器。在進行下一部分之前，請確保到目前為止一切正常。

這是src文件夾（僅擴展了新內容。不必擔心.iml文件，它們用于IntelliJ）：