服装网站建设规划,网站开发涉及内容,正能量成年入口,网络公司的名字spring dao层注解欢迎来到Spring教程的第三部分。 在这一部分中#xff0c;我们将继续编写Timesheet应用程序#xff0c;这次我们将实现DAO层#xff0c;业务服务并编写一些测试。 在上一部分中#xff0c;我们定义了GenericDao接口#xff0c;该接口告诉我们需要对实体执… 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 Hibernates specific classes* see SessionFactory*/
Transactional(propagation Propagation.REQUIRED, readOnlyfalse)
public class HibernateDaoE, K extends Serializable implements GenericDaoE, K {private SessionFactory sessionFactory;protected Class? extends E daoType;public HibernateDao() {daoType (ClassE) ((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 ListE list() {return currentSession().createCriteria(daoType).list();}
} 我希望您注意有关此代码的几件事 我们在类的顶部使用Transcational批注。 这基本上意味着DAO方法将在事务内运行。 为了使其正常工作我们需要更改persistence-beans.xml文件并在其中声明将处理事务的事务管理器。 只需添加以下行新bean定义 bean idtransactionManagerclassorg.springframework.orm.hibernate3.HibernateTransactionManagerproperty namesessionFactory refsessionFactory //bean 我们正在使用setter注入自动装配AutowiredSessionFactory。 如您所知注入的种类更多字段setter构造函数。 使用Spring时字段注入看起来最好因为注释直接位于字段上而不是构造函数或setter方法上。 另一方面字段注入是最无用的因为我们不能手动将其他依赖项设置为私有字段例如在单元测试中。 我尽可能地喜欢构造函数注入因为我不必为依赖项使用mutatorsetter。 因此以更安全的方式构造对象。 在此特定情况下我们将使用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 GenericDaoEmployee, 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 GenericDaoManager, 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 GenericDaoTask, 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 GenericDaoTimesheet, 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 HibernateDaoEmployee, 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 mustnt 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 mustnt 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 HibernateDaoManager, 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 mustnt 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 HibernateDaoTask, 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 mustnt be assigned to no timesheetif (!taskQuery.list().isEmpty()) {return false;}// ok, remove as usualremove(task);return true;}Overridepublic ListTask 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 HibernateDaoTimesheet, Long implements TimesheetDao {Overridepublic ListTimesheet 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 idjdbcTemplateclassorg.springframework.jdbc.core.simple.SimpleJdbcTemplateconstructor-arg typejavax.sql.DataSource refdataSource//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());ListEmployee 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);}ListEmployee 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 - shouldnt 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());ListManager managers Arrays.asList(new Manager(test-1),new Manager(test-2),new Manager(test-3));for (Manager manager : managers) {managerDao.add(manager);}ListManager 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 - shouldnt 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();ListTask tasks Arrays.asList(newTaskFromTemplate(templateTask, 1),newTaskFromTemplate(templateTask, 2),newTaskFromTemplate(templateTask, 3));for (Task task : tasks) {taskDao.add(task);}ListTask 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);ListEmployee 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 timesheetDaoAutowiredprivate 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();ListTimesheet timesheets Arrays.asList(newTimesheetFromTemplate(templateTimesheet, 4),newTimesheetFromTemplate(templateTimesheet, 7),newTimesheetFromTemplate(templateTimesheet, 10));for (Timesheet timesheet : timesheets) {timesheetDao.add(timesheet);}ListTimesheet 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, readOnlyfalse)
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() {ListTask 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 ListTask tasksForEmployee(Employee employee) {ListTask allTasks taskDao.list();ListTask tasksForEmployee new ArrayListTask();for (Task task : allTasks) {if (task.getAssignedEmployees().contains(employee)) {tasksForEmployee.add(task);}}return tasksForEmployee;}Overridepublic ListTask 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 testingAutowiredprivate 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.htmlspring dao层注解
