敏捷软件开发-薪水支付案例学习

员工薪水支付系统介绍

很早以前学习了敏捷软件开发：原则、模式与实践中的薪水支付案例，有些代码设计思想觉得特别好的，特来分享下。
本系统实现了一个计算员工薪水，并发放薪水的功能，该系统必须为不同类型的员工支付正确的薪水，员工类型和结构如下：

有些员工是钟点工。会按照他们工作记录中每小时报酬字段的值对他们进行支付。他们每天会提交工作时间卡，其中记录了日期以及工作小时数。如果每天工作超过8小时，那么超过的部分会按照正常报酬的1.5倍进行支付。每周五对他们进行支付。
有些员工完全以月薪进行支付。每个月的最后一个工作日对他们进行支付。在他们的雇员记录中有一个月薪字段。
还有些销售员工，除了基本工资外，会根据他们的销售情况，支付他们一定数量的酬金。他们会提交销售凭条，其中记录了销售日期和数量。在他们的工作记录中有一个酬金字段，每隔一周的周五对他们进行支付。
员工还可以自由选择发放薪水方式，可以选择银行卡发放、把支票保存在出纳人员那里随时支取或者通过邮寄方式发放。
一些员工还会加入协会。每周需要扣除相应会费，协会有时也会针对单个协会成员征收服务费用。
刚学Java的时候，学习视频里的讲师有提到写代码时要一个类一个方法只做一件事，遇到会变化的内容时要知道抽象出来，我觉得在这个系统里得到了充分的体现。
有3种类型的员工，一般我们可以这么设计：

设计一个父类员工类，然后分别设计小时工、固定薪资员工、销售员工去继承父类员工类，但是这里有个问题，假如哪天有个需求说要把固定薪资员工转为小时工，或者把小时工转为销售员工时，我们该怎么办，很明显子类间是不能转化的。
解决方法是进行抽象，一些员工按小时支付，一些员工按固定薪资支付，一些员工按销售业绩支付。每种类型的员工都需要被支付，只是支付的策略不同，所以我们可以把支付的策略抽象出来。这就有了支付策略接口：

public interface PaymentClassification {//抽象出支付策略类double calculatePay(Paycheck payCheck);
}

员工类不用理会员工的支付形式，把支付形式交由支付策略接口去解决，由此的到三个实现类：
按工作小时支付：

/** 小时工即按小时支付，把按小时支付计算单独拿出来实现*/
public class HourlyClassification implements PaymentClassification {private double hourlyRate;//每小时工钱private List<TimeCard> timeCards=new ArrayList<TimeCard>();//记录员工的工作时间卡public HourlyClassification(double hourlyRate) {this.hourlyRate = hourlyRate;}public double calculatePay(Paycheck payCheck) {// TODO Auto-generated method stubdouble totalPay=0;for(TimeCard card:timeCards) {if(DateUtil.between(card.getDate(), payCheck.getPayPeriodStart(), payCheck.getPayPeriodend()))totalPay+=calculatePayForTimeCard(card);}return totalPay;}public void addTimeCard(TimeCard timeCard) {this.timeCards.add(timeCard);}public double calculatePayForTimeCard(TimeCard timeCard) {double hours=timeCard.getHours();if(hours>8) {return (8*hourlyRate+(hours-8)*hourlyRate*1.5);}else {return hours*hourlyRate;}}@Overridepublic String toString() {return "HourlyClassification [hourlyRate=" + hourlyRate + ", timeCards=" + timeCards + "]";}}

按固定薪资支付：

/** 固定薪资支付*/
public class SalariedClassification implements PaymentClassification {private double salary;public SalariedClassification(double salary) {this.salary=salary;} public double calculatePay(Paycheck payCheck) {// TODO Auto-generated method stubreturn salary;}@Overridepublic String toString() {return "SalariedClassification [salary=" + salary + "]";}}

按销售情况支付：

/** 销售员工薪资计算*/
public class CommissionedClassification implements PaymentClassification {private double rate;//每笔销售单提成private double salary;//底薪private List<SalesReceipt> salesReceipt=new ArrayList<SalesReceipt>();public CommissionedClassification(double rate, double salary) {super();this.rate = rate;this.salary = salary;}public void addSalesReceipt(SalesReceipt sr) {this.salesReceipt.add(sr);}public double calculatePay(Paycheck payCheck) {// TODO Auto-generated method stubdouble commission=0;for(SalesReceipt sr:salesReceipt) {if(DateUtil.between(sr.getDate(), payCheck.getPayPeriodStart(), payCheck.getPayPeriodend()))commission+=sr.getAmount()*rate;}return commission+salary;}@Overridepublic String toString() {return "CommissionedClassification [rate=" + rate + ", salary=" + salary + ", salesReceipt=" + salesReceipt+ "]";}}

支付策略已经抽象了，还有发放薪水的方式，继续抽象，把发放薪水的方式交由以下接口处理：

/** 抽象支付薪资方式*/
public interface PaymentMethod {void pay(Paycheck payCheck);
}

银行卡支付方式：

/** 银行卡支付方式实现类*/
public class BankMethod implements PaymentMethod {private String bank;//银行卡private double account;//应支付的工资public BankMethod(String bank, double account) {super();this.bank = bank;this.account = account;}public void pay(Paycheck payCheck) {// TODO Auto-generated method stubSystem.out.println("向银行卡"+bank+"支付"+payCheck.getNetPay()+"元钱");}@Overridepublic String toString() {return "BankMethod [bank=" + bank + ", account=" + account + "]";}}

到财务/出纳自取方式：

public class HoldMethod implements PaymentMethod {public void pay(Paycheck payCheck) {// TODO Auto-generated method stubSystem.out.println("到财务自取");}@Overridepublic String toString() {return "HoldMethod [到财务自取]";}}

邮寄方式：

/** 邮寄支付工资方式实现类*/
public class MailMethod implements PaymentMethod {private String address;public MailMethod(String address) {super();this.address = address;}public void pay(Paycheck payCheck) {// TODO Auto-generated method stubSystem.out.println("给"+address+"邮寄工资");}@Overridepublic String toString() {return "MailMethod [address=" + address + "]";}}

当我们继续理解需求，我们会发现小时工的薪水发放是每周五进行，固定薪资员工的薪水发放是每月月底，销售员工则是隔一周的周五，薪水的发放时间不一致，就需要对每种类型员工的发放时间进行单独计算，抽象出支付时间：

/** 抽象出支付时间*/
public interface PaymentSchedule {boolean isPayDate(LocalDate date);LocalDate getPayPeriodStartDate(LocalDate date);
}

该接口需实现两个方法，判断当前日子是否为支付日，返回上一次的支付日期。
每周周五进行支付：

/** 按每周周五进行支付实现类*/
public class WeeklySchedule implements PaymentSchedule {public boolean isPayDate(LocalDate date) {// TODO Auto-generated method stubreturn DateUtil.isFriday(date);}public LocalDate getPayPeriodStartDate(LocalDate date) {// TODO Auto-generated method stubreturn DateUtil.add(date, -6);}@Overridepublic String toString() {return "WeeklySchedule [每周五支付]";}}

月底支付：

/** 按月进行支付*/
public class MothlySchedule implements PaymentSchedule {public boolean isPayDate(LocalDate date) {// TODO Auto-generated method stubreturn DateUtil.isLastDayOfMonth(date);}public LocalDate getPayPeriodStartDate(LocalDate date) {// TODO Auto-generated method stubreturn DateUtil.getFirstDay(date);}@Overridepublic String toString() {return "MothlySchedule [月底支付]";}}

隔周周五支付：

/** 隔周周五进行支付*/
public class BiweeklySchedule implements PaymentSchedule {LocalDate firstPayableFriday = LocalDate.of(2019, 1, 4);public boolean isPayDate(LocalDate date) {// TODO Auto-generated method stubreturn DateUtil.isAfterFirday(date);}public LocalDate getPayPeriodStartDate(LocalDate date) {// TODO Auto-generated method stubreturn DateUtil.add(date, -13);}@Overridepublic String toString() {return "BiweeklySchedule [隔周周五支付]";}}

最后还有员工的会费计算，需要在计算薪资时扣除：

/** 抽象会费计算，协会对象*/
public interface Affiliation {double calculateDecutions(Paycheck paycheck);
}

这里实现了一个协会：

/** 具体协会实现类,负责计算应扣除项*/
public class UnionAffiliation implements Affiliation {private String memberId;private double weeklyBue;//每周固定应付款字段private List<ServiceChange> serviceChanges=new ArrayList<ServiceChange>();//不定时收的服务费public UnionAffiliation(String memberId, double weeklyBue) {super();this.memberId = memberId;this.weeklyBue = weeklyBue;}public String getMemberId() {return memberId;}public void setMemberId(String memberId) {this.memberId = memberId;}public double getWeeklyBue() {return weeklyBue;}public void setWeeklyBue(double weeklyBue) {this.weeklyBue = weeklyBue;}public void addServiceChanges(ServiceChange sc) {this.serviceChanges.add(sc);}public double calculateDecutions(Paycheck paycheck) {// TODO Auto-generated method stubint fridays=NumberOfFridaysInPayPeriod(paycheck.getPayPeriodStart(),paycheck.getPayPeriodend());double totalDue=fridays*weeklyBue;double totalChange=0;for(ServiceChange sc:serviceChanges) {if(DateUtil.between(sc.getDate(), paycheck.getPayPeriodStart(), paycheck.getPayPeriodend()))totalChange+=sc.getAmount();}return totalDue+totalChange;}private int NumberOfFridaysInPayPeriod(LocalDate start,LocalDate end) {ZonedDateTime zonedDatestart = start.atStartOfDay(ZoneId.systemDefault());ZonedDateTime zonedDateend = end.atStartOfDay(ZoneId.systemDefault());Date payPeriodStart=Date.from(zonedDatestart.toInstant());Date payPeriodEnd=Date.from(zonedDateend.toInstant());Calendar dayCa = Calendar.getInstance();dayCa.setTime(payPeriodStart);Calendar payPeriodEndCa = Calendar.getInstance();dayCa.setTime(payPeriodEnd);int fridays = 0;while (dayCa.before(payPeriodEndCa)) {if (dayCa.get(Calendar.DAY_OF_WEEK) == Calendar.FRIDAY) {fridays++;}dayCa.add(Calendar.DATE, 1);}return fridays;}@Overridepublic String toString() {return "UnionAffiliation [memberId=" + memberId + ", weeklyBue=" + weeklyBue + "]";}}

OK，再回过头来看下员工类的实现，成员变量里对于会费的计算、薪资策略的计算、发放薪水方式、发放薪水时间计算都做了抽象，将发放薪水过程的各个方法都分给了不同的接口、类进行处理，类与类间做到了低耦合、高内聚的设计思路。

    private String id;private String name;private String address;private List<Affiliation> affiliations=new ArrayList<Affiliation>();private PaymentClassification classification;private PaymentMethod paymentMethod;private PaymentSchedule schedule;

在计算发放薪资时：

public void payDay(Paycheck pc) {//发放薪水double grossPay=classification.calculatePay(pc);//薪水计算交由支付策略类计算double deductions=calculateDeductions(pc);//应扣除项交由会费类处理double netPay=grossPay-deductions;pc.setDeductions(deductions);pc.setEmpId(id);pc.setGrossPay(grossPay);pc.setNetPay(netPay);paymentMethod.pay(pc);//薪资发放交由员工选择的发放形式处理}protected double calculateDeductions(Paycheck pc) {double deductions=0;for(Affiliation affiliation:affiliations) {deductions+=affiliation.calculateDecutions(pc);}return deductions;}

整个过程类与类间的分工明确，这里还有将发放的薪资进行了封装：

public class Paycheck {//封装应支付薪水类private LocalDate payPeriodStart;//薪水起始计算时间private LocalDate payPeriodend;//薪水结束计算时间private double grossPay;//应付private double deductions;//扣除private double netPay;//实付private String empId;public Paycheck(LocalDate payperiodStart,LocalDate payPeriodend) {this.payPeriodStart=payperiodStart;this.payPeriodend=payPeriodend;}}

总结下，有人说薪水支付案例是最好的面向对象设计案例，通过这个案例的学习可以了解什么是面向接口编程而不是面向实现编程，如何设计把合适的功能分给合适的类去实现，个人觉得这个是策略设计模式非常好的运用，把代码逻辑封装到具有共同接口的独立的类中。
最后贴个自己写的本项目Github地址：

本项目Github地址