敏捷软件开发_实例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;
  	}
  }

主程序

总结

到目前为止基本功能已经实现，仅仅只是用了模板，空值，命令等设计模式，下一篇将会进一步使用更多的设计模式进行打包处理。

posted @ 2018-09-29 11:44 阿杜888 阅读(826) 评论(0) 编辑收藏举报

刷新页面返回顶部

_想飞的鱼

记录所见，所思，所感。

敏捷软件开发_实例1<二>

敏捷软件开发_实例1<二>

咖啡机实例

方案一

方案二

用例

薪水支付实例

用例：

设计类和结构：

从用例的角度设计

从程序运行的角度补充细节

实现

总结