• 编写云计算计费系统

    上一篇介绍了自建一个Laxcus云服务需要了解的基础知识，这一篇咱们从编程角度，来说说如何编写一个简单的云服务计费系统，如果你有更复杂的需求，可以在这个上面扩展。更进一步，如果你非常熟悉Laxcus分布式操作系统的运行流程，那么可以去GitHub拿源代码修改，甚至直接操作底层或者硬件获取必要信息，这样会更贴近你的需求。
    闲话不多说，咱们正式进入主题。
    编写一个简单的Laxcus云服务计费系统，需要这样三步：
    1.了解Check User Cost命令。
    2.了解Check User Cost命令的返回结果。
    3.生成Check User Cost命令，调用系统DSDK软件包的API，把命令投递到Laxcus计算机集群上执行，然后等待返回结果，解析结果中的信息，结合你的计费算法，得出计费结果。

    目前Laxcus分布式操作系统的DSDK软件包，只支持Java编程，同类型的C、C++接口、Python接口，还处于Alpha状态，暂时没有公布出来。所以咱们这篇文章就以Java编程的方式，来介绍编写Laxcus云服务计费的系统。

    一、Check User Cost命令
    Check User Cost命令的源代码如下

    1. public class CheckUserCostProduct extends EchoProduct {
    2.  
    3. 	private static final long serialVersionUID = 3146106632408001248L;
    4.  
    5. 	/** 用户签名 -> 单元 **/
    6. 	private Map array = new TreeMap();
    7.  
    8. 	/**
    9. 	 * 构造默认的服务器系统信息检测结果
    10. 	 */
    11. 	public CheckUserCostProduct() {
    12. 		super();
    13. 	}
    14.  
    15. 	/**
    16. 	 * 从可类化数据读取器解析服务器系统信息检测结果
    17. 	 * @param reader 可类化数据读取器
    18. 	 */
    19. 	public CheckUserCostProduct(ClassReader reader) {
    20. 		this();
    21. 		resolve(reader);
    22. 	}
    23.  
    24. 	/**
    25. 	 * 构造服务器系统信息检测结果的数据副本
    26. 	 * @param that CheckUserCostProduct实例
    27. 	 */
    28. 	private CheckUserCostProduct(CheckUserCostProduct that) {
    29. 		super(that);
    30. 		array.putAll(that.array);
    31. 	}
    32.  
    33. 	/**
    34. 	 * 加一个
    35. 	 * @param product
    36. 	 */
    37. 	public void add(CheckUserCostProduct product) {
    38. 		for (UserCostElement element : product.array.values()) {
    39. 			add(element.getIssuer(), element);
    40. 		}
    41. 	}
    42.  
    43. 	/**
    44. 	 * 加全部
    45. 	 * @param issuer 用户签名
    46. 	 * @param element 成员
    47. 	 */
    48. 	public void add(Siger issuer, UserCostElement element) {
    49. 		UserCostElement that = array.get(issuer);
    50. 		if (that != null) {
    51. 			that.addAll(element.list());
    52. 		} else {
    53. 			array.put(issuer, element);
    54. 		}
    55. 	}
    56.  
    57. 	/**
    58. 	 * 加一个单元
    59. 	 * @param issuer 签名
    60. 	 * @param item 成员
    61. 	 */
    62. 	public void add(Siger issuer, UserCostItem item) {
    63. 		UserCostElement element = array.get(issuer);
    64. 		if (element != null) {
    65. 			element.add(item);
    66. 		} else {
    67. 			element = new UserCostElement(issuer);
    68. 			element.add(item);
    69. 			array.put(element.getIssuer(), element);
    70. 		}
    71. 	}
    72.  
    73. 	/**
    74. 	 * 输出全部
    75. 	 * @return
    76. 	 */
    77. 	public List list() {
    78. 		return new ArrayList(array.values());
    79. 	}
    80. 	
    81. 	/**
    82. 	 * 查找一个成员
    83. 	 * @param siger 签名
    84. 	 * @return 返回匹配的成员
    85. 	 */
    86. 	public UserCostElement find(Siger siger) {
    87. 		return array.get(siger);
    88. 	}
    89.  
    90. 	/**
    91. 	 * 判断是空
    92. 	 * @return
    93. 	 */
    94. 	public boolean isEmpty() {
    95. 		return array.isEmpty();
    96. 	}
    97.  
    98. 	/**
    99. 	 * 有效单元数目
    100. 	 * @return 整数
    101. 	 */
    102. 	public int size() {
    103. 		return array.size();
    104. 	}
    105.  
    106. 	/* (non-Javadoc)
    107. 	 * @see com.laxcus.echo.product.EchoProduct#duplicate()
    108. 	 */
    109. 	@Override
    110. 	public CheckUserCostProduct duplicate() {
    111. 		return new CheckUserCostProduct(this);
    112. 	}
    113.  
    114. 	/* (non-Javadoc)
    115. 	 * @see com.laxcus.echo.product.EchoProduct#buildSuffix(com.laxcus.util.ClassWriter)
    116. 	 */
    117. 	@Override
    118. 	protected void buildSuffix(ClassWriter writer) {
    119. 		writer.writeInt(array.size());
    120. 		for (UserCostElement e : array.values()) {
    121. 			writer.writeObject(e);
    122. 		}
    123. 	}
    124.  
    125. 	/* (non-Javadoc)
    126. 	 * @see com.laxcus.echo.product.EchoProduct#resolveSuffix(com.laxcus.util.ClassReader)
    127. 	 */
    128. 	@Override
    129. 	protected void resolveSuffix(ClassReader reader) {
    130. 		int size = reader.readInt();
    131. 		for (int i = 0; i < size; i++) {
    132. 			UserCostElement element = new UserCostElement(reader);
    133. 			add(element.getIssuer(), element);
    134. 		}
    135. 	}
    136.  
    137. }

    Check User Cost类中的变量需要做点解释
    1. 节点类型，它的定义，可以查阅SiteTag类的源代码，目前是除Front节点和Watch节点之外，都能够支持，Front节点和Watch注册用户和系统管理员使用的节点，并不涉及计费问题。如果指定全部节点，那么all变量设成“true”。
    2. 用户签名，对应Siger类，它的本质就是一个SHA256签名。生成SHA256签名可以使用Laxkit类的doSiger方法来实现，doSiger方法的作用是把一个字符串转换成数字签名，输入是字符文本，输出是Siger类。
    3. 查询的命名。在Laxcus集群里，所有分布式计算工作都有一个名称，比如执行大型的分布式计算工作，对应CONDUCT名称，如果上传文件到云端，对应UPLOAD CLOUD FILE名称。依此类推。Naming的作用是忽略大小写，即一个 CONDUCT和conduct等价。如果置空，表示搜索与用户签名相关的全部命令
    4. 忽略的命令。它的作用和查询命名相反，即不查询某些命名。
    5. 开始、结束命令。这个参数是一个长整数值，使用转义函数来取得。

    比如我们想查询2022年12月1日到2022年12月2日两天，一个名为“Tubex“的用户记录，但是不包括CONDUCT命名，那么生成CheckUserCost的命令可以这样写：

    1. CheckUserCost cmd = new CheckUserCost();
    2. cmd.setAll(true);
    3. Siger siger = Laxkit.doSiger(“tubex”);
    4. cmd.addUser(siger);
    5. cmd.addExclude(new Naming("conduct"));
    6. long timestamp = CalendarGenerator.splitTimestamp("2022-12-1");
    7. cmd.setBeginTime(timestamp);
    8. timestamp = CalendarGenerator.splitTimestamp("2022-12-2");
    9. cmd.setEndTime(timestamp);

    二、Check User Cost命令的返回结果
    Check User Cost命令的返回结果对应CheckUserCostProduct类，CheckUserCostProduct继承自EchoProduct，保存所有检索结果。参数是基于用户签名和查询单元的TreeMap，CheckUserCostProduct类中包含了UserCostElement类，而UserCostElement类又包含UserCostItem类，这样就形成了“CheckUserCostProduct -> CheckUserCostElement -> UserCostItem”三级关系。因为CheckUserCostProduct类和UserCostElement类比较简单，咱们重点说说UserCostItem类。如果开发者想增加更多的计费元素，可以结合需求调用系统底层修改UserCostItem的源代码。

    UserCostItem源代码如下:

    1. public final class UserCostItem implements Classable, Cloneable, Serializable, Comparable {
    2.  
    3. 	private static final long serialVersionUID = -6293384810197643693L;
    4.  
    5. 	/** 节点类型 **/
    6. 	private byte family;
    7. 	
    8. 	/** 调用器编号 **/
    9. 	private long invokerId;
    10. 	
    11. 	/** 迭代次数 **/
    12. 	private int iterateIndex;
    13. 	
    14. 	/** 操作命名 **/
    15. 	private String command;
    16.  
    17. 	/** 开始和结束时间 **/
    18. 	private long initTime, endTime;
    19. 	
    20. 	/** 被线程调用，在EchoInvoker中的迭代时间 **/
    21. 	private long threadIterateTime;
    22. 	
    23. 	/** 接收数据流量 **/
    24. 	private long receiveFlows;
    25. 	
    26. 	/** 发送数据流量 **/
    27. 	private long sendFlows;
    28. 	
    29. 	/** 服务号，对应Command的slogan，全局唯一 **/
    30. 	private long slogan;
    31. 	
    32. 	/** 服务迭代编号，对应服务号，根据分布流程，从1开始逐次传递增加 **/
    33. 	private int sloganIndex;
    34. 	
    35. 	/** 命令级别，对应Command类 **/
    36. 	private byte priority;
    37. 	
    38. 	/**
    39. 	 * 构造默认的被刷新处理单元
    40. 	 */
    41. 	public UserCostItem() {
    42. 		super();
    43. 		family = 0;
    44. 		invokerId = 0;
    45. 		iterateIndex = 0;
    46. 		command = null;
    47. 		initTime = 0;
    48. 		endTime = 0;
    49. 		threadIterateTime = 0;
    50. 		receiveFlows = 0;
    51. 		sendFlows = 0;
    52. 		slogan = 0;
    53. 		sloganIndex = 0;
    54. 		priority = 0;
    55. 	}
    56.  
    57. 	/**
    58. 	 * 根据传入实例，生成用户消费单元的数据副本
    59. 	 * @param that UserCostItem实例
    60. 	 */
    61. 	private UserCostItem(UserCostItem that) {
    62. 		super();
    63. 		family = that.family;
    64. 		invokerId = that.invokerId;
    65. 		iterateIndex = that.iterateIndex;
    66. 		command = that.command;
    67. 		initTime = that.initTime;
    68. 		endTime = that.endTime;
    69. 		threadIterateTime = that.threadIterateTime;
    70. 		receiveFlows = that.receiveFlows;
    71. 		sendFlows = that.sendFlows;
    72. 		slogan = that.slogan;
    73. 		sloganIndex = that.sloganIndex;
    74. 		priority = that.priority;
    75. 	}
    76.  
    77. 	/**
    78. 	 * 从可类化数据读取器中用户消费单元
    79. 	 * @param reader 可类化数据读取器
    80. 	 */
    81. 	public UserCostItem(ClassReader reader) {
    82. 		this();
    83. 		resolve(reader);
    84. 	}
    85.  
    86. 	/**
    87. 	 * 设置节点类型
    88. 	 * @param who
    89. 	 */
    90. 	public void setFamily(byte who) {
    91. 		family = who;
    92. 	}
    93.  
    94. 	/**
    95. 	 * 返回节点类型
    96. 	 * @return
    97. 	 */
    98. 	public byte getFamily() {
    99. 		return family;
    100. 	}
    101.  
    102. 	/**
    103. 	 * 设置调用器编号
    104. 	 * @param id 编号
    105. 	 */
    106. 	public void setInvokerId(long id) {
    107. 		invokerId = id;
    108. 	}
    109.  
    110. 	/**
    111. 	 * 返回调用器编号
    112. 	 * @return 毫秒
    113. 	 */
    114. 	public long getInvokerId() {
    115. 		return invokerId;
    116. 	}
    117. 	
    118. 	/**
    119. 	 * 设置迭代次数
    120. 	 * @param i
    121. 	 */
    122. 	public void setIterateIndex(int i) {
    123. 		iterateIndex = i;
    124. 	}
    125.  
    126. 	/**
    127. 	 * 返回迭代次数
    128. 	 * @return
    129. 	 */
    130. 	public int getIterateIndex() {
    131. 		return iterateIndex;
    132. 	}
    133.  
    134. 	/**
    135. 	 * 设置命令
    136. 	 * @param s
    137. 	 */
    138. 	public void setCommand(String s) {
    139. 		command = s;
    140. 	}
    141.  
    142. 	/**
    143. 	 * 返回命令
    144. 	 * @return
    145. 	 */
    146. 	public String getCommand() {
    147. 		return command;
    148. 	}
    149.  
    150. 	/**
    151. 	 * 设置初始时间
    152. 	 * @param ms
    153. 	 */
    154. 	public void setInitTime(long ms) {
    155. 		initTime = ms;
    156. 	}
    157.  
    158. 	/**
    159. 	 * 返回初始时间
    160. 	 * @return
    161. 	 */
    162. 	public long getInitTime() {
    163. 		return initTime;
    164. 	}
    165.  
    166. 	/**
    167. 	 * 设置结束时间
    168. 	 * @param ms
    169. 	 */
    170. 	public void setEndTime(long ms) {
    171. 		endTime = ms;
    172. 	}
    173.  
    174. 	/**
    175. 	 * 返回结束时间
    176. 	 * @return
    177. 	 */
    178. 	public long getEndTime() {
    179. 		return endTime;
    180. 	}
    181.  
    182. 	/**
    183. 	 * 设置被线程调用，在EchoInvoker中的迭代时间
    184. 	 * @param ms 毫秒
    185. 	 */
    186. 	public void setThreadIterateTime(long ms) {
    187. 		threadIterateTime = ms;
    188. 	}
    189.  
    190. 	/**
    191. 	 * 返回被线程调用，在EchoInvoker中的迭代时间
    192. 	 * @return 毫秒
    193. 	 */
    194. 	public long getThreadIterateTime() {
    195. 		return threadIterateTime;
    196. 	}
    197. 	
    198. 	/**
    199. 	 * 设置接收数据流尺寸
    200. 	 * @param len 数据长度
    201. 	 */
    202. 	public void setReceiveFlows(long len) {
    203. 		receiveFlows = len;
    204. 	}
    205.  
    206. 	/**
    207. 	 * 返回接收数据流尺寸
    208. 	 * @return 数据长度
    209. 	 */
    210. 	public long getReceiveFlows() {
    211. 		return receiveFlows;
    212. 	}
    213. 	
    214. 	/**
    215. 	 * 设置发送数据流尺寸
    216. 	 * @param len 数据长度
    217. 	 */
    218. 	public void setSendFlows(long len) {
    219. 		sendFlows = len;
    220. 	}
    221.  
    222. 	/**
    223. 	 * 返回发送数据流尺寸
    224. 	 * @return 数据长度
    225. 	 */
    226. 	public long getSendFlows() {
    227. 		return sendFlows;
    228. 	}
    229. 	
    230. 	/**
    231. 	 * 设置服务号
    232. 	 * @param no 服务号
    233. 	 */
    234. 	public void setSlogan(long no) {
    235. 		slogan = no;
    236. 	}
    237.  
    238. 	/**
    239. 	 * 返回服务号
    240. 	 * @return 服务号
    241. 	 */
    242. 	public long getSlogan() {
    243. 		return slogan;
    244. 	}
    245.  
    246. 	/**
    247. 	 * 设置服务编号，不定义是0
    248. 	 * @param no 长整型
    249. 	 */
    250. 	public void setSloganIndex(int no) {
    251. 		sloganIndex = no;
    252. 	}
    253.  
    254. 	/**
    255. 	 * 返回服务编号
    256. 	 * @return 长整型
    257. 	 */
    258. 	public int getSloganIndex() {
    259. 		return sloganIndex;
    260. 	}
    261. 	
    262. 	/**
    263. 	 * 设置命令优先级
    264. 	 * @param no 命令优先级
    265. 	 */
    266. 	public void setPriority(byte no) {
    267. 		priority = no;
    268. 	}
    269.  
    270. 	/**
    271. 	 * 返回命令优先级
    272. 	 * @return 命令优先级
    273. 	 */
    274. 	public byte getPriority() {
    275. 		return priority;
    276. 	}
    277.  
    278. 	/**
    279. 	 * 生成当前实例的数据副本
    280. 	 * @return UserCostItem实例
    281. 	 */
    282. 	public UserCostItem duplicate() {
    283. 		return new UserCostItem(this);
    284. 	}
    285.  
    286. 	/*
    287. 	 * (non-Javadoc)
    288. 	 * @see java.lang.Object#clone()
    289. 	 */
    290. 	@Override
    291. 	public Object clone() {
    292. 		return duplicate();
    293. 	}
    294.  
    295. 	/*
    296. 	 * (non-Javadoc)
    297. 	 * @see java.lang.Object#hashCode()
    298. 	 */
    299. 	@Override
    300. 	public int hashCode() {
    301. 		return (int) ((invokerId >>> 32) ^ invokerId);
    302. 	}
    303.  
    304. 	/*
    305. 	 * (non-Javadoc)
    306. 	 * @see java.lang.Object#equals(java.lang.Object)
    307. 	 */
    308. 	@Override
    309. 	public boolean equals(Object that) {
    310. 		if (that == null || getClass() != that.getClass()) {
    311. 			return false;
    312. 		} else if (that == this) {
    313. 			return true;
    314. 		}
    315. 		// 比较
    316. 		return compareTo((UserCostItem ) that) == 0;
    317. 	}
    318.  
    319. 	/* (non-Javadoc)
    320. 	 * @see java.lang.Comparable#compareTo(java.lang.Object)
    321. 	 */
    322. 	@Override
    323. 	public int compareTo(UserCostItem that) {
    324. 		int ret = Laxkit.compareTo(family, that.family);
    325. 		if (ret == 0) {
    326. 			ret = Laxkit.compareTo(initTime, that.initTime);
    327. 		}
    328. 		if (ret == 0) {
    329. 			ret = Laxkit.compareTo(command, that.command, false);
    330. 		}
    331. 		if (ret == 0) {
    332. 			ret = Laxkit.compareTo(invokerId, that.invokerId);
    333. 		}
    334. 		return ret;
    335. 	}
    336. 	
    337. 	/* (non-Javadoc)
    338. 	 * @see com.laxcus.util.Classable#build(com.laxcus.util.ClassWriter)
    339. 	 */
    340. 	@Override
    341. 	public int build(ClassWriter writer) {
    342. 		int size = writer.size();
    343. 		buildSuffix(writer);
    344. 		return writer.size() - size;
    345. 	}
    346.  
    347. 	/* (non-Javadoc)
    348. 	 * @see com.laxcus.util.Classable#resolve(com.laxcus.util.ClassReader)
    349. 	 */
    350. 	@Override
    351. 	public int resolve(ClassReader reader) {
    352. 		int seek = reader.getSeek();
    353. 		resolveSuffix(reader);
    354. 		return reader.getSeek() - seek;
    355. 	}
    356.  
    357. 	/**
    358. 	 * 保存参数
    359. 	 * @param writer 
    360. 	 */
    361. 	protected void buildSuffix(ClassWriter writer) {
    362. 		writer.write(family);
    363. 		writer.writeLong(invokerId);
    364. 		writer.writeInt(iterateIndex);
    365. 		writer.writeString(command);
    366. 		
    367. 		writer.writeLong(initTime);
    368. 		writer.writeLong(endTime);
    369. 		writer.writeLong(threadIterateTime);
    370. 		
    371. 		writer.writeLong(receiveFlows);
    372. 		writer.writeLong(sendFlows);
    373. 		
    374. 		writer.writeLong(slogan);
    375. 		writer.writeInt(sloganIndex);
    376. 		writer.write(priority);
    377. 	}
    378.  
    379. 	/**
    380. 	 * 解析参数
    381. 	 * @param reader
    382. 	 */
    383. 	protected void resolveSuffix(ClassReader reader) {
    384. 		family = reader.read();
    385. 		invokerId = reader.readLong();
    386. 		iterateIndex = reader.readInt();
    387. 		command = reader.readString();
    388.  
    389. 		initTime = reader.readLong();
    390. 		endTime = reader.readLong();
    391. 		threadIterateTime = reader.readLong();
    392.  
    393. 		receiveFlows = reader.readLong();
    394. 		sendFlows = reader.readLong();
    395. 		
    396. 		slogan = reader.readLong();
    397. 		sloganIndex = reader.readInt();
    398. 		priority = reader.read();
    399. 	}
    400.  
    401. }

    下面说说UserCostItem比较重要的一些参数，通过这些参数，结束计费算法规则，你将最终得到你的计费
    1. family，节点类型，它对应SiteTag中的节点类型
    2. invokerId，调用器编号，也可以理解为进程编号。如果查阅系统日志，把它和节点类型结合，可以定位提取出调用器产生的运行记录。
    3. iterateIndex，迭代次数。Laxcus调用器存在被系统多次调用的可能，迭代编号是指它循环执行的次数。多次迭代之间，调用器会被系统悬挂起来，直到运行条件满足再次触发执行。迭代次数理论上最少1次，最多不限。
    4. command，操作命名，这个参数对应CheckUserCost中的includes参数。
    5. initTime, endTime，调用器的第一次启动时间和最后时间，两个参数的差值，就是调用器运行的总时间。如果以时间为标准进行计费，通过这个时间，结合计费结合，可以得出一个计费结果。
    6. receiveFlows，调用器在分布计算过程中，接收得到的数据流量。流量以字节为单位，这个参数通常是各种计费标准的主要依据之一。
    7. sendFlows，调用器在分布计算过程中，发送出去的数据流量。这个参数同样也是计费标准参照之一。
    8. slogan，服务号，是一个64位的整数值。它在分布计算执行前由系统赋值，保证运行环境全局唯一，如果分布计算过程中产生了分裂（类似Linux编程中的fork），这个服务号也会被继承下来。通过服务号，无论分布计算在多少个节点执行，其间发生了多少次分裂，都可以把它们记录下来，然后反向推导出分布计算执行的先后顺序和分布执行情况。如果有需要，在这个基础上，进一步形成可视化的分布计算执行流程图表，必要时提供给用户，做为分布计算的佐证之一。
    9. sloganIndex，服务迭代编号，即关联服务号的调用器，在分布式计算过程中发生了分裂，就在这个编号上做一个加1的操作。服务迭代编号从1开始，随着调用器分裂逐层传递增加。
    10. priority，操作执行优先级，前一篇说过，用户的分布业务，有四个级别，从大到小分为MAX级，NORMAL级，MINI级，NONE级。调整用户优先级由管理员来操作，默认情况下，所有用户都是NONE级，即不定义优先级。获得更高优先级应用业务，总是比低于它一级的应用业务，优先取得Laxcus计算机集群的资源，优先取得执行权限进行分布计算工作。所以priority也是一个计费参照之一，更高优先级的业务，在享受优先处理权利时，也应该付出更多的消费金额。

    下面是UserCostElement类和CheckUserCostProduct类的源程序代码，因为比较简单，就不单独说明了。

    1. public final class UserCostElement implements Classable, Cloneable, Serializable, Comparable {
    2.  
    3. 	private static final long serialVersionUID = 5651643178030182283L;
    4.  
    5. 	/** 用户签名 **/
    6. 	private Siger issuer;
    7.  
    8. 	/** 未使用容量 **/
    9. 	private TreeSet array = new TreeSet();
    10. 	
    11. 	/**
    12. 	 * 构造默认的用户资源消耗成员
    13. 	 */
    14. 	public UserCostElement() {
    15. 		super();
    16. 	}
    17.  
    18. 	/**
    19. 	 * 构造用户资源消耗成员
    20. 	 * @param issuer 用户签名
    21. 	 */
    22. 	public UserCostElement(Siger issuer) {
    23. 		this();
    24. 		setIssuer(issuer);
    25. 	}
    26. 	
    27. 	/**
    28. 	 * 根据传入实例，生成用户资源消耗成员的数据副本
    29. 	 * @param that UserCostElement实例
    30. 	 */
    31. 	private UserCostElement(UserCostElement that) {
    32. 		super();
    33. 		issuer = that.issuer;
    34. 		array.addAll(that.array);
    35. 	}
    36.  
    37. 	/**
    38. 	 * 从可类化数据读取器中用户资源消耗成员
    39. 	 * @param reader 可类化数据读取器
    40. 	 */
    41. 	public UserCostElement(ClassReader reader) {
    42. 		this();
    43. 		resolve(reader);
    44. 	}
    45.  
    46. 	/**
    47. 	 * 设置用户签名
    48. 	 * @param who 签名
    49. 	 */
    50. 	public void setIssuer(Siger who) {
    51. 		issuer = who;
    52. 	}
    53.  
    54. 	/**
    55. 	 * 返回用户签名
    56. 	 * @return 签名
    57. 	 */
    58. 	public Siger getIssuer() {
    59. 		return issuer;
    60. 	}
    61.  
    62. 	/**
    63. 	 * 加一个单元
    64. 	 * @param item
    65. 	 * @return
    66. 	 */
    67. 	public boolean add(UserCostItem item) {
    68. 		if (item != null) {
    69. 			return array.add(item);
    70. 		}
    71. 		return false;
    72. 	}
    73. 	
    74. 	/**
    75. 	 * 增加一批单元
    76. 	 * @param a
    77. 	 * @return
    78. 	 */
    79. 	public int addAll(Collection a) {
    80. 		int size = array.size();
    81. 		if (a != null) {
    82. 			for (UserCostItem item : a) {
    83. 				add(item);
    84. 			}
    85. 		}
    86. 		return array.size() - size;
    87. 	}
    88.  
    89. 	/**
    90. 	 * 返回单元
    91. 	 * @return
    92. 	 */
    93. 	public List list() {
    94. 		return new ArrayList(array);
    95. 	}
    96.  
    97. 	/**
    98. 	 * 全部成员
    99. 	 * @return
    100. 	 */
    101. 	public int size() {
    102. 		return array.size();
    103. 	}
    104. 	
    105. 	/**
    106. 	 * 生成当前实例的数据副本
    107. 	 * @return UserCostElement实例
    108. 	 */
    109. 	public UserCostElement duplicate() {
    110. 		return new UserCostElement(this);
    111. 	}
    112.  
    113. 	/*
    114. 	 * (non-Javadoc)
    115. 	 * @see java.lang.Object#clone()
    116. 	 */
    117. 	@Override
    118. 	public Object clone() {
    119. 		return duplicate();
    120. 	}
    121.  
    122. 	/*
    123. 	 * (non-Javadoc)
    124. 	 * @see java.lang.Object#equals(java.lang.Object)
    125. 	 */
    126. 	@Override
    127. 	public boolean equals(Object that) {
    128. 		if (that == null || getClass() != that.getClass()) {
    129. 			return false;
    130. 		} else if (that == this) {
    131. 			return true;
    132. 		}
    133. 		// 比较
    134. 		return compareTo((UserCostElement) that) == 0;
    135. 	}
    136.  
    137. 	/* (non-Javadoc)
    138. 	 * @see java.lang.Comparable#compareTo(java.lang.Object)
    139. 	 */
    140. 	@Override
    141. 	public int compareTo(UserCostElement that) {
    142. 		if (that == null) {
    143. 			return 1;
    144. 		}
    145. 		// 比较参数
    146. 		return Laxkit.compareTo(issuer, that.issuer);
    147. 	}
    148.  
    149. 	/* (non-Javadoc)
    150. 	 * @see com.laxcus.util.Classable#build(com.laxcus.util.ClassWriter)
    151. 	 */
    152. 	@Override
    153. 	public int build(ClassWriter writer) {
    154. 		int size = writer.size();
    155. 		buildSuffix(writer);
    156. 		return writer.size() - size;
    157. 	}
    158.  
    159. 	/* (non-Javadoc)
    160. 	 * @see com.laxcus.util.Classable#resolve(com.laxcus.util.ClassReader)
    161. 	 */
    162. 	@Override
    163. 	public int resolve(ClassReader reader) {
    164. 		int seek = reader.getSeek();
    165. 		resolveSuffix(reader);
    166. 		return reader.getSeek() - seek;
    167. 	}
    168.  
    169. 	/**
    170. 	 * 保存参数
    171. 	 * @param writer 
    172. 	 */
    173. 	protected void buildSuffix(ClassWriter writer) {
    174. 		writer.writeObject(issuer);
    175. 		int size = array.size();
    176. 		writer.writeInt(size);
    177. 		for (UserCostItem e : array) {
    178. 			writer.writeObject(e);
    179. 		}
    180. 	}
    181.  
    182. 	/**
    183. 	 * 解析参数
    184. 	 * @param reader
    185. 	 */
    186. 	protected void resolveSuffix(ClassReader reader) {
    187. 		issuer = new Siger(reader);
    188. 		int size = reader.readInt();
    189. 		for (int i = 0; i < size; i++) {
    190. 			UserCostItem item = new UserCostItem(reader);
    191. 			add(item);
    192. 		}
    193. 	}
    194.  
    195. }
    1. public class CheckUserCostProduct extends EchoProduct {
    2.  
    3. 	private static final long serialVersionUID = 3146106632408001248L;
    4.  
    5. 	/** 用户签名 -> 单元 **/
    6. 	private Map array = new TreeMap();
    7.  
    8. 	/**
    9. 	 * 构造默认的服务器系统信息检测结果
    10. 	 */
    11. 	public CheckUserCostProduct() {
    12. 		super();
    13. 	}
    14.  
    15. 	/**
    16. 	 * 从可类化数据读取器解析服务器系统信息检测结果
    17. 	 * @param reader 可类化数据读取器
    18. 	 */
    19. 	public CheckUserCostProduct(ClassReader reader) {
    20. 		this();
    21. 		resolve(reader);
    22. 	}
    23.  
    24. 	/**
    25. 	 * 构造服务器系统信息检测结果的数据副本
    26. 	 * @param that CheckUserCostProduct实例
    27. 	 */
    28. 	private CheckUserCostProduct(CheckUserCostProduct that) {
    29. 		super(that);
    30. 		array.putAll(that.array);
    31. 	}
    32.  
    33. 	/**
    34. 	 * 加一个
    35. 	 * @param product
    36. 	 */
    37. 	public void add(CheckUserCostProduct product) {
    38. 		for (UserCostElement element : product.array.values()) {
    39. 			add(element.getIssuer(), element);
    40. 		}
    41. 	}
    42.  
    43. 	/**
    44. 	 * 加全部
    45. 	 * @param issuer 用户签名
    46. 	 * @param element 成员
    47. 	 */
    48. 	public void add(Siger issuer, UserCostElement element) {
    49. 		UserCostElement that = array.get(issuer);
    50. 		if (that != null) {
    51. 			that.addAll(element.list());
    52. 		} else {
    53. 			array.put(issuer, element);
    54. 		}
    55. 	}
    56.  
    57. 	/**
    58. 	 * 加一个单元
    59. 	 * @param issuer 签名
    60. 	 * @param item 成员
    61. 	 */
    62. 	public void add(Siger issuer, UserCostItem item) {
    63. 		UserCostElement element = array.get(issuer);
    64. 		if (element != null) {
    65. 			element.add(item);
    66. 		} else {
    67. 			element = new UserCostElement(issuer);
    68. 			element.add(item);
    69. 			array.put(element.getIssuer(), element);
    70. 		}
    71. 	}
    72.  
    73. 	/**
    74. 	 * 输出全部
    75. 	 * @return
    76. 	 */
    77. 	public List list() {
    78. 		return new ArrayList(array.values());
    79. 	}
    80. 	
    81. 	/**
    82. 	 * 查找一个成员
    83. 	 * @param siger 签名
    84. 	 * @return 返回匹配的成员
    85. 	 */
    86. 	public UserCostElement find(Siger siger) {
    87. 		return array.get(siger);
    88. 	}
    89.  
    90. 	/**
    91. 	 * 判断是空
    92. 	 * @return
    93. 	 */
    94. 	public boolean isEmpty() {
    95. 		return array.isEmpty();
    96. 	}
    97.  
    98. 	/**
    99. 	 * 有效单元数目
    100. 	 * @return 整数
    101. 	 */
    102. 	public int size() {
    103. 		return array.size();
    104. 	}
    105.  
    106. 	/* (non-Javadoc)
    107. 	 * @see com.laxcus.echo.product.EchoProduct#duplicate()
    108. 	 */
    109. 	@Override
    110. 	public CheckUserCostProduct duplicate() {
    111. 		return new CheckUserCostProduct(this);
    112. 	}
    113.  
    114. 	/* (non-Javadoc)
    115. 	 * @see com.laxcus.echo.product.EchoProduct#buildSuffix(com.laxcus.util.ClassWriter)
    116. 	 */
    117. 	@Override
    118. 	protected void buildSuffix(ClassWriter writer) {
    119. 		writer.writeInt(array.size());
    120. 		for (UserCostElement e : array.values()) {
    121. 			writer.writeObject(e);
    122. 		}
    123. 	}
    124.  
    125. 	/* (non-Javadoc)
    126. 	 * @see com.laxcus.echo.product.EchoProduct#resolveSuffix(com.laxcus.util.ClassReader)
    127. 	 */
    128. 	@Override
    129. 	protected void resolveSuffix(ClassReader reader) {
    130. 		int size = reader.readInt();
    131. 		for (int i = 0; i < size; i++) {
    132. 			UserCostElement element = new UserCostElement(reader);
    133. 			add(element.getIssuer(), element);
    134. 		}
    135. 	}
    136.  
    137. }

    最后，我们需要把它们整合起来，编写成计算机程序，投递给Laxcus计算机集群来处理，这里的代码就非常简单，只有以下几步：
    1.生成命令 （这步上面已经演示）
    2.生成一个异步监听接口，和命令一起，交给命令分派接口处理。
    3.调用Laxcus分布式操作系统DSDK中的命令分派接口，把命令和异步监听器投递给它，DSDK代让命令分派接口投递给Laxcus集群处理。
    4.异步监听接口收到反馈结果，解析CheckUsetCostProduct中的参数，结合计费算法，得出计费结果。
    这些步骤集合起来，就是下面这样一段代码：

    1. class CheckUserCostProductListener implements ProductListener {
    2.  
    3.         @Override
    4.         public void push(Object e) {
    5.             boolean success = (e != null && e.getClass() == CheckUserCostProduct.class);
    6.             if (!success) {
    7.                 // 不成功，做出错的处理
    8.                 return;
    9.             }
    10.             // 成功，提取返回参数，结束计费算法，得出计费结果
    11.         }
    12.     }
    13.  
    14. 	// 1. 生成命令
    15. 	CheckUserCost cmd = new CheckUserCost();
    16. 	cmd.setAll(true);
    17. 	Siger siger = Laxkit.doSiger("tubex");
    18. 	cmd.addUser(siger);
    19. 	cmd.addExclude(new Naming("conduct"));
    20. 	long timestamp = CalendarGenerator.splitTimestamp("2022-12-1");
    21. 	cmd.setBeginTime(timestamp);
    22. 	timestamp = CalendarGenerator.splitTimestamp("2022-12-2");
    23. 	cmd.setEndTime(timestamp);
    24. 	// 2. 生成异步监听器，返回结果将投递给它处理
    25. 	CheckUserCostProductListener listner = new CheckUserCostProductListener();
    26. 	// 3. 生成交互适配器，在命令投递进入集群前出现错误，将由它来处理和显示
    27. 	MeetDisplayAdapter adapter = new MeetDisplayAdapter(listener);
    28. 	// 4. 调用系统API，把命令投递给集群处理
    29. 	CommandDispatcher dispatcher = PlatformKit.findListener(CommandDispatcher.class);
    30. 	dispatcher.submit(cmd, true, new CommandAuditorAdapter(), adapter);

    上面这些代码通过编译，做成一个Laxcus分布式操作系统的应用软件，就可以运行了。
    另外，如果是在Laxcus管理员桌面环境以外运行，那么就要把DSDK集成起来，并且连接进入Laxcus集群，才能执行上面的操作。
    至此，一个简单的Laxcus云服务计费系统设计完成。有兴趣不妨去试试，把它“润”起来，看看你的Laxcus云服务有多少人在使用，他们在执行什么工作，消耗了多少计算机资源，也或者看看有什么改进工作要做吧。

  • 相关阅读:
    【TypeScript】-- TS之面向对象
    STL-stack、queue和priority_queue的模拟实现
    计算机毕业设计之java+ssm美味厨房点餐系统
    物联网AI MicroPython传感器学习 之 TEA5767 FM收音机模块
    东盟与中日韩（10+3）中小企业人工智能产业论坛
    【JavaScript】 一万字 JavaScript 笔记（详细讲解 + 代码演示 + 图解）
    农林种植类VR虚拟仿真实验教学整体解决方案
    卖出看涨期权的例子：Selling a Call Option
    python逆向基础流程（纯小白教程）
    【Java 基础篇】Java transient 关键字详解：对象序列化与非序列化字段
  • 原文地址：https://blog.csdn.net/laxcus/article/details/128186727