欢迎来到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和服务层。 这包括很多代码，因此在继续之前，请确保您的项目结构如下所示：

参考： 第3部分–我们的JCG合作伙伴 Michal Vrtiak在vrtoonjava博客上提供的DAO和服务层 。