我们要建立一个时间表的应用。先来看实体entities.
经理给员工分派工作。一项工作可以分派给许多员工。
员工把一项工作干了多长时间填报给系统。
经理,员工阅读时间报表。
实体:经理,员工,时间报表,工作任务
服务层
我们创建一个接口,该接口要能够对各种实体完成增删改查的操作。
持久层
我们现在不操心实际的存储,所以,我们把所有的资料(就是域模型数据)存入内存。
现在做一个测试
至此,我们还没有用spring.Spring的最初目的是简化企业级的开发并且鼓励用POJO开发模型。后面大家会看到,用
spring处理本例的模型很容易。
原文:http://www.javacodegeeks.com/2012/09/spring-designing-domain-model-and.html
源代码:http://pan.baidu.com/share/link?shareid=431508&uk=3878681452
经理给员工分派工作。一项工作可以分派给许多员工。
员工把一项工作干了多长时间填报给系统。
经理,员工阅读时间报表。
实体:经理,员工,时间报表,工作任务
数据模型层
package org.timesheet.domain;
public class Employee {
private String name;
private String department;
public Employee(String name, String department) {
this.name = name;
this.department = department;
}
public String getName() {
return name;
}
public String getDepartment() {
return department;
}
@Override
public String toString() {
return "姓名" + name + "部门" + department + "]";
}
}
package org.timesheet.domain;
public class Manager {
private String name;
public Manager(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
package org.timesheet.domain;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Task {
private List<Employee> assignedEmployees = new ArrayList<Employee>();
private Manager manager;
private boolean completed;
private String description;
public Task(String description, Manager manager, Employee... employees) {
this.description = description;
this.manager = manager;
assignedEmployees.addAll(Arrays.asList(employees));
completed = false;
}
public Manager getManager() {
return manager;
}
public List<Employee> getAssignedEmployees() {
return assignedEmployees;
}
public void addEmployee(Employee e) {
assignedEmployees.add(e);
}
public void removeEmployee(Employee e) {
assignedEmployees.remove(e);
}
public void completeTask() {
completed = true;
}
}
package org.timesheet.domain;
public class Timesheet {
private Employee who;
private Task task;
private Integer hours;
public Timesheet(Employee who, Task task, Integer hours) {
this.who = who;
this.task = task;
this.hours = hours;
}
public Employee getWho() {
return who;
}
public Task getTask() {
return task;
}
public Integer getHours() {
return hours;
}
/**
* Manager can alter hours before closing task
*
* @param hours
* New amount of hours
*/
public void alterHours(Integer hours) {
this.hours = hours;
}
@Override
public String toString() {
return "Timesheet [who=" + who + ", task=" + task + ", hours=" + hours
+ "]";
}
}
服务层
我们创建一个接口,该接口要能够对各种实体完成增删改查的操作。
package org.timesheet.service;
import java.util.List;
public interface GenericDao<E, K> {
void add(E entity);
void update(E entity);
void remove(E entity);
E find(K key);
List<E> list();
}
持久层
我们现在不操心实际的存储,所以,我们把所有的资料(就是域模型数据)存入内存。
package org.timesheet.service.impl;
import java.util.ArrayList;
import java.util.List;
import org.timesheet.service.GenericDao;
public class InMemoryDao<E, K> implements GenericDao<E, K> {
private List<E> entities = new ArrayList<E>();
@Override
public void add(E entity) {
entities.add(entity);
}
@Override
public void update(E entity) {
throw new UnsupportedOperationException(
"Not supported in dummy in-memory impl!");
}
@Override
public void remove(E entity) {
entities.remove(entity);
}
@Override
public E find(K key) {
if (entities.isEmpty()) {
return null;
}
// just return the first one sice we are not using any keys ATM
return entities.get(0);
}
@Override
public List<E> list() {
return entities;
}
}
现在做一个测试
package org.timesheet.service;
import static org.junit.Assert.*;
import java.util.List;
import java.util.Iterator;
import org.junit.Before;
import org.junit.Test;
import org.timesheet.domain.Employee;
import org.timesheet.service.impl.InMemoryDao;
public class EmployeeDaoTest {
private GenericDao<Employee, Long> employeeDao = new InMemoryDao<Employee, Long>();
@Before
public void setUp() {
for (int i = 0; i < 5; i++) {
Employee e = new Employee("Mike " + i, "IT");
employeeDao.add(e);
}
}
@Test
public void testAdd() {
int oldSize = employeeDao.list().size();
Employee e = new Employee("Bob", "IT");
employeeDao.add(e);
int newSize = employeeDao.list().size();
assertFalse (oldSize == newSize);
}
@Test
public void testRemove() {
int oldSize = employeeDao.list().size();
Employee e = employeeDao.find(1L);
employeeDao.remove(e);
int newSize = employeeDao.list().size();
assertFalse(oldSize == newSize);
}
@Test
public void testUpdate() {
// TODO: need real implementation
}
@Test
public void testList() {
List<Employee> list = employeeDao.list();
assertNotNull(list);
assertFalse(list.isEmpty());
System.out.println(list);
for(Iterator i = list.iterator(); i.hasNext();)
System.out.println(i.next());
}
}
至此,我们还没有用spring.Spring的最初目的是简化企业级的开发并且鼓励用POJO开发模型。后面大家会看到,用
spring处理本例的模型很容易。
原文:http://www.javacodegeeks.com/2012/09/spring-designing-domain-model-and.html
源代码:http://pan.baidu.com/share/link?shareid=431508&uk=3878681452