面向对象·重构·设计模式

作者: 黄大海 | 来源:发表于2021-01-27 10:57 被阅读0次

面向对象、设计原则、设计模式、编程规范、重构
GeekBand C++设计模式第一周
设计模式之美读书笔记
面向对象·重构·设计模式
第十一周 C++设计模式 Boolan 李建忠
C++设计模式 week1 (Boolan)
面向对象设计原则
GeekBand C++ 李建忠老师设计模式
第一周（Geek Band)
单例模式

设计模式六大原则

单一职责原则
开闭原则
里氏替换原则
依赖倒置原则
接口隔离原则
迪米特法则

代码的坏味道

Long Method(过长方法)

public void reserve(Integer orderId){
    //此处省略1000行代码
    //行复杂度1000，分支复杂度100
}

方案：拆分成独立的子方法

//level 1
public boolean reserve(Integer orderId){
    ReserveContext context = fetchData(orderId);
    
    if(!precheckInventory(context)){
        insufficientInventory(context);
        return false;
    }
    
    if(reserveEntirely(context)){
        return true;
    }
    
    insufficientInventory(context);
    return false;
}

//level 2
private ReserveContext fetchData(Integer orderId){
    //此处有100行
}

//level 2
private boolean precheckInventory(ReserveContext context){
    //此处有100行
}

//level 2
private boolean insufficientInventory(ReserveContext context){
    //其他代码100行
    addInventoryDemand();
    notifyLackGoodsCancel();
}

//level 2
private boolean reserveEntirely(ReserveContext context){
    //其他代码100行
    deductInventory();
    updateOrder();
    notifyPick();
    notifyAutoDeliver();
}

//level 3
private boolean addInventoryDemand(){
    //此处有100行
}

//level 3
private boolean deductInventory(){
    //此处有100行
}

//level 3
private boolean updateOrder(){
    //此处有20行
}

//level 3
private boolean notifyPick(){
    //此处有30行
}

//level 3
private boolean notifyAutoDeliver(){
    //此处有125行
}

//level 3
private boolean notifyLackGoodsCancel(){
    //此处有50行
}

Large Class(过大类)

方案：把不同的业务拆分到独立的类中

class InventoryServiceImpl implements InventoryService {
    //level 3
    private boolean addInventoryDemand(){
        //此处有100行
    }
    
    //level 3
    private boolean deductInventory(){
        //此处有100行
    }
}

interface ReserveListener{
    void onInventoryInsufficient(ReserveContext context);
    void onReserveSuccess(ReserveContext context);
}

abstract class EmptyReserveListener implements ReserveListener {
    void onInventoryInsufficient(ReserveContext context){};
    void onReserveSuccess(ReserveContext context){};
}

class UpdateOrderListener extends EmptyReserveListener {
    void onReserveSuccess(ReserveContext context){
        //此处有20行
    }
}

class NotifyPickListener extends EmptyReserveListener {
    void onReserveSuccess(ReserveContext context){
        //此处有30行
    }
}

class NotifyAutoDeliverListener extends EmptyReserveListener {
    void onReserveSuccess(ReserveContext context){
        //此处有125行
    }
}

class NotifyLackGoodsCancelListener extends EmptyReserveListener {
    void onInventoryInsufficient(ReserveContext context){
        //此处有125行
    }
}

class CompositeReserveListener implements ReserveListener {
    private List<ReserveListener> listeners = new ArrayList<>();
    
    void onInventoryInsufficient(ReserveContext context){
        for(ReserveListener each : listeners){
            each.onInventoryInsufficient(context);
        }
    }
    void onReserveSuccess(ReserveContext context){
        for(ReserveListener each : listeners){
            each.onReserveSuccess(context);
        }
    }
}
class ReserveService {
    private InventoryService inventoryService;
    
    
    
    //level 2
    private boolean insufficientInventory(ReserveContext context){
        //其他代码100行
        addInventoryDemand();
        notifyLackGoodsCancel();
    }
    
    //level 2
    private boolean reserveEntirely(ReserveContext context){
        //其他代码100行
        deductInventory();
        updateOrder();
        notifyPick();
        notifyAutoDeliver();
    }
}

Duplicated Code(重复的代码)

方案：抽取到公共的类，模版方法

Redis redis = initRedis();
Integer randomValue = Random.randomInt();
redis.set("key", randomValue, NX,PX,1000)
try{
    //do something in lock
    //此处省略200行...
}finally{
    redis.eval("if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end", "key", randomValue)
}

abstract class RedisLockTemplate {
    void doWithLock(){
        Redis redis = initRedis();
        Integer randomValue = Random.randomInt();
        redis.set("key", randomValue, NX,PX,1000)
        try{
            doWithInLock();
        }finally{
            redis.eval("if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end", "key", randomValue)
        }
    }
    
    abstract void doWithInLock();
}

class OrderServcieImpl extends RedisLockTemplate {
    void doWIthInLock(){
        //此处省略200行
    }
}

interface Callback{
    void doWithInLock();
}

class RedisLockTemplate {
    void doWithLock(RedisCallBack callBack){
        Redis redis = initRedis();
        Integer randomValue = Random.randomInt();
        redis.set("key", randomValue, NX,PX,1000)
        try{
            callBack.doWithInLock();
        }finally{
            redis.eval("if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end", "key", randomValue)
        }
    }
    
class OrderServcieImpl {
    private RedisLockTemplate lock = new RedisLockTemplate();

    public void syncOrder(Order order){
        lock.doWithLock(() -> {
            ...
            //此处省略200行  
        });
    }
}

方案：定义接口，生命周期

interface Servlet {
    void init();
    void service(ServletRequest req, ServletResponse res)
    void destroy();
}

class container {
    void void service(ServletRequest req, ServletResponse res) {
        Servlet servlet = getServlet();
        servlet.init();
        servlet.service(req, res);
        servlet.destroy();
    }
}

Long Parameter List(过长參数列表)

//出库
void stockOut(String shipmentId, String trackingNumber, String boxCode, Boolean basketFlag, String fromFacilityId, String userName, String packager);

方案：提取参数对象，Builder模式

Class StockRequest {
    String shipmentId;
    String trackingNumber;
    String boxCode;
    Boolean basketFlag;
    String fromFacilityId;
    String userName;
    String packager;
    
    //getter
    //setter
}

void stockOut(StockRequest stockRequest);

Switch Statements(过多的分支)

if(partyId = 65588){
   ...
   ...
   ...
   ...
   ...
   //此处省略100行
} else if(partyId = 65530){
    ...
    ...
    ...
    ...
    ...
    //此处省略100行
} else if(partyId = 65540){
    ...
    ...
    ...
    ...
    ...
    //此处省略100行
} else if(partyId = 65539){
    ...
    ...
    ...
    ...
    ...
    //此处省略100行
} else if(partyId = 65542){
    ...
    ...
    ...
    ...
    ...
    //此处省略100行
}

方案：提取接口，策略模式

    interface PartyProcessor {
        void processParty()
    }
    
    class FDProcessor implements PartyProcessor {
        void processParty(){
            ...
            //此处省略100行
        }
    }
    
    class AZProcessor implements PartyProcessor {
        void processParty(){
            ...
            //此处省略100行
        }
    }
    
    Map<Integer, PartyProcessor> processorByPartyId = ...;
    
    processorByPartyId.get(partyId).processParty();

if(condition1){
   ...
   ...
   ...
   ...
   ...
   //此处省略100行
} else if(condition2){
    ...
    ...
    ...
    ...
    ...
    //此处省略100行
} else if(condition3){
    ...
    ...
    ...
    ...
    ...
    //此处省略100行
} else if(condition4){
    ...
    ...
    ...
    ...
    ...
    //此处省略100行
} else if(condition5){
    ...
    ...
    ...
    ...
    ...
    //此处省略100行
}

    interface Strategy {
        boolean applyable(condition);
        void process()
    }
    
    class Strategy1 implements Strategy {
        boolean applyable(condition){
            return condition == condition1;
        }
        
        void process(){
            ...
            //此处省略100行
        }
    }
    
    class Strategy2 implements Strategy {
        boolean applyable(condition){
            return condition == condition2;
        }
    
        void process(){
            ...
            //此处省略100行
        }
    }
    
    List<Strategy> strategies = ...;
    
    for(Strategy each : strategies){
        if(each.applyable(condition)){
            each.process();
        }
    }

Feature Envy(依恋情结)

class InventoryController {
    public void inventoryLoss(String dispatchSn, String user){
        //page controller logic 100行
        
        InventoryItem inventoryItem = getInventoryItem(dispatchSn);
        vOrderSn = generateVOrderSn();
        Product product = getProduct(dispatchSn)
        
        doInventoryLoss(inventoryItem, user, inventoryItem.getFacilityId, vOrderSn, product.getGoodName(), inventoryItem.getUnitCost)
    }
}

class InventoryService {
    void doInventoryLoss(InventoryItem inventoryItem, String user, String facilityId, String vOrderSn, String goodName, String goodPrice){
        //处理业务500行
    }
}

方案：迪米特法则，接口只传递必要参数，精简参数列表

Divergent Change (多种变化)

class OrderServiceImpl {
    Order createSaleOrder(...);
    Order createPurchaseOrder(...);
    Order createStockOrder(...);
    
    void saleOrderPay();
    void saleOrderConfirm();
    void purchaseOrderStockIn();
    void stockOrderStockIn();
}

方案：拆分成不同类，各自负责某个方向

class OrderFactory {
    Order createSaleOrder(...);
    Order createPurchaseOrder(...);
    Order createStockOrder(...);    
}

class OrderService {
    void saleOrderPay();
    void saleOrderConfirm();
    void purchaseOrderStockIn();
    void stockOrderStockIn();
}

class SaleOrderService {
    Order createSaleOrder(...);
    void saleOrderPay();
    void saleOrderConfirm();
}

class InventoryOrderService {
    Order createPurchaseOrder(...);
    Order createStockOrder(...);    
    void purchaseOrderStockIn();
    void stockOrderStockIn();
}

Shotgun Surgery(霰弹式改动)

public void businessA(){
    ...200行
    //库存-供应商退货
    ...300行
}

public void businessB(){
    ...200行
    //库存-入库
    ...300行
}

public void businessD(){
    ...200行
    //库存-出库
    ...300行
}

public void businessE(){
    ...200行
    //库存-盘亏
    ...300行
}

public void businessF(){
    ...200行
    //库存-盘盈
    ...300行
}

方案：单一职责，把一类事情交给一个类来处理


class InventoryService {
    public void suppleirReturn(){
        //库存-供应商退货
    }
    
    public void inStock(){
        //库存-入库
    }
    
    public void outStock(){
        //库存-出库
    }
    
    public void loss(){
        //库存-盘亏
    }
    
    public void regain(){
        //库存-盘盈
    }
    
}

public void businessA(){
    ...200行
    inventoryService.suppleirReturn();
    ...300行
}

public void businessB(){
    ...200行
    inventoryService.inStock();
    ...300行
}

public void businessD(){
    ...200行
    inventoryService.outStock();
    ...300行
}

public void businessE(){
    ...200行
    inventoryService.loss();
    ...300行
}

public void businessF(){
    ...200行
    inventoryService.regain();
    ...300行
}

参考书目

《java与模式》
《重构:改善既有代码的设计》
《重构与模式》

面向对象、设计原则、设计模式、编程规范、重构
面向对象、设计原则、设计模式、编程规范、重构面向对象主流的三个编程风格有：面向对象，面向过程，函数式编程。面...
GeekBand C++设计模式第一周
1.设计模式简介课程目标松耦合设计思想面向对象设计原则重构技法改善设计 GOF核心设计模式设计模式不断...
设计模式之美读书笔记
面向对象、设计原则、设计模式、编程规范、重构，五者的关系面向对象，由于它具有丰富的特性，例如继承、多态、封装、抽...
面向对象·重构·设计模式
设计模式六大原则单一职责原则开闭原则里氏替换原则依赖倒置原则接口隔离原则迪米特法则代码的坏味道 Lo...
第十一周 C++设计模式 Boolan 李建忠
1. 设计模式简介课程目标理解松耦合设计思想掌握面向对象设计原则掌握重构技法改善设计掌握GOF 核心设计...
C++设计模式 week1 (Boolan)
课程目标理解松耦合设计思想掌握面向对象设计原则掌握重构技法改善设计掌握GOF核心设计模式推荐书目 GOF...
面向对象设计原则
面向对象设计原则面向对象设计原则是设计模式的基础，每个设计模式都符合一一种或多种面向对象的设计原则。常用的面向...
GeekBand C++ 李建忠老师设计模式
第一讲课程目标理解松耦合设计思想掌握面向对象设计原则掌握重构技法改善设计掌握GOF核心设计模式 GOF设...
第一周（Geek Band)
课程目标 1.理解松耦合设计思想2.掌握面向对象设计原则3.掌握重构技法改善设计4.掌握GOF核心设计模式设计模...
单例模式
面向对象设计的设计模式（四）：单例模式

面向对象·重构·设计模式

设计模式六大原则

代码的坏味道

Long Method(过长方法)

方案：拆分成独立的子方法

Large Class(过大类)

方案：把不同的业务拆分到独立的类中

Duplicated Code(重复的代码)

方案：抽取到公共的类，模版方法

方案：定义接口，生命周期

Long Parameter List(过长參数列表)

方案：提取参数对象，Builder模式

Switch Statements(过多的分支)

方案：提取接口，策略模式

Feature Envy(依恋情结)

方案：迪米特法则，接口只传递必要参数，精简参数列表

Divergent Change (多种变化)

方案：拆分成不同类，各自负责某个方向

Shotgun Surgery(霰弹式改动)

方案：单一职责，把一类事情交给一个类来处理

参考书目

相关文章

面向对象、设计原则、设计模式、编程规范、重构

GeekBand C++设计模式第一周

设计模式之美读书笔记

面向对象·重构·设计模式

第十一周 C++设计模式 Boolan 李建忠

C++设计模式 week1 (Boolan)

面向对象设计原则

GeekBand C++ 李建忠老师设计模式

第一周（Geek Band)

单例模式

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

程序员

面向对象·重构·设计模式

设计模式六大原则

代码的坏味道

Long Method(过长方法)

方案：拆分成独立的子方法

Large Class(过大类)

方案：把不同的业务拆分到独立的类中

Duplicated Code(重复的代码)

方案：抽取到公共的类，模版方法

方案：定义接口，生命周期

Long Parameter List(过长參数列表)

方案：提取参数对象，Builder模式

Switch Statements(过多的分支)

方案：提取接口，策略模式

Feature Envy(依恋情结)

方案：迪米特法则，接口只传递必要参数，精简参数列表

Divergent Change (多种变化)

方案：拆分成不同类，各自负责某个方向

Shotgun Surgery(霰弹式改动)

方案：单一职责， 把一类事情交给一个类来处理

参考书目

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

方案：单一职责，把一类事情交给一个类来处理