购物流程接口设计+案例

已于 2023-10-22 12:32:28 修改
阅读量2.1k 收藏 6
点赞数
分类专栏： 架构 文章标签： java 数据库 前端
于 2019-08-28 11:37:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhou920786312/article/details/100115924
版权

购物流程接口设计

为什么要设计这个接口

  1. 要实现代码校验和逻辑抽离
  2. 数据出错修复，打个比方说，用户支付订单后，但是订单数据还是未支付。
  3. 异步执行修复数据或者任务，不影响业务功能，加速请求校验。
    1. 打个比方说：服务商取消订单，需要发送消息给对应的用户终端，这个时候可以将发送功能接触数据修复接口，如果发送成功就不发送，发送失败就重试发送。
  4. 后期功能扩展容易
    1. 后期功能扩展可以在业务模块那边新增扩展接口，也可以action总模板路口那里做扩展设计

概念设计

在这里插入图片描述

总体设计

在这里插入图片描述

接下图
在这里插入图片描述

模板细节设计

在这里插入图片描述

策略细节设计

在这里插入图片描述接下图
在这里插入图片描述

数据修复设计

在这里插入图片描述

shoppingFlowManager设计

handler（）

  1. 对外暴露的业务执行接口，比如订单新增业务。
  2. 负责少部分的数据校验和所有的业务代码。
  3. 具体业务由子类具体实现。比如说orderAddOperation的handler方法

beforeHandler（）

  1. 执行handler方法前的操作，控制handler和afterHandler方法的执行。
  2. 具体业务由子类具体实现。比如说orderAddOperation的beforeHandler方法

afterHandler（）

  1. 执行handler方法之后的操作。
    1. 举例（异步执行）：
      1. 订单支付成功了，但是由于cpu负载的原因，导致没有更新订单状态，这个时候需要去修复数据。
  2. 具体业务由子类具体实现。比如说orderAddOperation的afterHandler方法。

check（）

  1. 处理绝大部分数据校验，异常直接抛出给外部处理。
  2. 具体业务由子类具体实现。比如说orderAddOperation的check方法

saveLog（）

  1. 记录日志接口，是对所有业务共性的抽象

action（）

  1. 模板方法，该方法记录模板的整个流程。
  2. 后期共性功能的抽象可以这里动态扩展。
    1. 打个比方说：
      1. 假设后期所有业务都要做大数据分析，那么这里可以记录大数据分析所需要的基础数据。

businessManager设计

  1. 模板具体实现，用来处理不同的业务。
  2. 对不同的业务功能可以做扩展处理。

businessOperation设计

  1. 该接口是核心的业务接口。
  2. 后期功能扩展只要实现该接口就能扩展功能加入到购物流程接口设计的体系中，比如说有个物流管理的功能，那么只要实现该接口，就如加入这套体系中。
  3. 是所有业务操作共性接口
  4. 方便做AOP扩展。比如说执行动作前，新增一些其他动作
  5. 案例：
    1. 订单新增操作
    2. 订单迁移操作
    3. 订单取消操作

ruleCheck设计

  1. 规则校验接口
  2. 是所有校验规则的父类。
  3. 方便做AOP扩展。比如说执行动作前，新增一些其他动作
  4. 案例：
    1. 订单新增规则
    2. 订单取消规则

other设计

  1. 后期扩展接口，是为了这套体系，不同业务操作那里功能做灵活扩展。
    1. 案例：订单新增操作，还需要自动生成对账单记录，其他业务不需要生成对账单
      1. 只要订单新增操作实现这个扩展接口，其他业务不需要实现该接口。

dataRepair设计

  1. 对业务数据的补偿性修复。
  2. 如果有的业务操作需要在afterHandler方法中，做数据修复，可以实现该接口
    1. 案例
      1. 订单新增：支付状态修复，如果订单微信支付成功了，但是状态还是未支付，那么实现该接口，并将修复线程放到修复任务队列中去就行，修复线程会被异步执行。
        ##数据修复设计
  3. 漏桶算法限制修复任务的执行。（限流）
  4. 任务执行的过程，队列中任务出列，线程池中线程执行该任务，不管失败还是成功，任务都从队列中丢弃。如果任务失败，持久化请求参数和对应的修复操作到数据库中。

日志核心参数的设计

  1. 业务类型
  2. 业务操作类型
  3. 业务请求参数
  4. 业务执行结果
  5. 操作人
  6. 操作日期
  7. 主键id

订单数据修复设计

  1. 支付前,执行修复动作，将数据保存到数据库中

  2. 修复动作：

    1. 间隔5秒（业务设置）后去修复数据
    2. 重试N次（业务设置）还失败就不去修复
    3. 手动页面修复。

  3. 线程主动开启或者关闭

使用规则

  1. 新增业务需要继承shoppingFlowManager抽象类
  2. 新增的业务操作需要实现businessOperation接口
  3. 如果有些业务操作需要数据修复，实现dataRepair接口
  4. 新增的业务操作规则实现ruleCheck接口
  5. 如果某些特殊的业务，需要做业务功能扩展，那么新增接口，businessManager包含新增接口。在businessManager实现的模板方法中，新增功能扩展。

在这里插入图片描述

购物流程接口设计案例

结构

在这里插入图片描述

接口代码

	package com.xxx.businessManager.business;

	/**
	 * @Author feizhou
	 * @Description 主动抛出异常处理
	 * @Date 11:18 2019/8/5
	 * @Param 
	 * @return 
	 **/

	public class BusinessException extends RuntimeException{
		private Integer code;

		private ResultModel exMessage;//扩展需要返回的信息,如果该信息存在就返回该信息

		public BusinessException(Integer code, String msg){
			super(msg);
			this.code=code;
		}

		public BusinessException(ResultModel exMessage,Integer code, String msg){
			super(msg);
			this.code=code;
			this.exMessage=exMessage;
		}

		public Integer getCode() {
			return code;
		}

		public void setCode(Integer code) {
			this.code = code;
		}

		public ResultModel getExMessage() {
			return exMessage;
		}

		public void setExMessage(ResultModel exMessage) {
			this.exMessage = exMessage;
		}
	}

	package com.xxx.businessManager.business;

	/**
	 * @Author feizhou
	 * @Description 业务操作接口
	 * @Date 14:54 2019/8/2
	 * @Param
	 * @return
	 **/
	public interface BusinessOperation {


		/**
		 * @return
		 * @Author feizhou
		 * @Description 业务核心代码
		 * @Date 14:35 2019/8/2
		 * @Param []
		 **/
		BusinessResult handler();

		/**
		 * @return
		 * @Author feizhou
		 * @Description 业务核心代码后动作
		 * @Date 14:39 2019/8/2
		 * @Param []
		 **/
		BusinessResult afterHandler();

		/**
		 * @return void
		 * @Author feizhou
		 * @Description 业务核心代码前动作
		 * @Date 14:39 2019/8/2
		 * @Param []
		 **/
		BusinessResult beforeHandler();

		/**
		 * @return void
		 * @Author feizhou
		 * @Description 数据校验，直接抛异常
		 * @Date 14:38 2019/8/2
		 * @Param []
		 **/
		void  check();


	}

	package com.xxx.businessManager.business;


	import java.util.Map;

	/**
	 * @ClassName: ShoppingFlowManager
	 * @Description 业务执行结果
	 * @Author feizhou
	 * @Date 2019/8/2  14:33
	 * @Verson 1.0
	 **/


	public class BusinessResult {

		private boolean isRunHandler=true ;   //是否执行Handler方法
		private boolean isRunAfterHandler=true ;//是否执行AfterHandler方法
		private Map<String, Object> operationParam;//业务参数
		private String businessOperationType; //业务操作类型

		private ResultModel returnObject;//返回给客户端的对象

		public boolean isRunHandler() {
			return isRunHandler;
		}

		public void setRunHandler(boolean runHandler) {
			isRunHandler = runHandler;
		}

		public boolean isRunAfterHandler() {
			return isRunAfterHandler;
		}

		public void setRunAfterHandler(boolean runAfterHandler) {
			isRunAfterHandler = runAfterHandler;
		}

		public Map<String, Object> getOperationParam() {
			return operationParam;
		}

		public void setOperationParam(Map<String, Object> operationParam) {
			this.operationParam = operationParam;
		}

		public String getBusinessOperationType() {
			return businessOperationType;
		}

		public void setBusinessOperationType(String businessOperationType) {
			this.businessOperationType = businessOperationType;
		}

		public ResultModel getReturnObject() {
			return returnObject;
		}

		public void setReturnObject(ResultModel returnObject) {
			this.returnObject = returnObject;
		}
	}

	package com.xxx.businessManager.business;

	public interface DataRepair {
		/**
		 * @Author feizhou
		 * @Description 数据修复
		 * @Date 15:50 2019/8/2
		 * @Param []
		 * @return com.lolaage.businessManager.BusinessResult
		 **/
		void toRepair();
	}

	package com.xxx.businessManager.business;

	import java.io.Serializable;

	/**
	 * @Author feizhou
	 * @Description 返回的数据
	 * @Date 15:10 2019/8/8
	 * @Param 
	 * @return 
	 **/

	public class ResultModel  implements Serializable {
		private static final long serialVersionUID = 1L;

		private Integer errCode;
		private String errMsg;
		private Object returnData;//第一优先级，如果存在，就返回该数据，如果不存在，就需要分析errCode，errMsg

		public ResultModel(Integer errCode, String errMsg) {
			this.errCode = errCode;
			this.errMsg = errMsg;
		}

		public ResultModel() {

		}

		public ResultModel(Integer errCode, String errMsg, Object returnData) {
			this.errCode = errCode;
			this.errMsg = errMsg;
			this.returnData = returnData;
		}

		public Integer getErrCode() {
			return errCode;
		}

		public void setErrCode(Integer errCode) {
			this.errCode = errCode;
		}

		public String getErrMsg() {
			return errMsg;
		}

		public void setErrMsg(String errMsg) {
			this.errMsg = errMsg;
		}

		public Object getReturnData() {
			return returnData;
		}

		public void setReturnData(Object returnData) {
			this.returnData = returnData;
		}
	}

	package com.xxx.businessManager.business;

	/**
	 * @Author feizhou
	 * @Description 规则校验接口,直接抛异常
	 * @Date 15:31 2019/8/2
	 * @Param 
	 * @return 
	 **/
	public interface RuleCheck {

		/**
		 * @Author feizhou
		 * @Description  规则校验接口,直接抛异常
		 * @Date 15:32 2019/8/2
		 * @Param []
		 * @return void
		 **/
	  void  check();
	}

	package com.xxx.businessManager.business;

	/**
	 * @ClassName: ShoppingFlowManager
	 * @Description 业务流程模板
	 * @Author feizhou
	 * @Date 2019/8/2  14:33
	 * @Verson 1.0
	 **/
	public abstract class ShoppingFlowManager {

		private BusinessResult businessResult = new BusinessResult();

		/**
		 * @return void
		 * @Author feizhou
		 * @Description 方法模板
		 * @Date 15:46 2019/8/2
		 * @Param []
		 **/
		public final BusinessResult action() {

			try {
				saveLog();
				check();
				businessResult = beforeHandler();

				if (businessResult.isRunHandler()) {
					businessResult = handler();
				}

				if (businessResult.isRunAfterHandler()) {
					businessResult = afterHandler();
				}
			} catch (Exception e) {
				ResultModel m=new ResultModel();

				//打印异常
				e.printStackTrace();

				if (e instanceof BusinessException) {
					//检测主动抛出的异常
					BusinessException be = (BusinessException) e;
					if(be.getExMessage()!=null){
						m=be.getExMessage();
					}else {
						m.setErrCode(be.getCode());
						m.setErrMsg(be.getMessage());
					}
				} else {
					//系统异常
					m.setErrCode(-2);
					m.setErrMsg(e.getMessage());
				}
				businessResult.setReturnObject(m);
			}

			return businessResult;

		}

		/**
		 * @return java.util.Map
		 * @Author feizhou
		 * @Description 记录日志
		 * @Date 14:35 2019/8/2
		 * @Param []
		 **/
		private void saveLog() {

		}


		/**
		 * @return
		 * @Author feizhou
		 * @Description 业务核心代码
		 * @Date 14:35 2019/8/2
		 * @Param []
		 **/
		public abstract BusinessResult handler();

		/**
		 * @return
		 * @Author feizhou
		 * @Description 业务核心代码后动作
		 * @Date 14:39 2019/8/2
		 * @Param []
		 **/
		public abstract BusinessResult afterHandler();

		/**
		 * @return void
		 * @Author feizhou
		 * @Description 业务核心代码前动作
		 * @Date 14:39 2019/8/2
		 * @Param []
		 **/
		public abstract BusinessResult beforeHandler();

		/**
		 * @return void
		 * @Author feizhou
		 * @Description 数据校验，直接抛异常
		 * @Date 14:38 2019/8/2
		 * @Param []
		 **/
		public abstract void check();


	}

	package com.xxx.businessManager.workTask;


	import com.xxx.businessManager.business.DataRepair;

	public class  Task {


		/**
		 * @Author feizhou
		 * @Description 需要执行的方法
		 * @Date 9:57 2019/8/12
		 * @Param 
		 * @return 
		 **/
		private DataRepair dataRepair;
		
		/**
		 * @Author feizhou
		 * @Description 方法执行失败后,重试次数,默认3
		 * @Date 9:58 2019/8/12
		 * @Param 
		 * @return 
		 **/
		private int tryTime;

		/**
		 * @Author feizhou
		 * @Description 方法执行失败后,重试尝试的间隔时间，算法：t=（intervalBaseTime的2*alreadyhasRunTime幂函数)
		 * @Date 9:58 2019/8/12
		 * @Param
		 * @return
		 **/
		private int intervalTime[]={3,6,9};

		/**
		 * @Author feizhou
		 * @Description 方法执行失败后，已经执行的运行次数
		 * @Date 9:58 2019/8/12
		 * @Param
		 * @return
		 **/
		private int alreadyhasRunTime;


		public int getTryTime() {
			return tryTime;
		}


		public int getIntervalTime() {
			return intervalTime[alreadyhasRunTime]*1000;
		}


		//修复数据的接口
		public DataRepair getDataRepair() {
			return dataRepair;
		}
		public void setDataRepair(DataRepair dataRepair) {
			this.dataRepair = dataRepair;
		}

	//构造方法

		public Task(DataRepair dataRepair) {
			this.dataRepair = dataRepair;
			this.tryTime =  intervalTime.length;

		}


		public Task(DataRepair dataRepair,  int ... intervalTime) {
			this.dataRepair = dataRepair;
			this.tryTime =  intervalTime.length;
			this.intervalTime=intervalTime;
		}


		//已经运行的次数

		public int getAlreadyhasRunTime() {
			return alreadyhasRunTime;
		}

		public void setAlreadyhasRunTime(int alreadyhasRunTime) {

			this.alreadyhasRunTime = alreadyhasRunTime;
		}



		
	}

	package com.xxx.businessManager.workTask;

	import com.xxx.businessManager.business.BusinessException;
	import com.xxx.businessManager.business.DataRepair;

	import java.util.concurrent.BlockingQueue;
	import java.util.concurrent.LinkedBlockingDeque;

	/**
	 * @Author feizhou
	 * @Description 处理一些非事务异步任务, 也就是对数据一致性要求不高的功能
	 * @Date 14:53 2019/7/22
	 * @Param
	 * @return
	 **/
	public class  TaskWork {

		/**
		 * @Author feizhou
		 * @Description 线程池中默认线程的个数为1
		 * @Date 14:31 2019/7/22
		 **/
		private static int worker_num = 1;



		/**
		 * @Author feizhou
		 * @Description 任务队列
		 * @Date 14:31 2019/7/22
		 **/
		private static BlockingQueue<Task> taskQueue = new LinkedBlockingDeque<>();



		/**
		 * @Author feizhou
		 * @Description 工作线程
		 * @Date 14:31 2019/7/22
		 **/
		private static WorkThread[] workThrads;


		private static TaskWork taskWork=new TaskWork();



		public static void dispatch(Task task) {
			try {
				taskQueue.put(task);

			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}



		//构造私有，防止开发者实例化类Single，创建出新的single
		private TaskWork() {
			init();
		};
		public static TaskWork getTaskWork() {
			return taskWork;
		}
		/**
		 * @Author feizhou
		 * @Description 构造方法执行完毕, 也就是类加载完成后执行intit方法
		 * @Date 14:31 2019/7/22
		 **/

		public void init() {

			workThrads = new WorkThread[worker_num];
			for (int i = 0; i < worker_num; i++) {
				workThrads[i] = new WorkThread();
				workThrads[i].setName("LimitTaskThread-" + i);
				workThrads[i].start();// 开启线程池中的线程
			}
		}

		/**
		 * @Author feizhou
		 * @Description 定义工作线程
		 * @Date 14:52 2019/7/22
		 * @Param
		 * @return
		 **/
		private class WorkThread extends Thread {



			@Override
			public void run() {
				while (true) {
					try {
						//获取队列的任务
						//阻塞式方法，没有元素就等待
						Task  task = taskQueue.take();
						runTask(task);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}

				}
			}

			/**
			 * @Author feizhou
			 * @Description 执行任务
			 * @Date 10:11 2019/8/12
			 * @Param []
			 * @return void
			 **/
			private void runTask(Task task) throws InterruptedException {

				//方法执行错误后的执行次数
				int tryTime = task.getTryTime();
				//已经修复的次数
				int alreadyhasRunTime = task.getAlreadyhasRunTime();


				if(alreadyhasRunTime<tryTime){
					//间隔时间
					int intervalTime = task.getIntervalTime();

					task.setAlreadyhasRunTime(++alreadyhasRunTime);
					try {
						System.out.println("第"+alreadyhasRunTime+"次修复数据执行--"+"间隔时间:"+intervalTime+"--请求的参数"+task.getDataRepair());
						Thread.sleep(intervalTime);
						task.getDataRepair().toRepair();
					}catch (Exception e){
						//阻塞式方法， 元素满就等待
						if(alreadyhasRunTime<tryTime){
							taskQueue.put(task);
						}

					}
				}


			}
		}

		public static void main(String[] args) {

			DataRepair dataRepair= new DataRepair() {
				@Override
				public void toRepair() {
					throw  new BusinessException(2,"333");
				}
			};



			Task task=new Task(dataRepair, 3,4);
			TaskWork.dispatch(task);


		}


	}

使用案例（订单取消）

	/**
	 * @Author feizhou
	 * @Description 活动订单管理：用户取消订单
	 * @Date 16:22 2019/8/2
	 * @Param
	 * @return
	 **/
	@Transactional
	public class OutingOrderForUserCancel implements BusinessOperation {
		private static Logger log = Logger.getLogger(OutingOrderForUserCancel.class);
		//请求参数
		private QuitParam quitParam;
		//全局变量，校验的时候会初始化
		private Business_activity_order order;
		private BusinessResult businessResult = new BusinessResult();
		//服务层
		private IBusinessActivityOrderService businessActivityOrderService;


		/**
		 * @return void
		 * @Author feizhou
		 * @Description 初始化服务层
		 * @Date 10:17 2019/8/6
		 * @Param []
		 **/
		private void initService() {
			businessActivityOrderService = (IBusinessActivityOrderService) ContextUtil.getBean("businessActivityOrderService");

		};




		//请求参数
		public OutingOrderForUserCancel(QuitParam quitParam) {
			this.quitParam=quitParam;
			initService();
		}



		/**
		 * @return com.lolaage.businessManager.BusinessResult
		 * @Author feizhou
		 * @Description 处理业务
		 * @Date 16:23 2019/8/2
		 * @Param []
		 **/
		@Override
		public BusinessResult handler() {

			JsonModel result =  toCancel();

			ResultModel resultModel = new ResultModel(0, "success");
			resultModel.setReturnData(result);
			businessResult.setReturnObject(resultModel);


			return businessResult;

		}

		/**
		 * @Author feizhou
		 * @Description 取消訂單，已经将校验逻辑抽离的业务逻辑
		 * @Date 10:22 2019/8/19
		 * @Param 
		 * @return void
		 **/
		private JsonModel toCancel() {

			  return  null;
		}
		/**
		 * @Author feizhou
		 * @Description 异步tcp发通知
		 * @Date 10:48 2019/8/20
		 * @Param
		 * @return void
		 **/
		private void sendMsgForTCP(Long userId, String authCode, String socketSvrIp, Long outingId, Long startTime, Byte type, Long uid, Long memberOrderId) {
			DataRepair dataRepair=new OutingOrderForUserCancelSendTCPMsgDataRepair(  userId,   authCode,   socketSvrIp,   outingId,   startTime,   type,   uid,   memberOrderId );
			HashMap<String, Object> pa = new HashMap<>();
			pa.put("dataRepair",dataRepair);
			Task task=new Task(dataRepair, 1,60,180);
			TaskWork.dispatch(task);
		}


		@Override
		public BusinessResult afterHandler() {

			//订单取消完成，需要通知终端，但是调用终端是其他的服务，
			// 且和当前的功能事务无关，那么我们将它定义为需要修复的数据，让它异步去执行
			//这里我为了简化代码，就传null值
			sendMsgForTCP( null,   null,   null,   null,   null,   null,   null,   null );
			return businessResult;
		}

		@Override
		public BusinessResult beforeHandler() {
		   //做一些数据的修补工作，比如说本来IOS端需要传递一个参数status过来的，但是现在对应的版本没有传
			//但是现在IOS版本已经上线了，来不及修改，那么我们可以这里做下判断补充

			return businessResult;
		}

		@Override
		public void check() {
			//处理数据校验和初始全局变量
			order = businessActivityOrderService.findById(quitParam.getOrderId());
			//订单校验
			orderCheck(order);
		}



		/**
		 * @Author feizhou
		 * @Description 订单校验
		 * @Date 11:18 2019/8/15
		 * @Param [order]
		 * @return void
		 **/
		private void orderCheck(Business_activity_order order) {

			if(order == null){
				throw new BusinessException(SystemErrCode.REQ_PARAM_ERROR,"订单不存在");
			}
			//'订单状态：0-待支付，1-已支付，2-订单异常，6-已取消 ,7部分退出，8已完成',
			if(order.getStatus()==6){
				throw new BusinessException(SystemErrCode.REQ_PARAM_ERROR,"订单已取消");
			}

		}



	}

	/**
	 * @Author feizhou
	 * @Description 活动订单管理：用户取消订单,发送tcp数据修复
	 * @Date 16:22 2019/8/2
	 * @Param
	 * @return
	 **/
	@Transactional
	public class OutingOrderForUserCancelSendTCPMsgDataRepair implements DataRepair {
		private static Logger log = Logger.getLogger(OutingOrderForUserCancelSendTCPMsgDataRepair.class);
		//请求参数
		private Long userId;
		private String authCode;
		private String socketSvrIp;
		private Long outingId;
		private Long startTime;
		private byte type;
		private Long uid;
		private Long memberOrderId;



		//请求参数
		public OutingOrderForUserCancelSendTCPMsgDataRepair(Long userId, String authCode, String socketSvrIp, Long outingId, Long startTime, byte type, Long uid, Long memberOrderId) {
			this.userId = userId;
			this.authCode = authCode;
			this.socketSvrIp = socketSvrIp;
			this.outingId = outingId;
			this.startTime = startTime;
			this.type = type;
			this.uid = uid;
			this.memberOrderId = memberOrderId;
		}


		@Override
		public void toRepair() {
			new OutingAction().commOutingMemberEntry(  userId,   authCode,   socketSvrIp,   outingId,   startTime,   type,   uid,   memberOrderId);
		}

		@Override
		public String toString() {
			return "OutingOrderForCancelSendTCPMsgDataRepair{" +
					"userId=" + userId +
					", authCode='" + authCode + '\'' +
					", socketSvrIp='" + socketSvrIp + '\'' +
					", outingId=" + outingId +
					", startTime=" + startTime +
					", type=" + type +
					", uid=" + uid +
					", memberOrderId=" + memberOrderId +
					'}';
		}
	}

好处

  1. 校验和逻辑抽离
  2. 数据出错修复
  3. 异步执行修复数据或者任务，不影响业务功能，加速请求校验
  4. 后期接口扩展容易
勤径苦舟
关注
专栏目录
主题 12：实践案例集锦之接口设计
Jin_Kwok的博客
10-28 621
1. 引言 API 是模块或者子系统之间交互的桥梁，好的系统架构离不开好的 API 设计。在《主题 1：如何设计一个好的 API》一文中，笔者解读了什么样的 API 设计是好的设计，本文作为 API 设计话题的延续，将介绍如何在设计中实践之前介绍的设计方法论。 成功的系统不是有一些特别闪光的地方，而是设计时点点滴滴的努力积累起来的。 API 设计面临的挑战千差万别，没有一种普适性的原则可以...
接口设计说明书（软件设计文档范例）
12-11
接口设计说明书 本接口说明书详细介绍了LK9000编程接口函数的功能，用法、声明所在的头文件。用户在开发LK9000软件时必须阅读该说明书。
接口设计实例
conganguo的专栏
03-15 2407
http://bbs.csdn.net/topics/390985459   问题： 这是为了描述各种硬件设备而设计的，应用的时候有点问题。 接口：A类设备 d1 = new 类：1号设备 接口：A类设备 d2 = new 类：2号设备 可是无法直接调用接口：串口或者接口：网口中的方法 暂时有一个变通的办法就是 (d1 as 接口：串口).Port = 10;
接口用例设计
伤心的辣条
09-04 227
接口用例设计方法中，针对输入、输出的设计是通用的，接口设计时都可用到。对于接口逻辑的设计可能会应用比较适合的一种或几种方法，在接口用例设计时，需要选取最合适的方法去覆盖被测逻辑。当测试时间紧任务重的情况下，用例设计需要具体情况具体分析。
六、【功能接口测试】用例设计方法及案例：单接口和业务场景
学习，学无止境
03-30 1224
接口测试的测试点有功能测试、性能测试和安全测试。其中功能测试分为单接口测试和业务场景测试的测试方法及测试用例案例。测试方法主要分为正向和反向思考。
基于微信小程序电子购物系统设计+ssm后端源码案例设计.zip
最新发布
04-21
总的来说，这个基于微信小程序的电子购物系统设计案例，结合SSM后端框架，为我们展示了现代电子商务平台的技术实现。它不仅涵盖了完整的电商功能，还融入了微信小程序的特性，为开发者提供了宝贵的学习和实践资源。...
基于Springboot+Vue购物推荐网站设计源码案例设计.zip
04-21
【标题】"基于Springboot+Vue购物推荐网站设计源码案例设计"是一个综合性的IT项目，旨在构建一个现代化的在线购物平台，结合了后端的Spring Boot框架与前端的Vue.js技术。这样的组合使得系统具备高效、轻量级以及...
基于JSP+Servlet+Jdbc宅商城购物网站设计源码案例设计.zip
04-19
【标题】基于JSP+Servlet+Jdbc宅商城购物网站设计源码案例设计 这个项目是一个典型的电子商务网站实现，利用了Java Web技术栈中的JSP（JavaServer Pages）、Servlet和JDBC（Java Database Connectivity）来构建一个...
基于微信小程序购物商城app设计带Java后端接口源码案例设计.zip
04-20
"基于微信小程序购物商城app设计带Java后端接口源码案例设计.zip"这个标题揭示了几个关键的IT知识点： 1. **微信小程序**：微信小程序是一种轻量级的应用开发平台，允许开发者在微信生态内构建无需安装即可使用的...
基于Springboot+Vue的前后端分离电子购物商城设计源码案例设计.zip
04-19
《基于Springboot+Vue的前后端分离电子购物商城设计源码案例详解》 在现代互联网应用开发中，前后端分离的架构模式已经成为主流。本案例将深入探讨如何使用Springboot和Vue.js这两种强大的技术栈来构建一个完整的...
系统接口设计对接方案 .docx
12-20
系统接口对接方式，涉及到安全，方式，压缩，解压，规范，标准，口令，审计，责任等。 系统接口对接方式，涉及到安全，方式，压缩，解压，规范，标准，口令，审计，责任等。
系统型产品接口设计方法总结
02-25
现在社会都在将谈论“共享”，很多我们接触的APP中，要完成所有的业务流程多少都需要和第三方产品进行对接，使用第三方已完成的功能。举个简单的例子：现在几乎所有的APP注册都是使用手机号进行注册，为了验证手机号为操作人本人所使用，都会发送一条短信验证码。这个时候，基本上发送短信的业务就使用到了第三方短信平台来完成。所以作为产品经理必须要了解，如何进行对接，要传什么信息给第三方平台，第三方平台处理完成业务后，所返回的信息我们应该如何处理等。在此，我就简单的做个总结，让各位刚入行的产品经理们知道如何进行多系统对接。首先，从了解基本名称出发；其次，了解设计的方法；最后案例解说加深大家的理解。软件接口：程
中航信FlightShopping调用接口示例
11-20
该工程为样例工程，涉及国际运价FlightShopping调用，主要包含如下样例： 1、生成调用所需要的xml信息(XmlGenDemo.java) 2、调用http请求，获取国际运价信息(HttpDemo.java) 3、解析调用的结果(XmlParseDemo.java) 【工具类说明】 工具类包含如下两项内容： 1、构造和解析xml数据的工具（ObjectFactory.java） 2、http调用的工具（HttpHelper.java） 【依赖jar包说明】 依赖的jar包如下： 1、ota-xml-dto-tsk-1.2.0-SNAPSHOT-jar-with-dependencies.jar ：用户构造和解析xml数据 2、commons-httpclient-3.1.jar和commons-codec-1.4.jar：用于http调用 【其他文件】 1、schema目录下TSK_AirFareFlightShop.xsd描述的是国际运价FlightShopping的schema文档 2、sample目录下的文件，是请求和返回的样例，供参考 3、castor.properties文件需存放于工程的classpath之下 【注意】 该工程基于jdk1.5
流程接口_eas
weixin_40570988的博客
09-15 233
/*IEnactmentService wfService = EnactmentServiceProxy.getEnacementService(ctx); ProcessInstInfo[] processInstances = wfService.getProcessInstanceByHoldedObjectId(info.getId().toString());//不包括已经结束的流程// if(null != processInstances &&...
【案例分析】分布式系统的接口幂等性设计！
xmt1139057136的专栏
04-10 1119
概念幂等性, Idempotence, 这个词来源自数学领域, 百科 上一元运算的幂等性解释如下：设 f 为一由 {x} 映射至 {x} 的一元运算, 则 f 为幂等的, 当对于所有在 {...
9.【I/O接口系统综合设计示例】
你说的白是什么白_
01-17 1051
【I/O接口系统综合设计示例】
接口流程图
weixin_34364135的博客
01-08 5142
转载于:https://www.cnblogs.com/hfdp/p/5112512.html
电商系统设计之商品接口|电商商品封装API接口
2301_79478575的博客
10-26 119
我应该是少数在文章中直接展示接口文档的人。本篇我思考了很久到底要不要解析下商品接口开发的注意点。客户端开发与服务端开发即是天敌也是兄弟。希望本篇文章让你们减少争执，把“爱”给对方。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值