敏捷软件开发_实例1<二>
这本书的实例非常好，给了我非常多的启发。主要讲了两个实例，咖啡机和薪水支付实例，咖啡机实例比较简单并没有用什么设计模式，薪水支付实例用了很多设计模式，包括后面的打包等。
咖啡机实例
做一个使用咖啡机的软件，驱动接口已经被写好。
咖啡机的硬件包括：
- 加热器加热棒（开关）
- 保温盘加热棒（开关）
- 保温盘传感器（保温盘空，杯子空，杯子不空）
- 加热器传感器（有水，没水）
- 冲煮按钮（开关）
- 指示灯（开关）
- 减压阀门（开关）
咖啡机的冲煮流程：
- 咖啡机一次煮12杯咖啡，
- 咖啡加入过滤器，过滤器加入支架，支架放到咖啡机。
- 倒入12杯水到滤水器，按下冲煮，水杯加热至沸腾，水蒸气碰洒到过滤器，形成水滴到咖啡壶，咖啡壶发现有水保温，
- 拿走水杯，停止工作。
方案一
建立一个咖啡机超类，关联各个硬件类。这个方案是非常丑陋的，这不是根据行为划分的，有些类，比如light没有任何变量，仅仅调用了驱动接口，这种类叫水蒸气类。没有意义
方案二
按照行为来划分，要确定一些类有没有意义，只需要确定谁使用他们，而且要到业务底层去看。把问题的本质和细节分离，忘掉一切，最根本的问题是如何煮咖啡。如何煮咖啡，将热水倒到咖啡上，把冲泡好的咖啡收集起来。水从哪来？咖啡放到哪里？那么就有两个类：热水类和支架类，大大多数人会考虑热水流到支架中，这是比较错误的，软件的行为应该按照软件的行为给出而不是基于一些物理关系。还需要考虑用户界面，这样就有三个类。
- 谁使用
- 最根本的问题
- 软件行为而不是物理行为
用例
- 按下冲煮，启动水流，支架做好准备，都准备好就开始煮咖啡
- 接受器具准备好没有
- 冲煮完成
- 咖啡喝完
a，b，c，d表示四种逻辑：
- a 表示：用户按下冲煮，确保支架中有咖啡壶放在保温杯上，热水器中已经加满了水，然后才开始煮咖啡
- b 表示：如果正在股咖啡的过程中咖啡壶被拿走，则必须中断咖啡流，停止送热水，再次放回咖啡壶继续煮咖啡
- c 表示：热水器中传感器告诉我们水用完了就停止煮咖啡，同时告诉用户和支架（保温盘）已经停止煮咖啡
- d 表示：冲煮结束时并且一个空的咖啡壶放在支架上（保温盘），热水器应该知道这个消息，同时用户也应该知道这个消息
这样整个咖啡机的抽象就完成了，按职责划分，各司其职。这三个抽象类不能知道任何关于咖啡机的任何信息。这就是依赖倒置原则。
系统的控制流如何检测传感器呢？是选择线程还是轮询。最好的总是假设消息都是可以异步发送的，就像存在有独立的线程一样，把使用轮询还是线程的决策推迟到最后一刻。
这样设置了一个接口，main()程序就待在一个循环中，不停地一遍遍调用这个方法实现轮询。
public static void Main(string[] args)
{
CoffeeMakerAPI api = new M4CoffeeMakerAPI();
M4UserInterface ui = new M4UserInterface(api);
M4HotWaterSOurce hws = new M4HotWaterSOurce(api);
M4ContainmentVessel cv = new M4ContainmentVessel(api);
ui.Init(hws,cv);
hws.Init(ui,cv);
cv.Init(hws,ui);
while(true)
{
ui.Poll();
hws.Poll();
cv.Poll();
}
}
依赖倒置，不允许高层的咖啡制作中依赖底层实现。
薪水支付实例
该案例主要有做一个薪水支付系统，主要有三类员工
- 临时工：基本时薪，超过8小时加班时间1.5倍工资，每天有考勤卡，每周5结算。
- 正式员工：月薪，每个月最后一天结算。
- 经理：月薪，每月最后一天结算，有项目提成，每隔一周的周五结算，加入公会扣会费。
- 公会会费分服务费和会费：会费每周都有从薪水中扣除，服务费从下个月薪水中扣除。
- 薪水支付方式：可以选择支票邮寄到家，支票保存自取，直接存入银行账号。
- 薪水支付每天运行一次，在当天为相应的雇员进行支付，上一次支付到本次支付应付的数额。
用例：
- 新增雇员：雇员号，姓名，地址。（零时工，正式员工，经理）
- 删除雇员：雇员号
- 登记考勤卡：雇员号，日期，小时
- 登记销售凭条：雇员号，日期，销售记录
- 登记公会服务费：公会成员，服务费用
- 更改雇员细则：更改姓名，更改地址，更改每小时报酬，更改薪水，更改提成，更改支付方式，加入公会，离开公会
设计类和结构：
通过迭代的方式进行实现。数据库是实现细节，应该尽推迟数据库的设计。通过用例来推导出应该有哪些类。
从用例的角度设计
- 新增雇员
把每一项工作划分为自己的类中。这样有可能会创建三个雇员类，但是分析一下就会发现变化的东西太多了，正式由于雇员变化的东西引发雇员类型的改变，只需要将变化的东西抽象出来，在更改雇员细则时改变这些变化的东西就可以改变雇员类型。
- 登记考勤卡
考勤卡和雇员应该是聚合的关系
- 登记销售凭条
销售凭条和雇员也应该是聚合的关系
- 登机工会服务费
工会服务费维护着工会会员的编号，因此系统必须要把工会成员和雇员标识联系起俩，推迟这一行为。公会成员和服务费也是聚合的关系
- 更改雇员细则
这是由多个更改策略组合而成。
最后各个类之间的关系
从程序运行的角度补充细节
- 运行薪水支付系统：找到所有进行支付的雇员，确定扣款额，根据他们的支付方式支付。
- 抽象出变化的东西：雇员的支付类别抽象，支付时间抽象
- 工会服务费抽象
实现
- 事务
事务是使用命令模式。
- 增加雇员事务，雇员有三个类型，所以使用模板模式来实现增加雇员，此处模板模式的唯一任务就是创建对象
public abstract class AddEmployeeTransaction : Transaction
{
private readonly int empid;
private readonly string name;
private readonly string address;
public AddEmployeeTransaction(int empid,
string name, string address, PayrollDatabase database)
: base (database)
{
this.empid = empid;
this.name = name;
this.address = address;
}
protected abstract
PaymentClassification MakeClassification();
protected abstract
PaymentSchedule MakeSchedule();
public override void Execute()
{
PaymentClassification pc = MakeClassification();
PaymentSchedule ps = MakeSchedule();
PaymentMethod pm = new HoldMethod();
Employee e = new Employee(empid, name, address);
e.Classification = pc;
e.Schedule = ps;
e.Method = pm;
database.AddEmployee(e);
}
public override string ToString()
{
return String.Format("{0} id:{1} name:{2} address:{3}", GetType().Name, empid, name,address);
}
}
public class AddSalariedEmployee : AddEmployeeTransaction
{
private readonly double salary;
public AddSalariedEmployee(int id, string name, string address, double salary, PayrollDatabase database)
: base(id, name, address, database)
{
this.salary = salary;
}
protected override
PaymentClassification MakeClassification()
{
return new SalariedClassification(salary);
}
protected override PaymentSchedule MakeSchedule()
{
return new MonthlySchedule();
}
}
- 删除雇员
提供雇员id，去数据库删除雇员，没啥好说的。
- 考勤卡、销售凭条、服务费
考勤卡：需要参数，雇员id,日期，工作时间
public class TimeCard
{
private readonly DateTime date;
private readonly double hours;
public TimeCard(DateTime date, double hours)
{
this.date = date;
this.hours = hours;
}
public double Hours
{
get { return hours; }
}
public DateTime Date
{
get { return date; }
}
}
public class TimeCardTransaction : Transaction
{
private readonly DateTime date;
private readonly double hours;
private readonly int empId;
public TimeCardTransaction(DateTime date, double hours, int empId, PayrollDatabase database)
: base(database)
{
this.date = date;
this.hours = hours;
this.empId = empId;
}
public override void Execute()
{
Employee e = database.GetEmployee(empId);
if (e != null)
{
HourlyClassification hc =
e.Classification as HourlyClassification;
if (hc != null)
hc.AddTimeCard(new TimeCard(date, hours));
else
throw new ApplicationException(
"Tried to add timecard to" +
"non-hourly employee");
}
else
throw new ApplicationException(
"No such employee.");
}
}
其他两种与这类似
- 更改雇员属性
更改雇员属性由多个事务集合而成
改名字事务：
public abstract class ChangeEmployeeTransaction : Transaction
{
private readonly int empId;
public ChangeEmployeeTransaction(int empId, PayrollDatabase database)
: base (database)
{
this.empId = empId;
}
public override void Execute()
{
Employee e = database.GetEmployee(empId);
if(e != null)
Change(e);
else
throw new ApplicationException(
"No such employee.");
}
protected abstract void Change(Employee e);
}
public class ChangeNameTransaction
: ChangeEmployeeTransaction
{
private readonly string newName;
public ChangeNameTransaction(int id, string newName, PayrollDatabase database)
: base(id, database)
{
this.newName = newName;
}
protected override void Change(Employee e)
{
e.Name = newName;
}
}
更改雇员类别
public abstract class ChangeClassificationTransaction
: ChangeEmployeeTransaction
{
public ChangeClassificationTransaction(int id, PayrollDatabase database)
: base (id, database)
{}
protected override void Change(Employee e)
{
e.Classification = Classification;
e.Schedule = Schedule;
}
protected abstract
PaymentClassification Classification { get; }
protected abstract PaymentSchedule Schedule { get; }
}
public class ChangeHourlyTransaction
: ChangeClassificationTransaction
{
private readonly double hourlyRate;
public ChangeHourlyTransaction(int id, double hourlyRate, PayrollDatabase database)
: base(id, database)
{
this.hourlyRate = hourlyRate;
}
protected override PaymentClassification Classification
{
get { return new HourlyClassification(hourlyRate); }
}
protected override PaymentSchedule Schedule
{
get { return new WeeklySchedule(); }
}
}
public class ChangeSalariedTransaction : ChangeClassificationTransaction
{
private readonly double salary;
public ChangeSalariedTransaction(int id, double salary, PayrollDatabase database)
: base(id, database)
{
this.salary = salary;
}
protected override PaymentClassification Classification
{
get { return new SalariedClassification(salary); }
}
protected override PaymentSchedule Schedule
{
get { return new MonthlySchedule(); }
}
}
public class ChangeCommissionedTransaction
: ChangeClassificationTransaction
{
private readonly double baseSalary;
private readonly double commissionRate;
public ChangeCommissionedTransaction(int id, double baseSalary, double commissionRate, PayrollDatabase database)
: base(id, database)
{
this.baseSalary = baseSalary;
this.commissionRate = commissionRate;
}
protected override PaymentClassification Classification
{
get { return new CommissionClassification(baseSalary, commissionRate); }
}
protected override PaymentSchedule Schedule
{
get { return new BiWeeklySchedule(); }
}
}
改变方法和改变工会实现方式基本与改变雇佣类别相似
改变支付方法：
public abstract class ChangeMethodTransaction : ChangeEmployeeTransaction
{
public ChangeMethodTransaction(int empId, PayrollDatabase database)
: base(empId, database)
{}
protected override void Change(Employee e)
{
PaymentMethod method = Method;
e.Method = method;
}
protected abstract PaymentMethod Method { get; }
}
public class ChangeMailTransaction : ChangeMethodTransaction
{
public ChangeMailTransaction(int empId, PayrollDatabase database)
: base(empId, database)
{
}
protected override PaymentMethod Method
{
get { return new MailMethod("3.14 Pi St"); }
}
}
public class ChangeHoldTransaction : ChangeMethodTransaction
{
public ChangeHoldTransaction(int empId, PayrollDatabase database)
: base(empId, database)
{
}
protected override PaymentMethod Method
{
get { return new HoldMethod(); }
}
}
public class ChangeDirectTransaction : ChangeMethodTransaction
{
public ChangeDirectTransaction(int empId, PayrollDatabase database)
: base(empId, database)
{
}
protected override PaymentMethod Method
{
get { return new DirectDepositMethod("Bank -1", "123"); }
}
}
改变工会：
public abstract class ChangeAffiliationTransaction : ChangeEmployeeTransaction
{
public ChangeAffiliationTransaction(int empId, PayrollDatabase database)
: base(empId, database)
{}
protected override void Change(Employee e)
{
RecordMembership(e);
Affiliation affiliation = Affiliation;
e.Affiliation = affiliation;
}
protected abstract Affiliation Affiliation { get; }
protected abstract void RecordMembership(Employee e);
}
public class ChangeUnaffiliatedTransaction : ChangeAffiliationTransaction
{
public ChangeUnaffiliatedTransaction(int empId, PayrollDatabase database)
: base(empId, database)
{}
protected override Affiliation Affiliation
{
get { return new NoAffiliation(); }
}
protected override void RecordMembership(Employee e)
{
Affiliation affiliation = e.Affiliation;
if(affiliation is UnionAffiliation)
{
UnionAffiliation unionAffiliation =
affiliation as UnionAffiliation;
int memberId = unionAffiliation.MemberId;
database.RemoveUnionMember(memberId);
}
}
}
public class ChangeMemberTransaction : ChangeAffiliationTransaction
{
private readonly int memberId;
private readonly double dues;
public ChangeMemberTransaction(int empId, int memberId, double dues, PayrollDatabase database)
: base(empId, database)
{
this.memberId = memberId;
this.dues = dues;
}
protected override Affiliation Affiliation
{
get { return new UnionAffiliation(memberId, dues); }
}
protected override void RecordMembership(Employee e)
{
database.AddUnionMember(memberId, e);
}
}
- 支付薪水
支付月薪：
public class PaydayTransaction : Transaction
{
private readonly DateTime payDate;
private Hashtable paychecks = new Hashtable();
public PaydayTransaction(DateTime payDate, PayrollDatabase database)
: base (database)
{
this.payDate = payDate;
}
public override void Execute()
{
ArrayList empIds = database.GetAllEmployeeIds();
foreach(int empId in empIds)
{
Employee employee = database.GetEmployee(empId);
if (employee.IsPayDate(payDate))
{
DateTime startDate =
employee.GetPayPeriodStartDate(payDate);
Paycheck pc = new Paycheck(startDate, payDate);
paychecks[empId] = pc;
employee.Payday(pc);
}
}
}
public Paycheck GetPaycheck(int empId)
{
return paychecks[empId] as Paycheck;
}
}
public class MonthlySchedule : PaymentSchedule
{
private bool IsLastDayOfMonth(DateTime date)
{
int m1 = date.Month;
int m2 = date.AddDays(1).Month;
return (m1 != m2);
}
public bool IsPayDate(DateTime payDate)
{
return IsLastDayOfMonth(payDate);
}
public DateTime GetPayPeriodStartDate(DateTime date)
{
int days = 0;
while(date.AddDays(days - 1).Month == date.Month)
days--;
return date.AddDays(days);
}
public override string ToString()
{
return "monthly";
}
}
其中有paycheck类。该类有日期，总薪酬，服务扣费，实际薪酬
-
临时工
public class HourlyClassification : PaymentClassification { private double hourlyRate; private Hashtable timeCards = new Hashtable(); public HourlyClassification(double rate) { this.hourlyRate = rate; } public double HourlyRate { get { return hourlyRate; } } public TimeCard GetTimeCard(DateTime date) { return timeCards[date] as TimeCard; } public void AddTimeCard(TimeCard card) { timeCards[card.Date] = card; } public override double CalculatePay(Paycheck paycheck) { double totalPay = 0.0; foreach(TimeCard timeCard in timeCards.Values) { if(DateUtil.IsInPayPeriod(timeCard.Date, paycheck.PayPeriodStartDate, paycheck.PayPeriodEndDate)) totalPay += CalculatePayForTimeCard(timeCard); } return totalPay; } private double CalculatePayForTimeCard(TimeCard card) { double overtimeHours = Math.Max(0.0, card.Hours - 8); double normalHours = card.Hours - overtimeHours; return hourlyRate * normalHours + hourlyRate * 1.5 * overtimeHours; } public override string ToString() { return String.Format("${0}/hr", hourlyRate); } } public class WeeklySchedule : PaymentSchedule { public bool IsPayDate(DateTime payDate) { return payDate.DayOfWeek == DayOfWeek.Friday; } public DateTime GetPayPeriodStartDate(DateTime date) { return date.AddDays(-6); } public override string ToString() { return "weekly"; } } public class Employee { private readonly int empid; private string name; private readonly string address; private PaymentClassification classification; private PaymentSchedule schedule; private PaymentMethod method; private Affiliation affiliation = new NoAffiliation(); public Employee(int empid, string name, string address) { this.empid = empid; this.name = name; this.address = address; } public string Name { get { return name; } set { name = value; } } public string Address { get { return address; } } public PaymentClassification Classification { get { return classification; } set { classification = value; } } public PaymentSchedule Schedule { get { return schedule; } set { schedule = value; } } public PaymentMethod Method { get { return method; } set { method = value; } } public Affiliation Affiliation { get { return affiliation; } set { affiliation = value; } } public bool IsPayDate(DateTime date) { return schedule.IsPayDate(date); } public void Payday(Paycheck paycheck) { //计算总的薪资 double grossPay = classification.CalculatePay(paycheck); //计算扣除薪资 double deductions = affiliation.CalculateDeductions(paycheck); //计算实际薪资 double netPay = grossPay - deductions; paycheck.GrossPay = grossPay; paycheck.Deductions = deductions; paycheck.NetPay = netPay; //通过支付方式支付 method.Pay(paycheck); } public DateTime GetPayPeriodStartDate(DateTime date) { return schedule.GetPayPeriodStartDate(date); } public int EmpId { get { return empid; } } public override string ToString() { StringBuilder builder = new StringBuilder(); builder.Append("Emp#: ").Append(empid).Append(" "); builder.Append(name).Append(" "); builder.Append(address).Append(" "); builder.Append("Paid ").Append(classification).Append(" "); builder.Append(schedule); builder.Append(" by ").Append(method); return builder.ToString(); } } public class UnionAffiliation : Affiliation { private Hashtable charges = new Hashtable(); private int memberId; private readonly double dues; public UnionAffiliation(int memberId, double dues) { this.memberId = memberId; this.dues = dues; } public UnionAffiliation() : this(-1, 0.0) {} public ServiceCharge GetServiceCharge(DateTime time) { return charges[time] as ServiceCharge; } public void AddServiceCharge(ServiceCharge sc) { charges[sc.Time] = sc; } public double Dues { get { return dues; } } public int MemberId { get { return memberId; } } public double CalculateDeductions(Paycheck paycheck) { double totalDues = 0; int fridays = NumberOfFridaysInPayPeriod( paycheck.PayPeriodStartDate, paycheck.PayPeriodEndDate); totalDues = dues * fridays; foreach(ServiceCharge charge in charges.Values) { if(DateUtil.IsInPayPeriod(charge.Time, paycheck.PayPeriodStartDate, paycheck.PayPeriodEndDate)) totalDues += charge.Amount; } return totalDues; } private int NumberOfFridaysInPayPeriod( DateTime payPeriodStart, DateTime payPeriodEnd) { int fridays = 0; for (DateTime day = payPeriodStart; day <= payPeriodEnd; day = day.AddDays(1)) { if (day.DayOfWeek == DayOfWeek.Friday) fridays++; } return fridays; } } -
主程序
总结
到目前为止基本功能已经实现，仅仅只是用了模板，空值，命令等设计模式，下一篇将会进一步使用更多的设计模式进行打包处理。