标签：chain standalone flink StreamNode edge 注释 源码 new TODO
启动入口
CliFrontend.main -> cli.parseParameters -> ACTION_RUN run(params); -> executeProgram -> invokeInteractiveModeForExecution
-> callMainMethod(){
mainMethod = entryClass.getMethod("main", String[].class);
mainMethod.invoke(null, (Object) args);
}
--> SocketWindowWordCount.main(){
/*************************************************
* TODO
* 注释： 解析 host 和 port
*/
// the host and the port to connect to
final String hostname;
final int port;
try {
final ParameterTool params = ParameterTool.fromArgs(args);
hostname = params.has("hostname") ? params.get("hostname") : "localhost";
port = params.getInt("port");
} catch(Exception e) {
return;
}
/*************************************************
* TODO
* 注释： 获取 StreamExecutionEnvironment
* 它呢，还是 跟 Spark 中的 SparkContext 还是有区别的！
*/
// get the execution environment
final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
/*************************************************
* TODO
* 注释： 加载数据源得到数据抽象：DataStream
* 其实最终，只是创建了一个 DataStreamSource 对象，然后把 SourceFunction（StreamOperator）和 StreamExecutionEnvironment
* 设置到了 DataStreamSource 中， DataStreamSource 是 DataStream 的子类
* -
* DataStream 的主要分类：
* DataStreamSource 流数据源
* DataStreamSink 流数据目的地
* KeyedStream 按key分组的数据流
* DataStream 普通数据流
* -
* 关于函数理解：
* Function 传参
* Operator Graph 中抽象概念
* Transformation 一种针对流的逻辑操作
* 最终： Function ---> Operator ---> Transformation
*/
// get input data by connecting to the socket
DataStream<String> text = env.socketTextStream(hostname, port, "\n");
// parse the data, group it, window it, and aggregate the counts
DataStream<WordWithCount> windowCounts = text
// TODO 注释： 讲算子生成 Transformation 加入到 Env 中的 transformations 集合中
.flatMap(new FlatMapFunction<String, WordWithCount>() {
@Override
public void flatMap(String value, Collector<WordWithCount> out) {
for(String word : value.split("\\s")) {
out.collect(new WordWithCount(word, 1L));
}
}
})
// TODO 注释： 依然创建一个 DataStream(KeyedStream)
.keyBy(value -> value.word)
.timeWindow(Time.seconds(5))
// TODO 注释：
.reduce(new ReduceFunction<WordWithCount>() {
@Override
public WordWithCount reduce(WordWithCount a, WordWithCount b) {
return new WordWithCount(a.word, a.count + b.count);
}
});
// print the results with a single thread, rather than in parallel
windowCounts.print().setParallelism(1);
/*************************************************
* TODO
* 注释： 提交执行
*/
env.execute("Socket Window WordCount");
}
--> StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
StreamExecutionEnvironment 是 Flink 应用程序的执行入口，提供了一些重要的操作机制：
1、提供了 readTextFile(), socketTextStream(), createInput(), addSource() 等方法去对接数据源
2、提供了 setParallelism() 设置程序的并行度
3、StreamExecutionEnvironment 管理了 ExecutionConfig 对象，该对象负责Job执行的一些行为配置管理。
还管理了 Configuration 管理一些其他的配置
4、StreamExecutionEnvironment 管理了一个 List<Transformation<?>> transformations
成员变量，该成员变量，主要用于保存 Job 的各种算子转化得到的 Transformation，把这些Transformation 按照逻辑拼接起来，就能得到 StreamGragh（Transformation ->StreamOperator -> StreamNode）
5、StreamExecutionEnvironment 提供了 execute() 方法主要用于提交 Job 执行。该方法接收的参数就是：StreamGraph
--> env.socketTextStream -> addSource(){
/*************************************************
* TODO
* 注释： 获取输出数据类型
*/
TypeInformation<OUT> resolvedTypeInfo = getTypeInfo(function, sourceName, SourceFunction.class, typeInfo);
// TODO 注释： 判断是否是并行
boolean isParallel = function instanceof ParallelSourceFunction;
clean(function);
/*************************************************
* TODO
* 注释： 构建 SourceOperator
* 它是 SourceFunction 的子类，也是 StreamOperator 的子类
*/
final StreamSource<OUT, ?> sourceOperator = new StreamSource<>(function);
/*************************************************
* TODO
* 注释： 返回 DataStreamSource
* 关于这个东西的抽象有四种：
* 1、DataStream
* 2、KeyedDataStream
* 3、DataStreamSource
* 4、DataStreamSink
*/
return new DataStreamSource<>(this, resolvedTypeInfo, sourceOperator, isParallel, sourceName);
}
--> text.flatMap(讲算子生成 Transformation 加入到 Env 中的 transformations 集合中){
/*************************************************
* TODO
* 注释： 通过反射拿到 算子的类型
*/
TypeInformation<R> outType = TypeExtractor.getFlatMapReturnTypes();
/*************************************************
* TODO
* 注释： 算子执行的真正操作逻辑是： 将算子构建成 Transformation 加入 Env 中的 transformation 中的
* transformations 集合中。将来执行 StreamGraph 生成的时候，会将 Transformation 变成 Operator
* -
* flatMap 到最后，还是构建一个 DataStream （SingleOutputStreamOperator）对象返回，然后将 Transformation 加入到
* transformations 集合中，等待将来提交的之后，构建成 StreamGraph
*/
return flatMap(flatMapper, outType);
--> flatMap(){
/*************************************************
* TODO
* 注释： flink把每一个算子transform成一个对流的转换
* 并且注册到执行环境中，用于生成StreamGraph
* -
* 第一步：用户代码里定义的UDF会被当作其基类对待，然后交给 StreamFlatMap 这个 operator 做进一步包装。
* 事实上，每一个Transformation都对应了一个StreamOperator。
* -
* flink流式计算的核心概念，就是将数据从输入流一个个传递给Operator进行链式处理，最后交给输出流的过程
* -
* StreamFlatMap 是一个 Function 也是一个 StreamOperator
* -
* StreamFlatMap = StreamOperator
* flatMapper = Function
* -最终调用 transform 方法来把 StreamFlatMap 这种StreamOperator 转换成 Transformation
* 最终加入到 StreamExectiionEnvironment 的 List<Transformation<?>> transformations
*/
return transform("Flat Map", outputType, new StreamFlatMap<>(clean(flatMapper)));
}
---> doTransform(){
// read the output type of the input Transform to coax out errors about MissingTypeInfo
transformation.getOutputType();
/*************************************************
* TODO
* 注释： 构建： OneInputTransformation
* 由于 flatMap 这个操作只接受一个输入，所以再被进一步包装为 OneInputTransformation
*/
OneInputTransformation<T, R> resultTransform = new OneInputTransformation<>(this.transformation, operatorName, operatorFactory, outTypeInfo,environment.getParallelism());
/*************************************************
* TODO
* 注释： 构建： SingleOutputStreamOperator
*/
@SuppressWarnings({"unchecked", "rawtypes"}) SingleOutputStreamOperator<R> returnStream = new SingleOutputStreamOperator(environment, resultTransform);
/*************************************************
* TODO 重点
* 注释： 把 Operator 注册到执行环境中，用于生成 StreamGraph
* 最后，将该 transformation 注册到执行环境中，当执行 generate 方法时，生成 StreamGraph 图结构。
*/
getExecutionEnvironment().addOperator(resultTransform);
/*************************************************
* TODO
* 注释：
* SingleOutputStreamOperator 也是 DataStream 的子类，也就是返回了一个新的 DataStream
* 然后调用新的 DataStream 的某一个算子，又生成新的 StreamTransformation，
* 继续加入到 StreamExecutionEnvironment 的 transformations
*/
return returnStream;
}
}
-> env.execute(提交执行)
StreamGraph
env.execute() -> StreamGraph sg = getStreamGraph(jobName); -> getStreamGraphGenerator().setJobName(jobName).generate(){
/*************************************************
* TODO
* 注释： 执行各种算子的 transformation： 由 算子 生成 Transformation 来构建 StreamGraph
* 当时在执行各种算子的时候，就已经把算子转换成对应的 Transformation 放入 transformations 集合中了
* 自底向上(先遍历 input transformations) 对转换树的每个 transformation 进行转换
*/
for(Transformation<?> transformation : transformations) {
// TODO 注释： 从 Env 对象中，把 Transformation 拿出来，然后转换成 StreamNode
// TODO 注释： Function --> Operator --> Transformation --> StreamNode
transform(transformation);
}
--> transformOneInputTransform(){
// 1. 生成 streamNode
/*************************************************
* TODO
* 注释： 添加一个 Operator（实际上 StreamGraph 端会添加一个 StreamNode）
*/
streamGraph
.addOperator(transform.getId(), slotSharingGroup, transform.getCoLocationGroupKey(), transform.getOperatorFactory(), transform.getInputType(),transform.getOutputType(), transform.getName());
}
-->addOperator -> addNode(){
/*************************************************
* TODO
* 注释： 生成一个 StreamNode
*/
StreamNode vertex = new StreamNode(vertexID, slotSharingGroup, coLocationGroup, operatorFactory, operatorName, new ArrayList<OutputSelector<?>>(),vertexClass);
/*************************************************
* TODO
* 注释： 添加一个 StreamNode
*
* 这个 vertexID 就是 Transformation id transform.getId()
* Transformation id 在创建 Transformation 时生成
* 即一个Transformation 对应一个 StreamNode
*/
streamNodes.put(vertexID, vertex);
}
// 2. 生成 StreamEdge
/*************************************************
* TODO
* 注释： 定义该 SreamNode 的 入边
*/
for(Integer inputId : inputIds) {
/*************************************************
* TODO
* 注释： 设置当前 StreamNode 和 上游所有 StreamNode 之间的 StreamEdge
* inputId 上游
* transform.getId() 下游
*/
streamGraph.addEdge(inputId, transform.getId(), 0);
}
-> addEdge -> addEdgeInternal(){
/*************************************************
* TODO
* 注释： 构建 StreamNode 之间的 边（StreamEdge） 对象
*/
StreamEdge edge = new StreamEdge(upstreamNode, downstreamNode, typeNumber, outputNames, partitioner, outputTag, shuffleMode);
// TODO 注释： 给 上游 StreamNode 设置 出边
getStreamNode(edge.getSourceId()).addOutEdge(edge);
// TODO 注释： 给 下游 StreamNode 设置 入边
getStreamNode(edge.getTargetId()).addInEdge(edge);
}
}
总结：
1、生成上游顶点和下游顶点 StreamNode upstreamNode | StreamNode downstreamNode
2、根据上下游顶点生成 StreamEdge StreamEdge edge = new StreamEdge(upstreamNode, downstreamNode...)
3、将成的StreamEdge 加入上游StreamNode 的 出边 getStreamNode(edge.getSourceId()).addOutEdge(edge);
为啥不直接用 upstreamNode.addOutEdge(edge);
4、将成的StreamEdge 加入下游StreamNode 的 入边 getStreamNode(edge.getTargetId()).addInEdge(edge);
JobGraph
execute(sg); -> executeAsync -> AbstractSessionClusterExecutor.execute(){
// 1. 将streamgraph优化得到jobgraph
final JobGraph jobGraph = PipelineExecutorUtils.getJobGraph(pipeline, configuration);
// 2. 调用RestClient中的netty 客户端进行提交 到 服务端执行
// 通过 channel 把请求数据，发给 WebMonitorEndpoint 中的 JobSubmitHandler 来执行处理
clusterClient.submitJob(jobGraph)
}
// 1. 将streamgraph优化得到jobgraph
-> PipelineExecutorUtils.getJobGraph(pipeline, configuration) -> FlinkPipelineTranslationUtil.getJobGraph
-> pipelineTranslator.translateToJobGraph -> streamGraph.getJobGraph -> StreamingJobGraphGenerator.createJobGraph
-> new StreamingJobGraphGenerator(streamGraph, jobID).createJobGraph(){
/*************************************************
* TODO
* 注释： 重点： 设置 Chaining, 将可以 Chain 到一起的 StreamNode Chain 在一起，
* 这里会生成相应的 JobVertex 、JobEdge 、 IntermediateDataSet 对象
* 把能 chain 在一起的 Operator 都合并了，变成了 OperatorChain
* -
* 大致逻辑：
* 这里的逻辑大致可以理解为，挨个遍历节点：
* 1、如果该节点是一个 chain 的头节点，就生成一个 JobVertex，
* 2、如果不是头节点，就要把自身配置并入头节点，然后把头节点和自己的出边相连；
* 对于不能chain的节点，当作只有头节点处理即可
* -
* 作用：
* 能减少线程之间的切换，减少消息的序列化/反序列化，减少数据在缓冲区的交换，减少了延迟的同时提高整体的吞吐量。
*/
setChaining(hashes, legacyHashes);
// TODO 注释： 设置 PhysicalEdges
// TODO 注释： 将每个 JobVertex 的入边集合也序列化到该 JobVertex 的 StreamConfig 中
// TODO 注释： 出边集合，已经在 上面的代码中，已经搞定了。
setPhysicalEdges();
// TODO 注释： 设置 SlotSharingAndCoLocation
setSlotSharingAndCoLocation();
}
--> setChaining(){
/*************************************************
* TODO
* 注释：
* 1、一个 StreamNode 也可以认为是 做了 chain 动作 StreamNode -> JobVertex
* 2、两个 StreamNode 做了 chain 动作 StreamNode + StreamNode -> JobVertex
*/
// TODO 注释： 处理每个 StreamNode
for(Integer sourceNodeId : streamGraph.getSourceIDs()) {
/*************************************************
* TODO
* 注释： 把能 chain 在一起的 StreamNode 都 chain 在一起
*/
createChain(sourceNodeId, 0, new OperatorChainInfo(sourceNodeId, hashes, legacyHashes, streamGraph));
}
}
---> createChain(){
/*************************************************
* TODO ->
* 注释： 判断是否可以 chain 在一起！
* 当前这个地方做的事情，只是当前这个 StreamNode 和它的直接下游 StreamNode
*/
for(StreamEdge outEdge : currentNode.getOutEdges()) {
/*************************************************
* TODO 重点 1 isChainable
* 注释： 判断一个 StreamGraph 中的一个 StreamEdge 链接的上下游 Operator（StreamNode） 是否可以 chain 在一起
*
*/
if(isChainable(outEdge, streamGraph)) {
// TODO 注释： 加入可 chain 集合
chainableOutputs.add(outEdge);
} else {
// TODO 注释： 加入不可 chain 集合
nonChainableOutputs.add(outEdge);
}
}
// TODO 注释： 把可以 chain 在一起的 StreamEdge 两边的 Operator chain 在一个形成一个 OperatorChain
for(StreamEdge chainable : chainableOutputs) {
// TODO 注释： 递归 chain
// TODO 注释： 如果可以 chain 在一起的话，这里的 chainIndex 会加 1
transitiveOutEdges.addAll(createChain(chainable.getTargetId(), chainIndex + 1, chainInfo));
}
// 不能chain在一起的
for(StreamEdge nonChainable : nonChainableOutputs) {
transitiveOutEdges.add(nonChainable);
// TODO 注释： 不能 chain 一起的话，这里的 chainIndex 是从 0 开始算的，后面也肯定会走到 createJobVertex 的逻辑
createChain(nonChainable.getTargetId(), 0, chainInfo.newChain(nonChainable.getTargetId()));
}
/*************************************************
* TODO -> 重点 2 createJobVertex
* 注释： 把chain在一起的多个 Operator 创建成一个 JobVertex
* 如果当前节点是 chain 的起始节点, 则直接创建 JobVertex 并返回 StreamConfig, 否则先创建一个空的 StreamConfig
* createJobVertex 函数就是根据 StreamNode 创建对应的 JobVertex, 并返回了空的 StreamConfig
*
* --总结：
* StreamGraph -> JobGrahph
* 判断哪些StreamEge可以执行优化（chain），将 多个StreanNode 并成一个 JobVertex
*
* StreamNode_A -> (StreamNode_B -> StreamNode_C)
* B,C chain在一起， startNodeId = B // Integer startNodeId = chainInfo.getStartNodeId();
* 当 currentNodeId = B 则 B 创建 JobVertex
* 当 currentNodeId = C 则 C 不创建 JobVertex
*/
StreamConfig config = currentNodeId.equals(startNodeId) ?
// TODO ->
createJobVertex(startNodeId, chainInfo) : new StreamConfig(new Configuration());
// TODO 注释： chain 在一起的多条边 connect 在一起
for(StreamEdge edge : transitiveOutEdges) {
/**
* 重点 3 根据 StreamNode和 StreamEdge 生成 JobEge 和 IntermediateDataSet 用来将JobVertex和JobEdge相连
* TODO ->
*/
connect(startNodeId, edge);
}
}
// 重点 1 isChainable
isChainable(){
// TODO 注释： 获取上游 SourceVertex
StreamNode upStreamVertex = streamGraph.getSourceVertex(edge);
// TODO 注释： 获取下游 TargetVertex
StreamNode downStreamVertex = streamGraph.getTargetVertex(edge);
/*************************************************
* TODO
* 注释： 判断是否能 chain 在一起
*/
// TODO 条件1. 下游节点的入度为1 （也就是说下游节点没有来自其他节点的输入） A -> B B A 一一对应 如果shuffle类，那么B的入度就 >= 2
return downStreamVertex.getInEdges().size() == 1
// TODO 注释： 条件2. 上下游算子实例处于同一个SlotSharingGroup中
&& upStreamVertex.isSameSlotSharingGroup(downStreamVertex)
// TODO -> 注释： 这里面有 3 个条件 条件 345
&& areOperatorsChainable(upStreamVertex, downStreamVertex, streamGraph){
// TODO 注释： 获取 上游 Operator
StreamOperatorFactory<?> upStreamOperator = upStreamVertex.getOperatorFactory();
// TODO 注释： 获取 下游 Operator
StreamOperatorFactory<?> downStreamOperator = downStreamVertex.getOperatorFactory();
// TODO 注释：条件3、前后算子不为空 如果上下游有一个为空，则不能进行 chain
if(downStreamOperator == null || upStreamOperator == null) {
return false;
}
/*************************************************
* 条件4、上游算子的链接策略是 always 或者 head
* 条件5、下游算子的链接策略必须是 always
*/
if(upStreamOperator.getChainingStrategy() == ChainingStrategy.NEVER ||
downStreamOperator.getChainingStrategy() != ChainingStrategy.ALWAYS) {
return false;
}
}
// TODO 注释：条件6 两个算子间的物理分区逻辑是ForwardPartitioner
// (无shuffle，当前节点的计算数据，只会发给自己 one to one 如上游50个task 计算完直接发送给下游50个task)
&& (edge.getPartitioner() instanceof ForwardPartitioner)
// TODO 注释：条件7 两个算子间的shuffle方式不等于批处理模式
&& edge.getShuffleMode() != ShuffleMode.BATCH
// TODO 注释：条件8 上下游算子实例的并行度相同
&& upStreamVertex.getParallelism() == downStreamVertex.getParallelism()
// TODO 注释：条件9 启动了 chain
&& streamGraph.isChainingEnabled();
}
// 重点 2 createJobVertex
createJobVertex(){
// TODO 注释： 获取 startStreamNode
StreamNode streamNode = streamGraph.getStreamNode(streamNodeId);
// TODO 注释： 生成一个 JobVertexID
JobVertexID jobVertexId = new JobVertexID(hash);
// JobVertex 初始化
if(chainedInputOutputFormats.containsKey(streamNodeId)) {
jobVertex = new InputOutputFormatVertex(chainedNames.get(streamNodeId), jobVertexId, operatorIDPairs);
chainedInputOutputFormats.get(streamNodeId).write(new TaskConfig(jobVertex.getConfiguration()));
} else {
// TODO 注释： 创建一个 JobVertex
jobVertex = new JobVertex(chainedNames.get(streamNodeId), jobVertexId, operatorIDPairs);
}
// 将生成好的 JobVertex 加入到： JobGraph
jobGraph.addVertex(jobVertex);
}
// 重点 3 根据 StreamNode和 StreamEdge 生成 JobEge 和 IntermediateDataSet 用来将JobVertex和JobEdge相连
connect(startNodeId, edge){
//生成JobEdge
JobEdge jobEdge;
if(isPointwisePartitioner(partitioner)) {
jobEdge = downStreamVertex.connectNewDataSetAsInput(headVertex, DistributionPattern.POINTWISE, resultPartitionType);
} else {
// TODO -> 创建 IntermediateDataSet
jobEdge = downStreamVertex.connectNewDataSetAsInput(headVertex, DistributionPattern.ALL_TO_ALL, resultPartitionType);
}
}
----> connectNewDataSetAsInput(){
// TODO -> input是JobVertex 即 JobVertex 创建 IntermediateDataSet
IntermediateDataSet dataSet = input.createAndAddResultDataSet(partitionType);
// TODO 创建 JobEdge
JobEdge edge = new JobEdge(dataSet, this, distPattern);
this.inputs.add(edge);
// TODO IntermediateDataSet -> JobEdge
dataSet.addConsumer(edge);
return edge;
// 至此形成流图 JobVertex -> IntermediateDataSet -> JobEdge
}
==================================================================================================================================
// 2. 调用RestClient中的netty 客户端进行提交 到 服务端执行
-> clusterClient.submitJob(jobGraph){
/*************************************************
* TODO
* 注释： 先持久化： 把 JobGragh 持久化到磁盘文件形成 jobGraphFile
* 1、持久化 JobGragh 的前缀：flink-jobgraph
* 2、持久化 JobGragh 的后缀：.bin
* 当我们把 JobGraph 持久化了之后，变成了一个文件： jobGraphFile
* 然后其实，在提交 JobGraph 到 Flink 集群运行的时候，其实提交的就是： 这个文件！
* 将来，最终是有 FLink 集群的 WebMonitor（JobSubmitHandler） 去接收请求来执行处理
* JobSubmitHandler 在执行处理的第一件事情： 把传送过来的这个文件反序列化得到 JobGraph 这个对象
*/
CompletableFuture<java.nio.file.Path> jobGraphFileFuture = CompletableFuture.supplyAsync(() -> {
try {
final java.nio.file.Path jobGraphFile = Files.createTempFile("flink-jobgraph", ".bin");
try(ObjectOutputStream objectOut = new ObjectOutputStream(Files.newOutputStream(jobGraphFile))) {
objectOut.writeObject(jobGraph);
/*************************************************
* TODO
* 注释： 等待持久化完成之后，然后加入带上传文件系列
* 补充： thenApply 接收一个函数作为参数，使用该函数处理上一个 CompletableFuture 调用的结果，并返回一个具有处理结果的 Future 对象。
*/
CompletableFuture<Tuple2<JobSubmitRequestBody, Collection<FileUpload>>> requestFuture = jobGraphFileFuture.thenApply(jobGraphFile -> {
List<String> jarFileNames = new ArrayList<>(8);
List<JobSubmitRequestBody.DistributedCacheFile> artifactFileNames = new ArrayList<>(8);
Collection<FileUpload> filesToUpload = new ArrayList<>(8);
// TODO 注释： 加入待上传的文件系列
filesToUpload.add(new FileUpload(jobGraphFile, RestConstants.CONTENT_TYPE_BINARY));
for(Path jar : jobGraph.getUserJars()) {
jarFileNames.add(jar.getName());
// 上传
filesToUpload.add(new FileUpload(Paths.get(jar.toUri()), RestConstants.CONTENT_TYPE_JAR));
}
// -> TODO -> 注释：sendRetriableRequest() 提交 真正提交
requestAndFileUploads -> sendRetriableRequest(JobSubmitHeaders.getInstance(), EmptyMessageParameters.getInstance(), requestAndFileUploads.f0,
requestAndFileUploads.f1, isConnectionProblemOrServiceUnavailable()));
// TODO 注释： 等 sendRetriableRequest 提交完成之后，删除生成的 jobGraghFile
Files.delete(jobGraphFile);
}
--> sendRetriableRequest -> restClient.sendRequest(){
/*************************************************
* TODO
* 注释： 通过 Netty 客户端发送请求给 Netty 服务端
*/
final ChannelFuture connectFuture = bootstrap.connect(targetAddress, targetPort);
/*************************************************
* TODO ->
* 注释： 发送请求 到 WebMonitorEndpoint 的 Netty 服务端
* 最终由： JobSubmitHandler 来执行处理
*/
httpRequest.writeTo(channel);
}
标签：chain,standalone,flink,StreamNode,edge,注释,源码,new,TODO 来源： https://blog.csdn.net/m0_46449152/article/details/120798275
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。