【Zookeeper】源码分析之请求处理链（二）
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了【Zookeeper】源码分析之请求处理链（二），小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含19540字，纯文字阅读大概需要28分钟。
内容图文
一、前言
前面学习了请求处理链的RequestProcessor父类，接着学习PrepRequestProcessor，其通常是请求处理链的第一个处理器。
二、ZooKeeper源码分析
2.1 类的继承关系
public
class PrepRequestProcessor extends Thread implements RequestProcessor {}
说明：可以看到PrepRequestProcessor继承了Thread类并实现了RequestProcessor接口，表示其可以作为线程使用。
2.2 类的属性
public
class PrepRequestProcessor extends Thread implements RequestProcessor {
// 日志记录器privatestaticfinal Logger LOG = LoggerFactory.getLogger(PrepRequestProcessor.class);
// 是否跳过ACL,需查看系统配置staticboolean skipACL;
static {
skipACL = System.getProperty("zookeeper.skipACL", "no").equals("yes");
if (skipACL) {
LOG.info("zookeeper.skipACL==\"yes\", ACL checks will be skipped");
}
}
/**
* this is only for testing purposes.
* should never be useed otherwise
*/// 仅用作测试使用privatestaticboolean failCreate = false;
// 已提交请求队列
LinkedBlockingQueue<Request> submittedRequests = new LinkedBlockingQueue<Request>();
// 下个处理器 RequestProcessor nextProcessor;
// Zookeeper服务器 ZooKeeperServer zks;
}
说明：类的核心属性有submittedRequests和nextProcessor，前者表示已经提交的请求，而后者表示提交的下个处理器。
2.3 类的构造函数
public
PrepRequestProcessor(ZooKeeperServer zks,
RequestProcessor nextProcessor) {
//
调用父类Thread构造函数
super("ProcessThread(sid:" + zks.getServerId()
+ " cport:" + zks.getClientPort() + "):");
// 类属性赋值this.nextProcessor = nextProcessor;
this.zks = zks;
}
说明：该构造函数首先会调用父类Thread的构造函数，然后利用构造函数参数给nextProcessor和zks赋值。
2.4 核心函数分析
1. run函数
public
void
run() {
try
{
while (true) { // 无限循环
// 从队列中取出一个请求
Request request = submittedRequests.take();
//long traceMask = ZooTrace.CLIENT_REQUEST_TRACE_MASK;
if (request.type == OpCode.ping) { // 请求类型为PING
traceMask = ZooTrace.CLIENT_PING_TRACE_MASK;
}
if (LOG.isTraceEnabled()) { // 是否可追踪
ZooTrace.logRequest(LOG, traceMask, ‘P‘, request, "");
}
if (Request.requestOfDeath == request) { // 在关闭处理器之后，会添加requestOfDeath，表示关闭后不再处理请求break;
}
// 调用pRequest函数 pRequest(request);
}
} catch (InterruptedException e) { // 中断异常
LOG.error("Unexpected interruption", e);
} catch (RequestProcessorException e) { // 请求处理异常if (e.getCause() instanceof XidRolloverException) {
LOG.info(e.getCause().getMessage());
}
LOG.error("Unexpected exception", e);
} catch (Exception e) { // 其他异常
LOG.error("Unexpected exception", e);
}
LOG.info("PrepRequestProcessor exited loop!");
}
说明：run函数是对Thread类run函数的重写，其核心逻辑相对简单，即不断从队列中取出request进行处理，其会调用pRequest函数，其源码如下
protected
void pRequest(Request request) throws RequestProcessorException {
// LOG.info("Prep>>> cxid = " + request.cxid + " type = " +
// request.type + " id = 0x" + Long.toHexString(request.sessionId));
// 将请求的hdr和txn设置为null
request.hdr = null;
request.txn = null;
try {
switch (request.type) { // 确定请求类型case OpCode.create: // 创建节点请求
// 新生创建节点请求
CreateRequest createRequest = new CreateRequest();
// 处理请求
pRequest2Txn(request.type, zks.getNextZxid(), request, createRequest, true);
break;
case OpCode.delete: // 删除节点请求
// 新生删除节点请求
DeleteRequest deleteRequest = new DeleteRequest();
// 处理请求
pRequest2Txn(request.type, zks.getNextZxid(), request, deleteRequest, true);
break;
case OpCode.setData: // 设置数据请求
// 新生设置数据请求
SetDataRequest setDataRequest = new SetDataRequest();
// 处理请求
pRequest2Txn(request.type, zks.getNextZxid(), request, setDataRequest, true);
break;
case OpCode.setACL: // 设置ACL请求
// 新生设置ACL请求
SetACLRequest setAclRequest = new SetACLRequest();
// 处理请求
pRequest2Txn(request.type, zks.getNextZxid(), request, setAclRequest, true);
break;
case OpCode.check: // 检查版本请求
// 新生检查版本请求
CheckVersionRequest checkRequest = new CheckVersionRequest();
// 处理请求
pRequest2Txn(request.type, zks.getNextZxid(), request, checkRequest, true);
break;
case OpCode.multi: // 多重请求
// 新生多重请求
MultiTransactionRecord multiRequest = new MultiTransactionRecord();
try {
// 将ByteBuffer转化为Record ByteBufferInputStream.byteBuffer2Record(request.request, multiRequest);
} catch(IOException e) {
// 出现异常则重新生成Txn头
request.hdr = new TxnHeader(request.sessionId, request.cxid, zks.getNextZxid(),
zks.getTime(), OpCode.multi);
throw e;
}
List<Txn> txns = new ArrayList<Txn>();
//Each op in a multi-op must have the same zxid!long zxid = zks.getNextZxid();
KeeperException ke = null;
//Store off current pending change records in case we need to rollback
// 存储当前挂起的更改记录，以防我们需要回滚
HashMap<String, ChangeRecord> pendingChanges = getPendingChanges(multiRequest);
int index = 0;
for(Op op: multiRequest) { // 遍历请求
Record subrequest = op.toRequestRecord() ;
/* If we‘ve already failed one of the ops, don‘t bother
* trying the rest as we know it‘s going to fail and it
* would be confusing in the logfiles.
*/if (ke != null) { // 发生了异常 request.hdr.setType(OpCode.error);
request.txn = new ErrorTxn(Code.RUNTIMEINCONSISTENCY.intValue());
}
/* Prep the request and convert to a Txn */else { // 未发生异常try {
// 将Request转化为Txn
pRequest2Txn(op.getType(), zxid, request, subrequest, false);
} catch (KeeperException e) { // 转化发生异常if (ke == null) {
ke = e;
}
// 设置请求头的类型 request.hdr.setType(OpCode.error);
// 设置请求的Txn
request.txn = new ErrorTxn(e.code().intValue());
LOG.info("Got user-level KeeperException when processing "
+ request.toString() + " aborting remaining multi ops."
+ " Error Path:" + e.getPath()
+ " Error:" + e.getMessage());
// 设置异常 request.setException(e);
/* Rollback change records from failed multi-op */// 从多重操作中回滚更改记录 rollbackPendingChanges(zxid, pendingChanges);
}
}
//FIXME: I don‘t want to have to serialize it here and then
// immediately deserialize in next processor. But I‘m
// not sure how else to get the txn stored into our list.
// 序列化
ByteArrayOutputStream baos = new ByteArrayOutputStream();
BinaryOutputArchive boa = BinaryOutputArchive.getArchive(baos);
request.txn.serialize(boa, "request") ;
ByteBuffer bb = ByteBuffer.wrap(baos.toByteArray());
txns.add(new Txn(request.hdr.getType(), bb.array()));
index++;
}
// 给请求头赋值
request.hdr = new TxnHeader(request.sessionId, request.cxid, zxid, zks.getTime(), request.type);
// 设置请求的Txn
request.txn = new MultiTxn(txns);
break;
//create/close session don‘t require request recordcase OpCode.createSession: // 创建会话请求case OpCode.closeSession: // 关闭会话请求
pRequest2Txn(request.type, zks.getNextZxid(), request, null, true);
break;
//All the rest don‘t need to create a Txn - just verify session
// 所有以下请求只需验证会话即可case OpCode.sync:
case OpCode.exists:
case OpCode.getData:
case OpCode.getACL:
case OpCode.getChildren:
case OpCode.getChildren2:
case OpCode.ping:
case OpCode.setWatches:
zks.sessionTracker.checkSession(request.sessionId,
request.getOwner());
break;
}
} catch (KeeperException e) { // 发生KeeperException异常if (request.hdr != null) {
request.hdr.setType(OpCode.error);
request.txn = new ErrorTxn(e.code().intValue());
}
LOG.info("Got user-level KeeperException when processing "
+ request.toString()
+ " Error Path:" + e.getPath()
+ " Error:" + e.getMessage());
request.setException(e);
} catch (Exception e) { // 其他异常
// log at error level as we are returning a marshalling
// error to the user
LOG.error("Failed to process " + request, e);
StringBuilder sb = new StringBuilder();
ByteBuffer bb = request.request;
if(bb != null){
bb.rewind();
while (bb.hasRemaining()) {
sb.append(Integer.toHexString(bb.get() & 0xff));
}
} else {
sb.append("request buffer is null");
}
LOG.error("Dumping request buffer: 0x" + sb.toString());
if (request.hdr != null) {
request.hdr.setType(OpCode.error);
request.txn = new ErrorTxn(Code.MARSHALLINGERROR.intValue());
}
}
// 给请求的zxid赋值
request.zxid = zks.getZxid();
// 传递给下个处理器进行处理 nextProcessor.processRequest(request);
}
说明：pRequest会确定请求类型，并根据请求类型不同生成不同的请求对象，然后调用pRequest2Txn函数，其源码如下
protected
void pRequest2Txn(int type, long zxid, Request request, Record record, boolean deserialize)
throws KeeperException, IOException, RequestProcessorException
{
// 新生事务头
request.hdr = new TxnHeader(request.sessionId, request.cxid, zxid,
zks.getTime(), type);
switch (type) { // 确定类型case OpCode.create: // 创建节点操作
// 检查会话，检查会话持有者是否为该owner zks.sessionTracker.checkSession(request.sessionId, request.getOwner());
// 向下转化
CreateRequest createRequest = (CreateRequest)record;
if(deserialize) // 反序列化，将ByteBuffer转化为Record ByteBufferInputStream.byteBuffer2Record(request.request, createRequest);
// 获取节点路径
String path = createRequest.getPath();
// 索引最后一个‘/‘int lastSlash = path.lastIndexOf(‘/‘);
if (lastSlash == -1 || path.indexOf(‘\0‘) != -1 || failCreate) { // 判断最后一个‘/‘是否合法
LOG.info("Invalid path " + path + " with session 0x" +
Long.toHexString(request.sessionId));
thrownew KeeperException.BadArgumentsException(path);
}
// 移除重复的ACL项
List<ACL> listACL = removeDuplicates(createRequest.getAcl());
if (!fixupACL(request.authInfo, listACL)) { // 确保ACL列表不为空thrownew KeeperException.InvalidACLException(path);
}
// 提取节点的父节点路径
String parentPath = path.substring(0, lastSlash);
// 获取父节点的Record
ChangeRecord parentRecord = getRecordForPath(parentPath);
// 检查ACL列表 checkACL(zks, parentRecord.acl, ZooDefs.Perms.CREATE,
request.authInfo);
// 获取父节点的Record的子节点版本号int parentCVersion = parentRecord.stat.getCversion();
// 获取创建模式
CreateMode createMode =
CreateMode.fromFlag(createRequest.getFlags());
if (createMode.isSequential()) { // 顺序模式
// 在路径后添加一串数字
path = path + String.format(Locale.ENGLISH, "%010d", parentCVersion);
}
try {
// 验证路径 PathUtils.validatePath(path);
} catch(IllegalArgumentException ie) {
LOG.info("Invalid path " + path + " with session 0x" +
Long.toHexString(request.sessionId));
thrownew KeeperException.BadArgumentsException(path);
}
try {
if (getRecordForPath(path) != null) {
thrownew KeeperException.NodeExistsException(path);
}
} catch (KeeperException.NoNodeException e) {
// ignore this one }
// 父节点是否为临时节点boolean ephemeralParent = parentRecord.stat.getEphemeralOwner() != 0;
if (ephemeralParent) { // 父节点为临时节点thrownew KeeperException.NoChildrenForEphemeralsException(path);
}
// 新的子节点版本号int newCversion = parentRecord.stat.getCversion()+1;
// 新生事务
request.txn = new CreateTxn(path, createRequest.getData(),
listACL,
createMode.isEphemeral(), newCversion);
//
StatPersisted s = new StatPersisted();
if (createMode.isEphemeral()) { // 创建节点为临时节点 s.setEphemeralOwner(request.sessionId);
}
// 拷贝
parentRecord = parentRecord.duplicate(request.hdr.getZxid());
// 子节点数量加1
parentRecord.childCount++;
// 设置新的子节点版本号 parentRecord.stat.setCversion(newCversion);
// 将parentRecord添加至outstandingChanges和outstandingChangesForPath中 addChangeRecord(parentRecord);
// 将新生成的ChangeRecord(包含了StatPersisted信息)添加至outstandingChanges和outstandingChangesForPath中
addChangeRecord(new ChangeRecord(request.hdr.getZxid(), path, s,
0, listACL));
break;
case OpCode.delete: // 删除节点请求
// 检查会话，检查会话持有者是否为该owner zks.sessionTracker.checkSession(request.sessionId, request.getOwner());
// 向下转化为DeleteRequest
DeleteRequest deleteRequest = (DeleteRequest)record;
if(deserialize) // 反序列化，将ByteBuffer转化为Record ByteBufferInputStream.byteBuffer2Record(request.request, deleteRequest);
// 获取节点路径
path = deleteRequest.getPath();
// 索引最后一个‘/‘
lastSlash = path.lastIndexOf(‘/‘);
if (lastSlash == -1 || path.indexOf(‘\0‘) != -1
|| zks.getZKDatabase().isSpecialPath(path)) {
thrownew KeeperException.BadArgumentsException(path);
}
// 提取节点的父节点路径
parentPath = path.substring(0, lastSlash);
// 获取父节点的Record
parentRecord = getRecordForPath(parentPath);
// 获取节点的Record
ChangeRecord nodeRecord = getRecordForPath(path);
// 检查ACL列表 checkACL(zks, parentRecord.acl, ZooDefs.Perms.DELETE,
request.authInfo);
// 获取版本int version = deleteRequest.getVersion();
if (version != -1 && nodeRecord.stat.getVersion() != version) {
thrownew KeeperException.BadVersionException(path);
}
if (nodeRecord.childCount > 0) { // 该结点有子节点，抛出异常thrownew KeeperException.NotEmptyException(path);
}
// 新生删除事务
request.txn = new DeleteTxn(path);
// 拷贝父节点Record
parentRecord = parentRecord.duplicate(request.hdr.getZxid());
// 父节点的孩子节点数目减1
parentRecord.childCount--;
//// 将parentRecord添加至outstandingChanges和outstandingChangesForPath中 addChangeRecord(parentRecord);
// 将新生成的ChangeRecord(包含了StatPersisted信息)添加至outstandingChanges和outstandingChangesForPath中
addChangeRecord(new ChangeRecord(request.hdr.getZxid(), path,
null, -1, null));
break;
case OpCode.setData: // 设置数据请求
// 检查会话，检查会话持有者是否为该owner zks.sessionTracker.checkSession(request.sessionId, request.getOwner());
// 向下转化
SetDataRequest setDataRequest = (SetDataRequest)record;
if(deserialize) // 反序列化，将ByteBuffer转化为Record ByteBufferInputStream.byteBuffer2Record(request.request, setDataRequest);
// 获取节点路径
path = setDataRequest.getPath();
// 获取节点的Record
nodeRecord = getRecordForPath(path);
// 检查ACL列表 checkACL(zks, nodeRecord.acl, ZooDefs.Perms.WRITE,
request.authInfo);
// 获取请求的版本号
version = setDataRequest.getVersion();
// 节点当前版本号int currentVersion = nodeRecord.stat.getVersion();
if (version != -1 && version != currentVersion) {
thrownew KeeperException.BadVersionException(path);
}
// 新生版本号
version = currentVersion + 1;
// 新生设置数据事务
request.txn = new SetDataTxn(path, setDataRequest.getData(), version);
// 拷贝
nodeRecord = nodeRecord.duplicate(request.hdr.getZxid());
// 设置版本号 nodeRecord.stat.setVersion(version);
// 将nodeRecord添加至outstandingChanges和outstandingChangesForPath中 addChangeRecord(nodeRecord);
break;
case OpCode.setACL: // 设置ACL请求
// 检查会话，检查会话持有者是否为该owner zks.sessionTracker.checkSession(request.sessionId, request.getOwner());
// 向下转化
SetACLRequest setAclRequest = (SetACLRequest)record;
if(deserialize) // 反序列化，将ByteBuffer转化为Record ByteBufferInputStream.byteBuffer2Record(request.request, setAclRequest);
// 获取节点路径
path = setAclRequest.getPath();
// 移除重复的ACL项
listACL = removeDuplicates(setAclRequest.getAcl());
if (!fixupACL(request.authInfo, listACL)) { // 确保ACL列表不为空thrownew KeeperException.InvalidACLException(path);
}
// 获取节点的Record
nodeRecord = getRecordForPath(path);
// 检查ACL列表 checkACL(zks, nodeRecord.acl, ZooDefs.Perms.ADMIN,
request.authInfo);
// 获取版本号
version = setAclRequest.getVersion();
// 当前版本号
currentVersion = nodeRecord.stat.getAversion();
if (version != -1 && version != currentVersion) { // 验证版本号thrownew KeeperException.BadVersionException(path);
}
// 新生版本号
version = currentVersion + 1;
// 设置请求事务
request.txn = new SetACLTxn(path, listACL, version);
// 拷贝
nodeRecord = nodeRecord.duplicate(request.hdr.getZxid());
// 设置ACL版本号 nodeRecord.stat.setAversion(version);
// 将nodeRecord添加至outstandingChanges和outstandingChangesForPath中 addChangeRecord(nodeRecord);
break;
case OpCode.createSession: // 创建会话请求
// 将request缓冲区rewind request.request.rewind();
// 获取缓冲区大小int to = request.request.getInt();
// 创建会话事务
request.txn = new CreateSessionTxn(to);
// 再次将request缓冲区rewind request.request.rewind();
// 添加session zks.sessionTracker.addSession(request.sessionId, to);
// 设置会话的owner zks.setOwner(request.sessionId, request.getOwner());
break;
case OpCode.closeSession: // 关闭会话请求
// We don‘t want to do this check since the session expiration thread
// queues up this operation without being the session owner.
// this request is the last of the session so it should be ok
//zks.sessionTracker.checkSession(request.sessionId, request.getOwner());
// 获取会话所有的临时节点
HashSet<String> es = zks.getZKDatabase()
.getEphemerals(request.sessionId);
synchronized (zks.outstandingChanges) {
for (ChangeRecord c : zks.outstandingChanges) { // 遍历outstandingChanges队列的所有ChangeRecordif (c.stat == null) { // 若其stat为null
// Doing a delete
// 则从es中移除其路径 es.remove(c.path);
} elseif (c.stat.getEphemeralOwner() == request.sessionId) { // 若临时节点属于该会话
// 则将其路径添加至es中 es.add(c.path);
}
}
for (String path2Delete : es) { // 遍历es
// 新生ChangeRecord，并将其添加至outstandingChanges和outstandingChangesForPath中
addChangeRecord(new ChangeRecord(request.hdr.getZxid(),
path2Delete, null, 0, null));
}
// 关闭会话 zks.sessionTracker.setSessionClosing(request.sessionId);
}
LOG.info("Processed session termination for sessionid: 0x"
+ Long.toHexString(request.sessionId));
break;
case OpCode.check: // 检查请求
// 检查会话，检查会话持有者是否为该owner zks.sessionTracker.checkSession(request.sessionId, request.getOwner());
// 向下转化
CheckVersionRequest checkVersionRequest = (CheckVersionRequest)record;
if(deserialize) // 反序列化，将ByteBuffer转化为Record ByteBufferInputStream.byteBuffer2Record(request.request, checkVersionRequest);
// 获取节点路径
path = checkVersionRequest.getPath();
// 获取节点的Record
nodeRecord = getRecordForPath(path);
// 检查ACL列表 checkACL(zks, nodeRecord.acl, ZooDefs.Perms.READ,
request.authInfo);
// 获取版本号
version = checkVersionRequest.getVersion();
// 当前版本号
currentVersion = nodeRecord.stat.getVersion();
if (version != -1 && version != currentVersion) { // 验证版本号thrownew KeeperException.BadVersionException(path);
}
// 新生版本号
version = currentVersion + 1;
// 新生请求的事务
request.txn = new CheckVersionTxn(path, version);
break;
}
}
说明：pRequest2Txn会根据不同的请求类型进行不同的验证，如对创建节点而言，其会进行会话验证，ACL列表验证，节点路径验证及判断创建节点的类型（顺序节点、临时节点等）而进行不同操作，同时还会使父节点的子节点数目加1，之后会再调用addChangeRecord函数将ChangeRecord添加至ZooKeeperServer的outstandingChanges和outstandingChangesForPath中。
在pRequest函数中，如果请求类型是多重操作，那么会调用getPendingChanges函数，其会获取挂起的更改，其源码如下
HashMap<String, ChangeRecord> getPendingChanges(MultiTransactionRecord multiRequest) { HashMap<String, ChangeRecord> pendingChangeRecords = new HashMap<String, ChangeRecord>(); for(Op op: multiRequest) { // String path = op.getPath(); try { // 获取path对应的ChangeRecord ChangeRecord cr = getRecordForPath(path); if (cr != null) { pendingChangeRecords.put(path, cr); } /* * ZOOKEEPER-1624 - We need to store for parent‘s ChangeRecord * of the parent node of a request. So that if this is a * sequential node creation request, rollbackPendingChanges() * can restore previous parent‘s ChangeRecord correctly. * * Otherwise, sequential node name generation will be incorrect * for a subsequent request. */int lastSlash = path.lastIndexOf(‘/‘); if (lastSlash == -1 || path.indexOf(‘\0‘) != -1) { continue; } // 提取节点的父节点路径 String parentPath = path.substring(0, lastSlash); // 获取父节点的Record ChangeRecord parentCr = getRecordForPath(parentPath); if (parentCr != null) { pendingChangeRecords.put(parentPath, parentCr); } } catch (KeeperException.NoNodeException e) { // ignore this one } } return pendingChangeRecords; }
说明：可以看到在函数中，会遍历多重操作，针对每个操作，通过其路径获取对应的Record，然后添加至pendingChangeRecords，然后对其父节点进行相应操作，之后返回，其中会调用getRecordForPath函数，其源码如下
ChangeRecord getRecordForPath(String path) throws KeeperException.NoNodeException { ChangeRecord lastChange = null; synchronized (zks.outstandingChanges) { // 同步块 // 先从outstandingChangesForPath队列中获取 lastChange = zks.outstandingChangesForPath.get(path); /* for (int i = 0; i < zks.outstandingChanges.size(); i++) { ChangeRecord c = zks.outstandingChanges.get(i); if (c.path.equals(path)) { lastChange = c; } } */if (lastChange == null) { // 若在outstandingChangesForPath中未获取到，则从数据库中获取 DataNode n = zks.getZKDatabase().getNode(path); if (n != null) { // 节点存在 Long acl; Set<String> children; synchronized(n) { acl = n.acl; children = n.getChildren(); } // 新生ChangeRecord lastChange = new ChangeRecord(-1, path, n.stat, children != null ? children.size() : 0, zks.getZKDatabase().convertLong(acl)); } } } if (lastChange == null || lastChange.stat == null) { // 抛出异常thrownew KeeperException.NoNodeException(path); } return lastChange; }
说明：其表示根据节点路径获取节点的Record，其首先会从outstandingChangesForPath中获取路径对应的Record，若未获取成功，则从Zookeeper数据库中获取，若还未存在，则抛出异常。
2. processResult函数
public
void
processRequest(Request request) {
//
request.addRQRec(">prep="+zks.outstandingChanges.size());
//
将请求添加至队列中
submittedRequests.add(request);
}
说明：该函数是对父接口函数的实现，其主要作用是将请求添加至submittedRequests队列进行后续处理（run函数中）。
三、总结
针对PrepRequestProcessor的源码就分析到这里，其完成的业务逻辑也相对简单，其通常是处理链的第一个处理器，也谢谢各位园友的观看~
原文：http://www.cnblogs.com/leesf456/p/6412843.html
内容总结
以上是互联网集市为您收集整理的【Zookeeper】源码分析之请求处理链（二）全部内容，希望文章能够帮你解决【Zookeeper】源码分析之请求处理链（二）所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。
来源：【匿名】