Spring– DAO和服務層

歡迎來到Spring教程的第三部分。在這一部分中，我們將繼續編寫Timesheet應用程序，這次我們將實現DAO層，業務服務并編寫一些測試。

在上一部分中，我們定義了GenericDao接口，該接口告訴我們需要對實體執行哪些操作。現在我們需要提供實現。我們將使用Hibernate的工具（使用SessionFactory）編寫一個類來執行這些操作。因此，任何提供的DAO都會自動繼承這些基本操作。我們稍后再討論。

package org.timesheet.service.impl;import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.timesheet.service.GenericDao;import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.List;/*** Basic DAO operations dependent with Hibernate's specific classes* @see SessionFactory*/
@Transactional(propagation= Propagation.REQUIRED, readOnly=false)
public class HibernateDao<E, K extends Serializable> implements GenericDao<E, K> {private SessionFactory sessionFactory;protected Class<? extends E> daoType;public HibernateDao() {daoType = (Class<E>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];}@Autowiredpublic void setSessionFactory(SessionFactory sessionFactory) {this.sessionFactory = sessionFactory;}protected Session currentSession() {return sessionFactory.getCurrentSession();}@Overridepublic void add(E entity) {currentSession().save(entity);}@Overridepublic void update(E entity) {currentSession().saveOrUpdate(entity);}@Overridepublic void remove(E entity) {currentSession().delete(entity);}@Overridepublic E find(K key) {return (E) currentSession().get(daoType, key);}@Overridepublic List<E> list() {return currentSession().createCriteria(daoType).list();}
}

我希望您注意有關此代碼的幾件事：

我們在類的頂部使用@Transcational批注。這基本上意味著，DAO方法將在事務內運行。為了使其工作，我們需要更改persistence-beans.xml文件，并在其中聲明將處理事務的事務管理器。只需添加以下行（新bean定義）：
```
<bean id='transactionManager'class='org.springframework.orm.hibernate3.HibernateTransactionManager'><property name='sessionFactory' ref='sessionFactory' /></bean>
```
我們正在使用setter注入自動裝配（@Autowired）SessionFactory。如您所知，注入的種類更多（字段，setter，構造函數）。使用Spring時，字段注入看起來最好，因為注釋直接位于字段上，而不是構造函數或setter方法上。另一方面，字段注入是最無用的，因為我們不能手動將其他依賴項設置為私有字段（例如在單元測試中）。我盡可能地喜歡構造函數注入，因為我不必為依賴項使用mutator（setter）。因此，以更安全的方式構造對象。在這種特定情況下，我們將使用setter注入，因為我們正在為擴展設計此類。如果我們選擇構造函數注入，那么所有擴展類都必須具有與超類匹配的構造函數。
如果您想了解更多有關此的內容，我建議您閱讀 Dhanji R. Prasanna撰寫的這本精彩的著作。
還要注意，構造函數的第一行正在做一些反射魔術。那是因為Java在運行時沒有泛型，只有在編譯時才有泛型，因此它阻止我們編寫類似E.class的東西。因此，我們使用了這個丑陋的技巧。

現在，我們有了一些DAO操作的基本模板。在實際系統中，每個實體通常都有DAO。那是因為有時那些繼承的CRUD操作還不夠，您還需要一些其他業務操作 。我們將定義類型安全的接口（每個DAO的操作集），并且以后僅依賴于控制器中的接口。我們將使用Hibernate實施它們，并使其自動接線。創建新的包org.timesheet.service.dao，并在其中添加以下接口–每個實體的DAO：

package org.timesheet.service.dao;import org.timesheet.domain.Employee;
import org.timesheet.service.GenericDao;/*** DAO of employee.*/
public interface EmployeeDao extends GenericDao<Employee, Long> {/*** Tries to remove employee from the system.* @param employee Employee to remove* @return {@code true} if employee is not assigned to any task* or timesheet. Else {@code false}.*/boolean removeEmployee(Employee employee);}

package org.timesheet.service.dao;import org.timesheet.domain.Manager;
import org.timesheet.service.GenericDao;/*** DAO of Manager.*/
public interface ManagerDao extends GenericDao<Manager, Long> {/*** Tries to remove manager from the system.* @param manager Manager to remove* @return {@code true} if manager is not assigned to any task.* Else {@code false}.*/boolean removeManager(Manager manager);
}

package org.timesheet.service.dao;import org.timesheet.domain.Task;
import org.timesheet.service.GenericDao;/*** DAO of Task.*/
public interface TaskDao extends GenericDao<Task, Long> {/*** Tries to remove task from the system.* @param task Task to remove* @return {@code true} if there is no timesheet created on task.* Else {@code false}.*/boolean removeTask(Task task);}

package org.timesheet.service.dao;import org.timesheet.domain.Timesheet;
import org.timesheet.service.GenericDao;/*** DAO of Timesheet.*/
public interface TimesheetDao extends GenericDao<Timesheet, Long> {// no additional business operations atm
}

實施時間。我們將擴展HibernateDao并實現coresponding接口。我們需要這些具體的類，因為這將被注入到相應的字段中（由接口聲明）。也許您已經聽說過有關此方法的一些內容-稱為接口編程，并且您肯定會喜歡這種方法。

package org.timesheet.service.impl;import org.hibernate.Query;
import org.springframework.stereotype.Repository;
import org.timesheet.domain.Employee;
import org.timesheet.service.dao.EmployeeDao;@Repository('employeeDao')
public class EmployeeDaoImpl extends HibernateDao<Employee, Long> implements EmployeeDao {@Overridepublic boolean removeEmployee(Employee employee) {Query employeeTaskQuery = currentSession().createQuery('from Task t where :id in elements(t.assignedEmployees)');employeeTaskQuery.setParameter('id', employee.getId());// employee mustn't be assigned on no taskif (!employeeTaskQuery.list().isEmpty()) {return false;}Query employeeTimesheetQuery = currentSession().createQuery('from Timesheet t where t.who.id = :id');employeeTimesheetQuery.setParameter('id', employee.getId());// employee mustn't be assigned to any timesheetif (!employeeTimesheetQuery.list().isEmpty()) {return false;}// ok, remove as usualremove(employee);return true;}
}

package org.timesheet.service.impl;import org.hibernate.Query;
import org.springframework.stereotype.Repository;
import org.timesheet.domain.Manager;
import org.timesheet.service.dao.ManagerDao;@Repository('managerDao')
public class ManagerDaoImpl extends HibernateDao<Manager, Long> implements ManagerDao {@Overridepublic boolean removeManager(Manager manager) {Query managerQuery = currentSession().createQuery('from Task t where t.manager.id = :id');managerQuery.setParameter('id', manager.getId());// manager mustn't be assigned on no taskif (!managerQuery.list().isEmpty()) {return false;}// ok, remove as usualremove(manager);return true;}
}

package org.timesheet.service.impl;import org.hibernate.Criteria;
import org.hibernate.Query;
import org.springframework.stereotype.Repository;
import org.timesheet.domain.Task;
import org.timesheet.domain.Timesheet;
import org.timesheet.service.dao.TaskDao;import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;@Repository('taskDao')
public class TaskDaoImpl extends HibernateDao<Task, Long> implements TaskDao {@Overridepublic boolean removeTask(Task task) {Query taskQuery = currentSession().createQuery('from Timesheet t where t.task.id = :id');taskQuery.setParameter('id', task.getId());// task mustn't be assigned to no timesheetif (!taskQuery.list().isEmpty()) {return false;}// ok, remove as usualremove(task);return true;}@Overridepublic List<Task> list() {return currentSession().createCriteria(Task.class).setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY).list();}
}

package org.timesheet.service.impl;import org.hibernate.Criteria;
import org.springframework.stereotype.Repository;
import org.timesheet.domain.Timesheet;
import org.timesheet.service.dao.TimesheetDao;import java.util.List;@Repository('timesheetDao')
public class TimesheetDaoImpl extends HibernateDao<Timesheet, Long> implements TimesheetDao {@Overridepublic List<Timesheet> list() {return currentSession().createCriteria(Timesheet.class).setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY).list();}
}

我希望您注意在每個DAO類上都有Spring的@Repository批注。那是因為我們不會手工創建它們，而是讓它們由Spring的IoC容器注入和管理。順便說一句–這是更新的面向注釋的方法。沒有XML配置，Spring會為我們解決我們可以使用大量將類注冊為bean的注釋：

@Component –自動掃描組件（Spring bean）
@Repository –持久層中的組件（通常是DAO）
@Service –服務層中的組件
@Controller – MVC架構中的控制器

另一個令人困擾的事情是，我們將字符串值傳遞給@Repository批注。我將在這里引用Spring的javadoc，因為這是最清晰的解釋： “該值可能表明建議使用邏輯組件名稱，以防自動檢測到的組件被轉換為Spring bean。”

現在-測試時間！創建新程序包： / src / test / java / org / timesheet / service / dao并在此處進行測試。

我們將使用一些外部SQL腳本來驗證數據庫狀態。在src / main / resources下創建文件夾sql 。現在讓我們添加兩個腳本； cleanup.sql和create-data.sql 。現在我們僅使用cleanup.sql腳本，稍后將使用create-data.sql。

創建數據.sql

-- delete old data
delete from task_employee;
delete from timesheet;
delete from task;
delete from employee;
delete from manager;-- add few employees
insert into employee values(1, 'management', 'Steve Jobs');
insert into employee values(2, 'management', 'Bill Gates');
insert into employee values(3, 'engineering', 'Steve Wozniak');
insert into employee values(4, 'engineering', 'Paul Allen');-- add few managers
insert into manager values(1, 'Eric Schmidt');
insert into manager values(2, 'Steve Ballmer');-- add some tasks
insert into task values(1, 0, 'task 1', 1);
insert into task values(2, 0, 'task 2', 2);-- connect tasks to some employees
insert into task_employee values (1, 1);
insert into task_employee values (1, 3);
insert into task_employee values (1, 4);
insert into task_employee values (2, 2);
insert into task_employee values (2, 1);-- create some timesheets on tasks
insert into timesheet values(1,5, -- hours1, -- first task1 -- employee steve jobs
);insert into timesheet values(2,8, -- hours2, -- second task3 -- employee bill gates
);

cleanup.sql

delete from task_employee;
delete from timesheet;
delete from task;
delete from employee;
delete from manager;

您不必使用我的數據；隨時自行創建一些內容。只要確保它們對您有意義。

在編寫測試之前，我們需要新的Spring bean。它被稱為jdbcTemplate ，它是在Spring中使用JDBC的眾所周知的工具。它基本上是簡單JDBC的包裝，簡化了很多事情。由于這一點，我們可以通過簡單的調用來運行腳本，稍后您將看到。

現在，將此bean添加到您的persistence-beans.xml Spring Config文件中：

<bean id='jdbcTemplate'class='org.springframework.jdbc.core.simple.SimpleJdbcTemplate'><constructor-arg type='javax.sql.DataSource' ref='dataSource'/></bean>

我不會對每項測試都給予特別的關注，所以讓我們僅簡要討論一下測試內容和方法。我們正在測試DAO，我們需要確保基本的CRUD操作正常運行。我們將在每種測試方法之后清除所有數據，如有必要，我們將在測試方法運行之前創建它們。我們測試的基本思路是這樣的：

如果添加了某些內容，請檢查是否可以找到
如果已刪除某些內容，請檢查我們是否再找不到該內容
將幾個項目添加到數據庫，對它們進行計數并驗證是否已添加
更新項目，保存。找到它并檢查它是否已更改

我喜歡考慮像集成測試這樣的測試，更像是單元測試。在巨大的領域中，類似的測試將需要（與普通的單元測試不同）大量的時間運行。這次，我們將創建一個稱為org.timesheet.DomainAwareBase的特殊基類。這擴展了AbstractJUnit4SpringContextTests，因此我們可以自動裝配DAO，但是它也可以在使用deleteScript執行任何測試方法之前從數據庫中刪除所有數據。

package org.timesheet;import org.junit.Before;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.FileSystemResource;
import org.springframework.jdbc.core.simple.SimpleJdbcTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
import org.springframework.test.jdbc.SimpleJdbcTestUtils;/*** Base makes sure that before any test empty database is available.*/
@ContextConfiguration(locations = {'/persistence-beans.xml'})
public abstract class DomainAwareBase extends AbstractJUnit4SpringContextTests {private final String deleteScript = 'src/main/resources/sql/cleanup.sql';@Autowiredprivate SimpleJdbcTemplate jdbcTemplate;@Beforepublic void deleteAllDomainEntities() {SimpleJdbcTestUtils.executeSqlScript(jdbcTemplate,new FileSystemResource(deleteScript), false);}
}

關于自動裝配和工具：

對我來說，自動裝配Bean時，工具特別重要。在沒有任何其他支持的情況下瀏覽代碼幾乎沒有什么困難。例如，如果您使用的是IntelliJ IDEA終極版，則可以直接從字段導航到自動裝配的依賴項，因為IntelliJ會添加很少的標記。

或者，您也可以在依賴關系視圖中查看自動裝配的依賴關系以及在XML中聲明的依賴關系。

現在讓我們看一下測試代碼：

package org.timesheet.service.dao;import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.timesheet.DomainAwareBase;
import org.timesheet.domain.Employee;
import org.timesheet.domain.Manager;
import org.timesheet.domain.Task;
import org.timesheet.domain.Timesheet;import java.util.Arrays;
import java.util.List;import static org.junit.Assert.*;@ContextConfiguration(locations = '/persistence-beans.xml')
public class EmployeeDaoTest extends DomainAwareBase {@Autowiredprivate EmployeeDao employeeDao;@Autowiredprivate ManagerDao managerDao;@Autowiredprivate TaskDao taskDao;@Autowiredprivate TimesheetDao timesheetDao;@Testpublic void testAdd() {int size = employeeDao.list().size();employeeDao.add(new Employee('test-employee', 'hackzorz'));// list should have one more employee nowassertTrue (size < employeeDao.list().size());}@Testpublic void testUpdate() {Employee employee = new Employee('test-employee', 'hackzorz');employeeDao.add(employee);employee.setName('updated');employeeDao.update(employee);Employee found = employeeDao.find(employee.getId());assertEquals('updated', found.getName());}@Testpublic void testFind() {Employee employee = new Employee('test-employee', 'hackzorz');employeeDao.add(employee);Employee found = employeeDao.find(employee.getId());assertEquals(found, employee);}@Testpublic void testList() {assertEquals(0, employeeDao.list().size());List<Employee> employees = Arrays.asList(new Employee('test-1', 'testers'),new Employee('test-2', 'testers'),new Employee('test-3', 'testers'));for (Employee employee : employees) {employeeDao.add(employee);}List<Employee> found = employeeDao.list();assertEquals(3, found.size());for (Employee employee : found) {assertTrue(employees.contains(employee));}}@Testpublic void testRemove() {Employee employee = new Employee('test-employee', 'hackzorz');employeeDao.add(employee);// successfully addedassertEquals(employee, employeeDao.find(employee.getId()));// try to removeemployeeDao.remove(employee);assertNull(employeeDao.find(employee.getId()));}@Testpublic void testRemoveEmployee() {Manager manager = new Manager('task-manager');managerDao.add(manager);Employee employee = new Employee('Jaromir', 'Hockey');employeeDao.add(employee);Task task = new Task('test-task', manager, employee);taskDao.add(task);Timesheet timesheet = new Timesheet(employee, task, 100);timesheetDao.add(timesheet);// try to remove -> shouldn't workassertFalse(employeeDao.removeEmployee(employee));// remove stufftimesheetDao.remove(timesheet);taskDao.remove(task);// should work -> employee is now freeassertTrue(employeeDao.removeEmployee(employee));}}

package org.timesheet.service.dao;import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.timesheet.DomainAwareBase;
import org.timesheet.domain.Employee;
import org.timesheet.domain.Manager;
import org.timesheet.domain.Task;import java.util.Arrays;
import java.util.List;import static org.junit.Assert.*;@ContextConfiguration(locations = '/persistence-beans.xml')
public class ManagerDaoTest extends DomainAwareBase {@Autowiredprivate ManagerDao managerDao;@Autowiredprivate EmployeeDao employeeDao;@Autowiredprivate TaskDao taskDao;@Testpublic void testAdd() {int size = managerDao.list().size();managerDao.add(new Manager('test-manager'));assertTrue (size < managerDao.list().size());}@Testpublic void testUpdate() {Manager manager = new Manager('test-manager');managerDao.add(manager);manager.setName('updated');managerDao.update(manager);Manager found = managerDao.find(manager.getId());assertEquals('updated', found.getName());}@Testpublic void testFind() {Manager manager = new Manager('test-manager');managerDao.add(manager);Manager found = managerDao.find(manager.getId());assertEquals(found, manager);}@Testpublic void testList() {assertEquals(0, managerDao.list().size());List<Manager> managers = Arrays.asList(new Manager('test-1'),new Manager('test-2'),new Manager('test-3'));for (Manager manager : managers) {managerDao.add(manager);}List<Manager> found = managerDao.list();assertEquals(3, found.size());for (Manager manager : found) {assertTrue(managers.contains(manager));}}@Testpublic void testRemove() {Manager manager = new Manager('test-manager');managerDao.add(manager);// successfully addedassertEquals(manager, managerDao.find(manager.getId()));// try to removemanagerDao.remove(manager);assertNull(managerDao.find(manager.getId()));}@Testpublic void testRemoveManager() {Manager manager = new Manager('task-manager');managerDao.add(manager);Employee employee = new Employee('Jaromir', 'Hockey');employeeDao.add(employee);Task task = new Task('test-task', manager, employee);taskDao.add(task);// try to remove -> shouldn't workassertFalse(managerDao.removeManager(manager));// remove tasktaskDao.remove(task);// should work -> no more tasks for managerassertTrue(managerDao.removeManager(manager));}
}

package org.timesheet.service.dao;import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.timesheet.DomainAwareBase;
import org.timesheet.domain.Employee;
import org.timesheet.domain.Manager;
import org.timesheet.domain.Task;import java.util.Arrays;
import java.util.List;import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;@ContextConfiguration(locations = '/persistence-beans.xml')
public class TaskDaoTest extends DomainAwareBase {@Autowiredprivate TaskDao taskDao;@Autowiredprivate ManagerDao managerDao;@Autowiredprivate EmployeeDao employeeDao;@Testpublic void testAdd() {int size = taskDao.list().size();Task task = newSpringTask();taskDao.add(task);assertTrue(size < taskDao.list().size());}@Testpublic void testUpdate() {Task task = newSpringTask();taskDao.add(task);// update tasktask.setDescription('Learn Spring 3.1');taskDao.update(task);Task found = taskDao.find(task.getId());assertEquals('Learn Spring 3.1', found.getDescription());}@Testpublic void testFind() {Task task = newSpringTask();taskDao.add(task);assertEquals(task, taskDao.find(task.getId()));}@Testpublic void testList() {assertEquals(0, taskDao.list().size());Task templateTask = newSpringTask();List<Task> tasks = Arrays.asList(newTaskFromTemplate(templateTask, '1'),newTaskFromTemplate(templateTask, '2'),newTaskFromTemplate(templateTask, '3'));for (Task task : tasks) {taskDao.add(task);}List<Task> found = taskDao.list();assertEquals(3, found.size());for (Task task : found) {assertTrue(tasks.contains(task));}}@Testpublic void testRemove() {Task task = newSpringTask();taskDao.add(task);// successfully addedassertEquals(task, taskDao.find(task.getId()));// try to removetaskDao.remove(task);assertNull(taskDao.find(task.getId()));}/*** @return Dummy task for testing*/private Task newSpringTask() {Manager bob = new Manager('Bob');managerDao.add(bob);Employee steve = new Employee('Steve', 'Business');Employee woz = new Employee('Woz', 'Engineering');employeeDao.add(steve);employeeDao.add(woz);return new Task('Learn Spring', bob, steve, woz);}/*** Creates dummy task fo testing as copy of existing task and* adds aditional information to every field.* @param templateTask Task to copy* @param randomInfo Info to append everywhere* @return Random task for testing*/private Task newTaskFromTemplate(Task templateTask, String randomInfo) {String description = templateTask.getDescription() + randomInfo;Manager manager = new Manager(templateTask.getManager().getName());managerDao.add(manager);List<Employee> templateEmployees = templateTask.getAssignedEmployees();Employee[] employees = new Employee[templateEmployees.size()];int idx = 0;for (Employee templateEmployee : templateEmployees) {Employee employee = new Employee(templateEmployee.getName() + randomInfo,templateEmployee.getDepartment() + randomInfo);employees[idx++] = employee;employeeDao.add(employee);}return new Task(description, manager, employees);}
}

package org.timesheet.service.dao;import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.timesheet.DomainAwareBase;
import org.timesheet.domain.Employee;
import org.timesheet.domain.Manager;
import org.timesheet.domain.Task;
import org.timesheet.domain.Timesheet;import java.util.Arrays;
import java.util.List;import static org.junit.Assert.*;@ContextConfiguration(locations = '/persistence-beans.xml')
public class TimesheetDaoTest extends DomainAwareBase {@Autowiredprivate TimesheetDao timesheetDao;// daos needed for integration test of timesheetDao@Autowiredprivate TaskDao taskDao;@Autowiredprivate EmployeeDao employeeDao;@Autowiredprivate ManagerDao managerDao;// common fields for timesheet creationprivate Task task;private Employee employee;@Overridepublic void deleteAllDomainEntities() {super.deleteAllDomainEntities();setUp();}public void setUp() {employee = new Employee('Steve', 'Engineering');employeeDao.add(employee);Manager manager = new Manager('Bob');managerDao.add(manager);task = new Task('Learn Spring', manager, employee);taskDao.add(task);}@Testpublic void testAdd() {int size = timesheetDao.list().size();Timesheet timesheet = newTimesheet();timesheetDao.add(timesheet);assertTrue (size < timesheetDao.list().size());}@Testpublic void testUpdate() {Timesheet timesheet = newTimesheet();timesheetDao.add(timesheet);// update timesheettimesheet.setHours(6);taskDao.update(timesheet.getTask());timesheetDao.update(timesheet);Timesheet found = timesheetDao.find(timesheet.getId());assertTrue(6 == found.getHours());}@Testpublic void testFind() {Timesheet timesheet = newTimesheet();timesheetDao.add(timesheet);assertEquals(timesheet, timesheetDao.find(timesheet.getId()));}@Testpublic void testList() {assertEquals(0, timesheetDao.list().size());Timesheet templateTimesheet = newTimesheet();List<Timesheet> timesheets = Arrays.asList(newTimesheetFromTemplate(templateTimesheet, 4),newTimesheetFromTemplate(templateTimesheet, 7),newTimesheetFromTemplate(templateTimesheet, 10));for (Timesheet timesheet : timesheets) {timesheetDao.add(timesheet);}List<Timesheet> found = timesheetDao.list();assertEquals(3, found.size());for (Timesheet timesheet : found) {assertTrue (timesheets.contains(timesheet));}}@Testpublic void testRemove() {Timesheet timesheet = newTimesheet();timesheetDao.add(timesheet);// successfully addedassertEquals(timesheet, timesheetDao.find(timesheet.getId()));// try to remocetimesheetDao.remove(timesheet);assertNull (timesheetDao.find(timesheet.getId()));}/*** @return  Dummy timesheet for testing*/private Timesheet newTimesheet() {return new Timesheet(employee, task, 5);}private Timesheet newTimesheetFromTemplate(Timesheet template,Integer hours) {return new Timesheet(template.getWho(),template.getTask(),hours);}
}

您可以將測試作為單個類運行，也可以從IDE一起運行，也可以像這樣從Maven作為“測試”目標運行它們（切換到項目目錄）：

$ mvn test

測試非常相似，因此，如果您至少能理解其中之一，則可以將它們復制粘貼到自己的項目中，這可能很好。如果您想花更多的時間，請隨時自己編寫它們，并做一些實驗以使Hibernate更好地了解。

至于DAO，我們已經完成了許多工作。不過，還有一件事–我們的TimesheetService接口。這就是我們感興趣的一組業務操作，因此讓我們使用Hibernate來實現它。我們將TimesheetServiceImpl類放在org.timesheet.service.impl包下：

package org.timesheet.service.impl;import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.timesheet.domain.Employee;
import org.timesheet.domain.Manager;
import org.timesheet.domain.Task;
import org.timesheet.service.TimesheetService;
import org.timesheet.service.dao.TaskDao;import java.util.ArrayList;
import java.util.List;
import java.util.Random;@Transactional(propagation= Propagation.REQUIRED, readOnly=false)
@Service('timesheetService')
public class TimesheetServiceImpl implements TimesheetService {// dependenciesprivate SessionFactory sessionFactory;private TaskDao taskDao;private Random random = new Random();@Autowiredpublic void setSessionFactory(SessionFactory sessionFactory) {this.sessionFactory = sessionFactory;}@Autowiredpublic void setTaskDao(TaskDao taskDao) {this.taskDao = taskDao;}public SessionFactory getSessionFactory() {return sessionFactory;}public TaskDao getTaskDao() {return taskDao;}private Session currentSession() {return sessionFactory.getCurrentSession();}@Overridepublic Task busiestTask() {List<Task> tasks = taskDao.list();if (tasks.isEmpty()) {return null;}Task busiest = tasks.get(0);for (Task task : tasks) {if (task.getAssignedEmployees().size() > busiest.getAssignedEmployees().size()) {busiest = task;}}return busiest;}@Overridepublic List<Task> tasksForEmployee(Employee employee) {List<Task> allTasks = taskDao.list();List<Task> tasksForEmployee = new ArrayList<Task>();for (Task task : allTasks) {if (task.getAssignedEmployees().contains(employee)) {tasksForEmployee.add(task);}}return tasksForEmployee;}@Overridepublic List<Task> tasksForManager(Manager manager) {Query query = currentSession().createQuery('from Task t where t.manager.id = :id');query.setParameter('id', manager.getId());return query.list();}
}

請注意，這次我們使用@Service批注（我們之前已經討論過這些）。此外，我們還將使用setter注入來注入一些DAO。某些業務方法未得到最有效的實現，但我們證明了我們可以混合使用通用DAO邏輯，也可以使用HQL創建自己的查詢。我們本來可以選擇Criteria API，現在已經不重要了。 HQL的最大缺點是它是純字符串，因此它不易于重構-除非您使用適當的工具。例如，即使是純字符串，IntelliJ也具有自動補全功能。它只是表明您正在編寫HQL。 HQL控制臺也非常有用，IntelliJ有一個，還有Eclipse的插件。

HQL的IntelliJ高亮顯示和自動完成功能：

現在我們應該測試這項服務。這次我們不想在Java中創建實體的實例，我們將使用之前創建的外部SQL腳本-設置和清除數據。

讓我們將測試類TimesheetServiceTest放在src / test / java文件夾中的org.timesheet.service包中。在以下代碼中，請注意我們如何使用jdbcTemplate bean：

package org.timesheet.service;import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.FileSystemResource;
import org.springframework.jdbc.core.simple.SimpleJdbcTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
import org.springframework.test.jdbc.SimpleJdbcTestUtils;
import org.timesheet.domain.Employee;
import org.timesheet.domain.Manager;
import org.timesheet.domain.Task;
import org.timesheet.service.dao.EmployeeDao;
import org.timesheet.service.dao.ManagerDao;import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;@ContextConfiguration(locations = '/persistence-beans.xml')
public class TimesheetServiceTest extends AbstractJUnit4SpringContextTests {@Autowiredprivate TimesheetService timesheetService;// resources for accessing data during the testing@Autowiredprivate SimpleJdbcTemplate jdbcTemplate;@Autowiredprivate EmployeeDao employeeDao;@Autowiredprivate ManagerDao managerDao;private final String createScript = 'src/main/resources/sql/create-data.sql';private final String deleteScript = 'src/main/resources/sql/cleanup.sql';@Beforepublic void insertData() {SimpleJdbcTestUtils.executeSqlScript(jdbcTemplate,new FileSystemResource(createScript), false);}@Afterpublic void cleanUp() {SimpleJdbcTestUtils.executeSqlScript(jdbcTemplate,new FileSystemResource(deleteScript), false);}@Testpublic void testBusiestTask() {Task task = timesheetService.busiestTask();assertTrue(1 == task.getId());}@Testpublic void testTasksForEmployees() {Employee steve = employeeDao.find(1L);Employee bill = employeeDao.find(2L);assertEquals(2, timesheetService.tasksForEmployee(steve).size());assertEquals(1, timesheetService.tasksForEmployee(bill).size());}@Testpublic void testTasksForManagers() {Manager eric = managerDao.find(1L);assertEquals(1, timesheetService.tasksForManager(eric).size());}}

好吧，就是這樣。我們已經實現了DAO和服務層。這包括很多代碼，因此在繼續之前，請確保您的項目結構如下所示：