使用桥接模式来显示下单结果-低调大师

使用桥接模式来显示下单结果

2019-09-03 812

在用工厂方法模式来下不同订单中我们看到，我们只简单显示来一个“下单成功”，但实际上我们需要给用户返回到结果可能多种多样。

先增加一个订单结果到接口。

public interface OrderSuccessResult {
    public OrderSuccessResult getResult(Order order);
}

添加一个服务订单结果实现类

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class ServiceOrderSuccessResult implements OrderSuccessResult {
    private String content;
    private String storeName;
    private String orderCode;
    private String servicContent;
    private Date serviceDate;
    private String storeAddress;
    private BigDecimal serviceAmount;

    @Override
    public OrderSuccessResult getResult(Order order) {
        ServiceOrderSuccessResult orderSuccessResult = ServiceOrderSuccessResult.builder()
                .content("服务商家正在审核，请耐心等待")
                .orderCode(((ServiceOrder)order).getCode())
                .serviceAmount(((ServiceOrder)order).getService().getService().getPrice().getNormalPrice())
                .serviceDate(((ServiceOrder)order).getServiceDate())
                .servicContent(((ServiceOrder)order).getService().getSimpleContent())
                .storeName(((ServiceOrder)order).getStore().getName())
                .storeAddress(((ServiceOrder)order).getStore().getAddress().getName())
                .build();
        return orderSuccessResult;
    }
}

给Order接口添加一个适配方法

public interface Order {
    public void makeOrder(Order order);
    public OrderSuccessResult getResult(Order order);
}

增加一个订单抽象类，完成对订单结果接口的桥接

public abstract class AbstractOrder implements Order {
    protected OrderSuccessResult orderSuccessResult;
}

修改各个Order的实现类，继承于该抽象类

@Data
@AllArgsConstructor
@NoArgsConstructor
@ServiceOrderVersion(value = 1)
@RequiredArgsConstructor
public class ServiceOrder extends AbstractOrder {
    private Long id;
    @NonNull
    private String code;
    @NonNull
    private Store store;
    @NonNull
    private ProviderService service;
    @NonNull
    private Car car;
    @NonNull
    private Date serviceDate;
    @NonNull
    private String contact;
    @NonNull
    private String contactTel;
    private AppUser user;
    @NonNull
    private String content;
    private int status;
    private Date createDate;


    @Override
    public void makeOrder(Order order) {
        ServiceOrderDao serviceOrderDao = SpringBootUtil.getBean(ServiceOrderDao.class);
        IdService idService = SpringBootUtil.getBean(IdService.class);
        ((ServiceOrder)order).setId(idService.genId());
        ((ServiceOrder)order).setCode(getCode(idService));
        AppUser loginAppUser = AppUserUtil.getLoginAppUser();
        AppUser user = new AppUser();
        user.setId(loginAppUser.getId());
        user.setUsername(loginAppUser.getUsername());
        ((ServiceOrder)order).setUser(user);
        ((ServiceOrder)order).setStatus(1);
        ((ServiceOrder)order).setCreateDate(new Date());
        serviceOrderDao.save((ServiceOrder) order);
    }

    @Override
    public OrderSuccessResult getResult(Order order) {
        this.orderSuccessResult = new ServiceOrderSuccessResult();
         return this.orderSuccessResult.getResult(order);
    }

    private String getCode(IdService idService) {
        String flow = String.valueOf(idService.genId());
        flow = flow.substring(14,flow.length());
        String pre = DateUtils.format(new Date(), DateUtils.pattern9);
        return pre + flow;
    }
}

我们可以看到this.orderSuccessResult = new ServiceOrderSuccessResult();对ServiceOrderSuccessResult进行了耦合，此处需要修改。

Controller修改如下

@Slf4j
@RestController
public class OrderController {
    private ThreadLocal<OrderFactory> orderFactory = new ThreadLocal<>();
    private ThreadLocal<Order> orderService = new ThreadLocal<>();
    @Autowired
    private OrderBean orderBean;

    @Transactional
    @SuppressWarnings("unchecked")
    @PostMapping("/makeeorder")
    public Result<OrderSuccessResult> makeOrder(@RequestBody String orderStr, @RequestParam("type") String type) {
        log.info(orderStr);
        try {
            Order order = setOrderFactory(orderStr,type);
            orderService.get().makeOrder(order);
            return Result.success(orderService.get().getResult(order));
        }
        finally {
            orderFactory.remove();
            orderService.remove();
        }
    }

    /**
     * 判断是哪一种类型的订单来获取哪一种类型的具体订单工厂
     * @param orderStr
     * @return
     */
    private Order setOrderFactory(String orderStr,String type) {
        Class<?> classType = orderBean.getOrderMap().get(type);
        Object order = JSONObject.parseObject(orderStr, classType);
//        if (orderStr.contains("service")) {
//            order = JSON.parseObject(orderStr, ServiceOrder.class);
//        }else if (orderStr.contains("product")) {
//            order = JSON.parseObject(orderStr, ProductOrder.class);
//        }
        Class<?> classFactoryType = orderBean.getOrderFactoryMap().get(type + "Factory");
        this.orderFactory.set((OrderFactory) SpringBootUtil.getBean(classFactoryType));
//        if (order instanceof ServiceOrder) {
//            this.orderFactory.set(SpringBootUtil.getBean(ServiceOrderFactory.class));
//        }else if (order instanceof ProductOrder) {
//            this.orderFactory.set(SpringBootUtil.getBean(ProductOrderFactory.class));
//        }
        orderService.set(orderFactory.get().getOrder());
        return (Order) order;
    }
}

现在运行是没有问题的。返回结果如下

{

"code" : 200 ,

"data" : {

"content" : "服务商家正在审核，请耐心等待" ,

"orderCode" : "2019090353318" ,

"servicContent" : "精细洗车" ,

"serviceAmount" : 100 ,

"serviceDate" : "2019-10-03T00:00:00.000+0800" ,

"storeAddress" : "北京市海淀区西北旺" ,

"storeName" : "三润汽修厂"

},

"msg" : "操作成功"

}

现在我们用简单工厂进行解耦合。添加版本标签

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ServiceResultVersion {
    int value();
}

ServiceOrderSuccessResult打上版本标签

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@ServiceResultVersion(value = 1)
public class ServiceOrderSuccessResult implements OrderSuccessResult {
    private String content;
    private String storeName;
    private String orderCode;
    private String servicContent;
    private Date serviceDate;
    private String storeAddress;
    private BigDecimal serviceAmount;

    @Override
    public OrderSuccessResult getResult(Order order) {
        ServiceOrderSuccessResult orderSuccessResult = ServiceOrderSuccessResult.builder()
                .content("服务商家正在审核，请耐心等待")
                .orderCode(((ServiceOrder)order).getCode())
                .serviceAmount(((ServiceOrder)order).getService().getService().getPrice().getNormalPrice())
                .serviceDate(((ServiceOrder)order).getServiceDate())
                .servicContent(((ServiceOrder)order).getService().getSimpleContent())
                .storeName(((ServiceOrder)order).getStore().getName())
                .storeAddress(((ServiceOrder)order).getStore().getAddress().getName())
                .build();
        return orderSuccessResult;
    }
}

添加简单工厂类(其实这里也可以使用工厂方法模式，但怕过于复杂，故不使用工厂方法模式)

@Component
public class ServiceOrderSuccessResultFactory {
    @Getter
    private OrderSuccessResult orderSuccessResult;

    @PostConstruct
    private void init() {
        this.orderSuccessResult = createResult();
    }
    
    
    private OrderSuccessResult createResult() {
        Set<Class<?>> classes = ClassUtil.getClassSet("com.cloud.ownercar.domain");
        Object instance = null;
        try {
            //过滤有@ServiceResultVersion标签的类
            instance = classes.stream().filter(clazz -> clazz.isAnnotationPresent(ServiceResultVersion.class))
                    //过滤实现了OrderSuccessResult接口的类
                    .filter(clazz -> OrderSuccessResult.class.isAssignableFrom(clazz))
                    //找出版本号大的类，并实例化为对象
                    .max(Comparator.comparingInt(clazz -> clazz.getAnnotation(ServiceResultVersion.class).value()))
                    .get().newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return (OrderSuccessResult) instance;
    }
}

修改ServiceOrder如下

@Data
@AllArgsConstructor
@NoArgsConstructor
@ServiceOrderVersion(value = 1)
@RequiredArgsConstructor
public class ServiceOrder extends AbstractOrder {
    private Long id;
    @NonNull
    private String code;
    @NonNull
    private Store store;
    @NonNull
    private ProviderService service;
    @NonNull
    private Car car;
    @NonNull
    private Date serviceDate;
    @NonNull
    private String contact;
    @NonNull
    private String contactTel;
    private AppUser user;
    @NonNull
    private String content;
    private int status;
    private Date createDate;


    @Override
    public void makeOrder(Order order) {
        ServiceOrderDao serviceOrderDao = SpringBootUtil.getBean(ServiceOrderDao.class);
        IdService idService = SpringBootUtil.getBean(IdService.class);
        ((ServiceOrder)order).setId(idService.genId());
        ((ServiceOrder)order).setCode(getCode(idService));
        AppUser loginAppUser = AppUserUtil.getLoginAppUser();
        AppUser user = new AppUser();
        user.setId(loginAppUser.getId());
        user.setUsername(loginAppUser.getUsername());
        ((ServiceOrder)order).setUser(user);
        ((ServiceOrder)order).setStatus(1);
        ((ServiceOrder)order).setCreateDate(new Date());
        serviceOrderDao.save((ServiceOrder) order);
    }

    @Override
    public OrderSuccessResult getResult(Order order) {
        ServiceOrderSuccessResultFactory orderSuccessResultFactory = SpringBootUtil.getBean(ServiceOrderSuccessResultFactory.class);
        this.orderSuccessResult = orderSuccessResultFactory.getOrderSuccessResult();
        return this.orderSuccessResult.getResult(order);
    }

    private String getCode(IdService idService) {
        String flow = String.valueOf(idService.genId());
        flow = flow.substring(14,flow.length());
        String pre = DateUtils.format(new Date(), DateUtils.pattern9);
        return pre + flow;
    }
}

微信关注我们

原文链接：https://my.oschina.net/u/3768341/blog/3101448

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

Ceph 中的 PG 状态详解

Creating Peering Activating Active Backfilling Backfill-toofull Backfill-wait Incomplete Inconsistent Peered Recovering Recovering-wait Remapped Scrubbing Unactive Unclean Stale Undersized Down Creating 含义：PG正在创建引起原因：创建pool的时候，根据指定的pg数量进行创建pg时出现的状态，正常状态后果：无解决方案：无需解决，正常状态之一 Peering 含义：PG之间进行互联，就其中的对象和元数据状态达成一致引起原因：当pg被creating之后，会进行互联，存储归置组副本的 OSD 之间就其中的对象和元数据状态达成一致。后果：无解决方案：无需解决，正常状态之一 Activating 含义：pg在完成peering过程后，会对之前的结果进行固化，等待所有pg同步，尝试进入active状态引起原因：pg进入active前的准备状态后果：如果长期卡在该状态，...

2019-09-03

878

本文是作者通过亲身实践，从零基础开始，一步一步总结出来的Kubernetes持续部署工作流程。文章从前期的工具准备开始，到复刻存储库、测试、构建镜像、构建流水线最后进行部署，所有的工作流程都一一展现在文章中，对于想要拥有全自动持续交付流水线的用户将有很大的借鉴意义。在很久很久以前的一份工作中，我的任务是将老式的LAMP堆栈切换到Kubernetes上。那会儿我的老板总是追逐新技术，认为只需要几天时间就能够完成新旧技术的迭代——鉴于那时我们甚至对容器的工作机制一无所知，所以不得不说老板的想法真的很大胆。在阅读了官方文档并且搜索了很多信息之后，我们开始感到不知所措——有许多新的概念需要学习：pod、容器以及replica等。对我而言，Kubernetes似乎只是为一群聪明的开发者而设计的。然后我做了我在这一状况下常做的事：通过实践来学习。通过一个简单的例子可以很好地理解错综复杂的问题，所以我自己一步一步完成了整个部署过程。最后，我们做到了，虽然远未达到规定的一周时间——我们花了将近一个月的时间来创建三个集群，包括它们的开发、测试和生产。本文我将详细介绍如何将应用程序部署到Kube...

2019-09-04

829

资源下载

更多资源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

WebStorm

WebStorm 是jetbrains公司旗下一款JavaScript 开发工具。目前已经被广大中国JS开发者誉为“Web前端开发神器”、“最强大的HTML5编辑器”、“最智能的JavaScript IDE”等。与IntelliJ IDEA同源，继承了IntelliJ IDEA强大的JS部分的功能。