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和服務層。 這包括很多代碼，因此在繼續之前，請確保您的項目結構如下所示：

參考： 第3部分–我們的JCG合作伙伴 Michal Vrtiak在vrtoonjava博客上提供的DAO和服務層 。

翻譯自: https://www.javacodegeeks.com/2012/09/spring-dao-and-service-layer.html

spring dao層注解

總結

以上是生活随笔為你收集整理的spring dao层注解_Spring– DAO和服务层的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。