麒麟KY-RTI分布仿真技术：第六章 Java程序设计

第六章 Java程序设计

       本章讲述了如何基于Java设计聊天程序和时间管理程序，两个程序都是控制台程序。聊天程序相当于4.3节的GNU C++聊天程序；时间管理程序相当于4.4节的GNU C++程序。对于不同的程序设计语言而言，基于HLA/RTI设计仿真应用的方法都差不多，其关键在于RTI软件能否支持相应程序设计语言的开发，用户只需要关心一下调用接口即可，通过调用接口可以设计形式多样的程序。与C++调用接口的一个显著区别在于句柄和时间的表示，Java中的各种句柄全部用int表示，各类时间则用double表示。

6.1 聊天程序

6.1.1需求分析

       本项目需要实现一个类似微信群或者QQ群聊天功能的Java程序，每个人发送的消息都能够被群里的其他人看到。

6.1.2项目设计

       每条聊天信息应包含2个内容：聊天者昵称、聊天的一句话，这样接收者就会知道是谁在发言。“聊天者昵称”用name表示，“聊天的一句话”用sentence表示，两个都是字符串类型。因为HLA是面向对象的，发送的数据要么采用对象类，要么采用交互类。本项目可采用交互类，将name和sentence封装到一个名叫“chat”的交互类中，如下列伪代码所示。

class chat {           //交互类

       int  name;     //参数

       int  sentence; //参数

}

       下面采用KY-OMT创建fed文件，相应的chat.fed文件已经在3.3.3中创建完成，将该文件保存到KY-RTI的bin目录。

       本项目对时间没有特别要求，不需要采用HLA时间管理机制。在采用Java语言开发时，不要使用tick服务，否则会报一个警告。

6.1.3代码设计

       该程序由3个源文件组成：GlobalVariables.java、Chat.java、HwFederateAmbassador.java。GlobalVariables.java定义了其他两个文件需要用到的公用变量；Chat.java调用RTI服务访问RTI；HwFederateAmbassador.java接收RTI回调服务。

       GlobalVariables.java定义了可由Chat.java、HwFederateAmbassador.java共享使用的静态变量；因为Java不支持C++的全局变量概念，这里的静态变量就相当于C++的全局变量。

                                      表6.1  Java聊天示例：GlobalVariables.java

  1. public class GlobalVariables
  2. {
  3.     public static int        hChatClass;
  4.     public static int        hChatName;
  5.     public static int        hChatSentence;
  6. }

       Chat.java代码说明：

21-25行：创建联邦执行；

27-33行：加入联邦执行；

36-38行：获取交互类及其参数句柄；

41行：公布交互类，只有公布之后才能够向RTI发送交互；

43行：订购交互类，只有订购之后才能够从RTI收到其他人的聊天内容；

46-59行：循环操作，每次输入一句话，并调用sendInteraction服务发送给RTI；当用户输入“exit”时则退出执行；

65行：该行为注释行，表示仿真成员在结束时不需要调用'resignFederationExecution'和 'destroyFederationExecution'服务，RTI服务器会自动执行这两个服务。

                                      表6.2  Java聊天示例：Chat.java

  1. import MID.*;
  2. import RTI.*;
  3.  
  4. public class Chat
  5. {
  6.     public static void main(String[] args) {
  7.         String federationName = "chat";
  8.         String federateName = System.console().readLine("Please input your name: ");
  9.  
  10.         HwFederateAmbassador fed;
  11.         RTI_RTIambassador rti;
  12.  
  13.         try {
  14.             fed = new HwFederateAmbassador();
  15.             rti = new RTI_RTIambassador();
  16.         } catch(Exception ex) {
  17.             ex.printStackTrace();
  18.             return;
  19.         }
  20.  
  21.         try {
  22.             rti.createFederationExecution(federationName, "chat.fed");
  23.         } catch(Exception ex) {
  24.             // According to the HLA standard, only the first federate can call createFederationExecution successfully. Don't return.
  25.         }
  26.  
  27.         try {
  28.             int federateHandle = rti.joinFederationExecution(federateName, federationName, fed);
  29.             //System.out.println("my federate handle is "+federateHandle);
  30.         } catch(Exception ex) {
  31.             ex.printStackTrace();
  32.             return;
  33.         }
  34.  
  35.         try {
  36.             GlobalVariables.hChatClass = rti.getInteractionClassHandle("chat");
  37.             GlobalVariables.hChatName = rti.getParameterHandle("name", GlobalVariables.hChatClass);
  38.             GlobalVariables.hChatSentence = rti.getParameterHandle("sentence", GlobalVariables.hChatClass);
  39.  
  40.             //如果向外发送，则需要公布
  41.             rti.publishInteractionClass(GlobalVariables.hChatClass);
  42.             //如果需要接收，则必须订购
  43.             rti.subscribeInteractionClass(GlobalVariables.hChatClass);
  44.  
  45.             String szSentence = "";
  46.             while (!szSentence.equals("exit")) {
  47.                 szSentence = System.console().readLine("Please input a sentence: ");
  48.  
  49.                 HandleValuePair[] theParameters = new HandleValuePair[2];
  50.                 theParameters[0] = new HandleValuePair();
  51.                 theParameters[0].aHandle = GlobalVariables.hChatName;
  52.                 theParameters[0].aValue = federateName; //int -> String
  53.  
  54.                 theParameters[1] = new HandleValuePair();
  55.                 theParameters[1].aHandle = GlobalVariables.hChatSentence;
  56.                 theParameters[1].aValue = szSentence; //int -> String
  57.  
  58.                 rti.sendInteraction(GlobalVariables.hChatClass, theParameters, "");
  59.             }
  60.         } catch (Exception ex) {
  61.             ex.printStackTrace();
  62.             return;
  63.         }
  64.  
  65.         //After the program exits, the RTI will automatically calls 'resignFederationExecution' and 'destroyFederationExecution'.
  66.     }
  67. }

       HwFederateAmbassador.java代码说明：

5-8行：由于不处理时间参数，因此如果接收到这种类型的receiveInteraction交互，则直接调用不带时间参数的服务来统一处理；

10-28行：处理接收到的聊天信息，将其简单输出即可。

                                      表6.3  Java聊天示例：HwFederateAmbassador.java

  1. import MID.*;
  2.  
  3. public class HwFederateAmbassador extends RTIFederateAmbassador
  4. {
  5.     public final void receiveInteraction(int theInteraction, MID.HandleValuePair[] theParameters, double theTime, String theTag, MID.EventRetractionHandle theHandle) {
  6.         //call the next service.
  7.         receiveInteraction(theInteraction, theParameters, theTag);
  8.     }
  9.  
  10.     public final void receiveInteraction(int theInteraction, MID.HandleValuePair[] theParameters, String theTag) {
  11.         String name = new String();     //name of sender
  12.         String sentence = new String(); //sentence of sender
  13.  
  14.         for ( int i = 0; i < theParameters.length; i++ ) {
  15.             if (theParameters[i].aHandle == GlobalVariables.hChatName) {
  16.                 name = theParameters[i].aValue;
  17.  
  18.             } else if (theParameters[i].aHandle == GlobalVariables.hChatSentence) {
  19.                 sentence = theParameters[i].aValue;
  20.  
  21.             } else {
  22.                 System.out.println("Receive wrong parameter handle.");
  23.             }
  24.         }
  25.  
  26.         System.out.println();
  27.         System.out.println(name + ": " + sentence);
  28.     }
  29. }

 

6.1.4编译运行

6.1.4.1编译

       编译Java程序，只要将kyrti.jar文件加入到CLASSPATH环境变量，或者在编译时作为命令参数添加。

       （1）如果在CLASSPATH环境变量中已经设置，则编译命令如下。

       javac  *.java

       （2）在编译时作为参数添加，则编译命令如下。

       javac  -classpath .;C:\KY-RTI\jar\ky-rti.jar  *.java                                       #Windows

       javac -classpath .:/home/lbq/RTI-1.3NGv6/Linux-x86_64-opt-mt/jar/ky-rti.jar  *.java      #Linux

6.1.4.2测试运行

       测试项目：在银河麒麟操作系统上运行2个Java仿真成员，测试KY-RTI通信功能。

       测试步骤：

       第1步：启动KY-RTI。注意，KY-RTI的IP地址和端口号要与RTI.rid一致。如果没有RTI.rid文件，则程序在运行时会自动生成该文件。Java程序不关注tick开关。

       第2步：如图6.1和图6.2所示，开启两个终端，运行2个仿真成员，开始对话。运行程序命令：

       java  Chat

       测试结果表明：Java仿真成员的聊天功能正常，KY-RTI支持中英文传输。

麒麟KY-RTI分布仿真技术：第六章 Java程序设计

                                      图6.1　Java聊天者1

麒麟KY-RTI分布仿真技术：第六章 Java程序设计

                                      图6.1　Java聊天者2

 

6.2 时间管理程序

6.2.1需求分析

       本仿真项目的名称为“TimeManagementExample”，名称规定了不是“TimeManagementExample”的程序不属于本项目。对HLA/RTI程序来说，联邦名称为“TimeManagementExample”，不是该名字的仿真成员不属于本项目。

       每个仿真成员拥有3架飞机，但其中只有1架飞机会起飞，飞机的x、y坐标为随机数（不考虑合理性），飞机会每隔1秒发布自己的位置信息。

6.2.2项目设计

       飞机每隔1秒发布自己的位置信息，意味着该仿真应采用时间管理服务，仿真步长为1。

       飞机发送的是自己的x、y二维态势信息，用一个对象类plane来封装，两个属性为xPos和yPos，类型为整型；但不管什么类型，在RTI中都是作为字符串来传送。如下列代码所示。

class plane {         //对象类

       int  xPos;      //属性

       int  yPos;      //属性

}

       下面采用KY-OMT创建fed文件，相应的tracer.fed文件已经在3.3.2中创建完成，将该文件保存到KY-RTI的bin目录。

6.2.3代码设计

       该程序由3个源文件组成：GlobalVariables.java、TimeManagement.java、HwFederateAmbassador.java。GlobalVariables.java定义了其他两个文件需要用到的公用变量；Chat.java调用RTI服务访问RTI；HwFederateAmbassador.java接收RTI回调服务。

       GlobalVariables.java定义了可由TimeManagement.java、HwFederateAmbassador.java共享使用的静态变量；因为Java不支持C++的全局变量概念，这里的静态变量就相当于C++的全局变量。

                                            表6.4  Java时间管理示例：GlobalVariables.java

  1. public class GlobalVariables
  2. {
  3.     public static double     g_currentTime = 0.0;
  4.     public static double     g_lookahead = 1.0;
  5.     public static boolean    g_bConstrained = false;
  6.     public static boolean    g_bRegulation = false;
  7.     public static boolean    g_granted = false;
  8.  
  9.     public static int        g_hxPos;
  10.     public static int        g_hyPos;
  11.  
  12.     //3 planes
  13.     public static int        g_hInstance1, g_hInstance2, g_hInstance3;
  14. }

 

       TimeManagement.java代码说明：

7行：联邦名称定义为“TimeManagementExample”；

21-26行：创建联邦执行；

28-34行：加入联邦执行；

37-39行：获取对象类及其属性句柄；

45行：公布对象类属性，只有公布之后才能够向RTI发送二维态势信息，即xPos和yPos；

46行：订购交互类属性，只有订购之后才能够从RTI收到二维态势信息；

48-53行：注册3架飞机；

60行：将仿真成员设置为时间管理受限的；

61-63行：等待RTI同意将该仿真成员设置为时间管理受限的；

65行：将仿真成员设置为时间管控成员；

66-68行：等待RTI同意将该仿真成员设置为时间管控成员；

70行：打开异步消息开关；

77行：仿真周期设置为1秒；这里的逻辑时间1对应物理时间的1秒（假设设置为2，则1个逻辑时间单位对应物理时间的0.5秒，2个逻辑时间单位对应仿真周期1秒）；

83-167行：每隔1秒循环推进仿真，直到中断退出仿真；

100行：发送飞机在下一时刻的二维态势信息（如果采用RO消息也可以发送当前时刻的态势，当前或下一步信息依项目要求来抉择）；

131行：将仿真请求推进到下一步；

132-134行：等待RTI同意该仿真成员推进到下一步；

169行：该行为注释行，表示仿真成员在结束时不需要调用'resignFederationExecution'和 'destroyFederationExecution'服务，RTI服务器会自动执行这两个服务。

                                      表6.5  Java时间管理示例：TimeManagement.java

  1. import MID.*;
  2. import RTI.*;
  3.  
  4. public class TimeManagement
  5. {
  6.     public static void main(String[] args) {
  7.         String federationName = "TimeManagementExample";
  8.         String federateName = System.console().readLine("Please input the federate name: ");
  9.  
  10.         HwFederateAmbassador fed;
  11.         RTI_RTIambassador rti;
  12.  
  13.         try {
  14.             fed = new HwFederateAmbassador();
  15.             rti = new RTI_RTIambassador();
  16.         } catch(Exception ex) {
  17.             ex.printStackTrace();
  18.             return;
  19.         }
  20.  
  21.         try {
  22.             rti.createFederationExecution(federationName, "tracer.fed");
  23.         } catch(Exception ex) {
  24.             // According to the HLA standard, only the first federate can call createFederationExecution successfully. Don't return.
  25.             ex.printStackTrace();
  26.         }
  27.  
  28.         try {
  29.             int federateHandle = rti.joinFederationExecution(federateName, federationName, fed);
  30.             System.out.println("my federate handle is "+federateHandle);
  31.         } catch(Exception ex) {
  32.             ex.printStackTrace();
  33.             return;
  34.         }
  35.  
  36.         try {
  37.             int hPlaneClass = rti.getObjectClassHandle("plane");
  38.             GlobalVariables.g_hxPos = rti.getAttributeHandle("xPos", hPlaneClass); //different from p1516
  39.             GlobalVariables.g_hyPos = rti.getAttributeHandle("yPos", hPlaneClass); //different from p1516
  40.  
  41.             int[] theAttributes = new int[2];
  42.             theAttributes[0] = GlobalVariables.g_hxPos;
  43.             theAttributes[1] = GlobalVariables.g_hyPos;
  44.  
  45.             rti.publishObjectClass(hPlaneClass, theAttributes);
  46.             rti.subscribeObjectClassAttributes(hPlaneClass, theAttributes);
  47.  
  48.             //register one plane
  49.             GlobalVariables.g_hInstance1 = rti.registerObjectInstance(hPlaneClass);
  50.             //register 2nd plane
  51.             GlobalVariables.g_hInstance2 = rti.registerObjectInstance(hPlaneClass);
  52.             //register 3rd plane
  53.             GlobalVariables.g_hInstance3 = rti.registerObjectInstance(hPlaneClass);
  54.         } catch (Exception ex) {
  55.             ex.printStackTrace();
  56.             return;
  57.         }
  58.  
  59.         try {
  60.             rti.enableTimeConstrained();
  61.             while(!GlobalVariables.g_bConstrained) {
  62.                 Thread.sleep(1);    //1 millisecond
  63.             }
  64.  
  65.             rti.enableTimeRegulation(0.0, GlobalVariables.g_lookahead);
  66.             while(!GlobalVariables.g_bRegulation) {
  67.                 Thread.sleep(1);    //1 millisecond
  68.             }
  69.  
  70.             rti.enableAsynchronousDelivery();
  71.         } catch (Exception ex) {
  72.             ex.printStackTrace();
  73.             return;
  74.         }
  75.  
  76.         double targetTime = GlobalVariables.g_currentTime;
  77.         double intervalTime = 1;
  78.         int xPos, yPos;
  79.         String tag = "F15";
  80.         int step = 0;
  81.         java.util.Random r = new java.util.Random(); //get a random number
  82.  
  83.         while(true) {
  84.             step++;
  85.             System.out.println("Step: "+step);
  86.  
  87.             xPos=r.nextInt();
  88.             yPos=r.nextInt();
  89.  
  90.             HandleValuePair[] theAttributeValues = new HandleValuePair[2];
  91.             theAttributeValues[0] = new HandleValuePair();
  92.             theAttributeValues[0].aHandle = GlobalVariables.g_hxPos;
  93.             theAttributeValues[0].aValue = String.valueOf(xPos); //int -> String
  94.  
  95.             theAttributeValues[1] = new HandleValuePair();
  96.             theAttributeValues[1].aHandle = GlobalVariables.g_hyPos;
  97.             theAttributeValues[1].aValue = String.valueOf(yPos); //int -> String
  98.  
  99.             try {
  100.                 rti.updateAttributeValues(GlobalVariables.g_hInstance1, theAttributeValues, GlobalVariables.g_currentTime + GlobalVariables.g_lookahead, tag);
  101.             } catch(RTI.ObjectNotKnown ex) {
  102.                 ex.printStackTrace();
  103.                 return;
  104.             } catch(RTI.AttributeNotDefined ex) {
  105.                 ex.printStackTrace();
  106.                 return;
  107.             } catch(RTI.AttributeNotOwned ex) {
  108.                 ex.printStackTrace();
  109.                 return;
  110.             } catch(RTI.InvalidFederationTime ex) {
  111.                 ex.printStackTrace();
  112.                 return;
  113.             } catch(RTI.FederateNotExecutionMember ex) {
  114.                 ex.printStackTrace();
  115.                 return;
  116.             } catch(RTI.SaveInProgress ex) {
  117.                 ex.printStackTrace();
  118.                 return;
  119.             } catch(RTI.RestoreInProgress ex) {
  120.                 ex.printStackTrace();
  121.                 return;
  122.             } catch(Exception ex) {
  123.                 ex.printStackTrace();
  124.                 return;
  125.             }
  126.  
  127.             targetTime = GlobalVariables.g_currentTime + intervalTime;
  128.             System.out.println("This federate will advance to "+targetTime);
  129.  
  130.             try {
  131.                 rti.timeAdvanceRequest(targetTime);
  132.                 while(!GlobalVariables.g_granted) {
  133.                     Thread.sleep(1);//1 millisecond
  134.                 }
  135.  
  136.                 GlobalVariables.g_granted = false;
  137.                 System.out.println("The federate has advanced to "+GlobalVariables.g_currentTime);
  138.                 System.out.println();
  139.             } catch(RTI.InvalidFederationTime ex) {
  140.                 ex.printStackTrace();
  141.                 return;
  142.             } catch(RTI.FederationTimeAlreadyPassed ex) {
  143.                 ex.printStackTrace();
  144.                 return;
  145.             } catch(RTI.TimeAdvanceAlreadyInProgress ex) {
  146.                 ex.printStackTrace();
  147.                 return;
  148.             } catch(RTI.EnableTimeRegulationPending ex) {
  149.                 ex.printStackTrace();
  150.                 return;
  151.             } catch(RTI.EnableTimeConstrainedPending ex) {
  152.                 ex.printStackTrace();
  153.                 return;
  154.             } catch(RTI.FederateNotExecutionMember ex) {
  155.                 ex.printStackTrace();
  156.                 return;
  157.             } catch(RTI.SaveInProgress ex) {
  158.                 ex.printStackTrace();
  159.                 return;
  160.             } catch(RTI.RestoreInProgress ex) {
  161.                 ex.printStackTrace();
  162.                 return;
  163.             } catch (Exception ex) {
  164.                 ex.printStackTrace();
  165.                 return;
  166.             }
  167.         }
  168.  
  169.         //After the program exits, the RTI will automatically calls 'resignFederationExecution' and 'destroyFederationExecution'.
  170.     }
  171. }

       HwFederateAmbassador.java代码说明：

5-7行：将发现的飞机输出到终端；

9-33行：将收到的飞机态势信息输出到终端；

35-39行：RTI同意将仿真成员设置为时间管控成员；

41-45行：RTI同意将仿真成员设置为时间管理受限的成员；

47-51行：RTI同意仿真成员推进到下一步。

                                      表6.6  Java时间管理示例：HwFederateAmbassador.java

  1. import MID.*;
  2.  
  3. public class HwFederateAmbassador extends RTIFederateAmbassador
  4. {
  5.     public final void discoverObjectInstance(int theObject, int theObjectClass, String theObjectName) {
  6.         System.out.println("discoverObjectInstance: "+theObject+","+theObjectClass+","+theObjectName);
  7.     }
  8.  
  9.     public final void reflectAttributeValues(int theObject, HandleValuePair[] theAttributes, double theTime, String theTag, MID.EventRetractionHandle theHandle) {
  10.         //call the next service.
  11.         reflectAttributeValues(theObject, theAttributes, theTag);
  12.     }
  13.  
  14.     public final void reflectAttributeValues(int theObject, MID.HandleValuePair[] theAttributes, String theTag) {
  15.         System.out.println("reflectAttributeValues: " + theObject);
  16.  
  17.         String value = new String();
  18.         for (int i = 0; i < theAttributes.length; ++i) {
  19.             if (theAttributes[i].aHandle == GlobalVariables.g_hxPos) {
  20.                 value = theAttributes[i].aValue;
  21.  
  22.             } else if (theAttributes[i].aHandle == GlobalVariables.g_hyPos) {
  23.                 value = theAttributes[i].aValue;
  24.  
  25.             } else {
  26.                 System.out.println("Receive wrong parameter handle.");
  27.             }
  28.  
  29.             System.out.println("    <"+theAttributes[i].aHandle+","+value+">");
  30.         }
  31.  
  32.         System.out.println("    tag:" + theTag);
  33.     }
  34.  
  35.     public final void timeRegulationEnabled(double theFederateTime) {
  36.         GlobalVariables.g_currentTime = theFederateTime;
  37.         GlobalVariables.g_bRegulation = true;
  38.         System.out.println("timeRegulationEnabled: " + theFederateTime);
  39.     }
  40.  
  41.     public final void timeConstrainedEnabled(double theFederateTime) {
  42.         GlobalVariables.g_currentTime = theFederateTime;
  43.         GlobalVariables.g_bConstrained = true;
  44.         System.out.println("timeRegulationEnabled: " + theFederateTime);
  45.     }
  46.  
  47.     public final void timeAdvanceGrant(double theTime) {
  48.         GlobalVariables.g_currentTime = theTime;
  49.         GlobalVariables.g_granted = true;
  50.         System.out.println("timeAdvanceGrant: " + theTime);
  51.     }

 

6.2.4编译运行

       编译方法参照6.1.4.1执行，生成可执行程序之后就可以进行测试。

       测试项目：在银河麒麟操作系统上运行2个Java仿真成员，两个仿真成员启动后尽可能快地向前推进；测试KY-RTI的HLA的基本服务功能，特别是时间管理同步功能。

       测试步骤：

       第1步：启动KY-RTI。注意，KY-RTI的IP地址和端口号要与RTI.rid一致。如果没有RTI.rid文件，则程序在运行时会自动生成该文件。Java程序不关注tick开关。

       第2步：如图6.3和图6.4所示，开启两个终端，运行2个Java仿真成员，开始仿真。运行程序命令：

       java  TimeManagement

       测试结果表明：KY-RTI支持基于麒麟操作系统的Java仿真技术，时间管理同步功能强。

       测试说明：

       （1）图6.3是仿真成员“Air01”被Ctrl+C中断执行时的界面。此时，它能收到仿真成员“Air02”发送的二维态势信息。

       （2）图6.4是仿真成员“Air02”被Ctrl+C中断执行时的界面。此时，只显示它自己的运行信息，不会有其他仿真成员的二维态势信息。

麒麟KY-RTI分布仿真技术：第六章 Java程序设计

                                      图6.3　使用时间管理服务的HLA仿真成员Air01

麒麟KY-RTI分布仿真技术：第六章 Java程序设计

                                      图6.4　使用时间管理服务的HLA仿真成员Air02

麒麟RTI软件KY-RTI的Linux、Windows版本和源码请联系作者:[email protected]

 

麒麟KY-RTI分布仿真技术：前 言

麒麟KY-RTI分布仿真技术：第一章 简介

麒麟KY-RTI分布仿真技术：第二章 系统安装

麒麟KY-RTI分布仿真技术：第三章 KY-OMT对象模型模板工具

麒麟KY-RTI分布仿真技术：第四章 C++程序设计

麒麟KY-RTI分布仿真技术：第五章 Qt程序设计

麒麟KY-RTI分布仿真技术：第六章 Java程序设计

麒麟KY-RTI分布仿真技术：第七章 Visual C++程序设计

麒麟KY-RTI分布仿真技术：第八章 Visual C#程序设计

麒麟KY-RTI分布仿真技术：第九章 综合演示

相关文章：

  • 2021-11-26
  • 2022-12-23
  • 2022-02-08
  • 2021-08-05
  • 2021-04-03
  • 2021-09-14
  • 2021-04-17
  • 2021-10-30
猜你喜欢
  • 2021-07-04
  • 2021-06-28
  • 2021-04-26
  • 2022-01-12
  • 2021-11-03
  • 2021-05-27
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode