SOA-based application layer software architecture construction method and device

Abstract

The invention provides an SOA-based application layer software architecture construction method and device. The method comprises the following steps: establishing a communication connection between an underlying protocol stack and an external Ethernet; establishing a connection between the underlying protocol stack and a software component in the SOA service processing module; creating a first executable entity in the software component, and creating a second executable entity in the application layer logic implementation module; establishing communication connection between the software component and the application layer logic implementation module; the functional logic is built based on the logic development tool, the first executable entity and the second executable entity. In the scheme, compared with the prior art, the SOA service processing module is added to realize the layering of a bottom layer and an application layer, so that the whole architecture is clearer, debugging information can be added in each layer when a problem occurs, which part has the problem can be positioned, and when software platform reuse is carried out, the debugging efficiency is greatly improved. And only a receiving interface at the SOA service processing module needs to be modified, so that modularized software reuse can be realized.

Description

Technical Field

[0001] The present invention relates to the field of automotive electronics technology, and in particular to a method and device for building an application layer software architecture based on SOA. Background Art

[0002] SOA (Service-Oriented Architecture) is a software architecture design model and methodology. Its core idea is to modularize the various electronic control units (ECUs) and software functions in the car and provide them in the form of services. Each service is an independent executable software component with its own IP address and standardized interface, which can be easily called at any time.

[0003] The existing SOA application layer software architecture of automotive electronic systems generally unpacks services and executes functions directly in the model of application logic implementation. There is no layered structure, that is, there is no separation between the bottom layer and the application layer. Service subscription management, service feedback and logic implementation are implemented at the same level.

[0004] The existing SOA application layer software architecture, when reusing software on the developed software platform, has no layered processing between the bottom layer and the application layer, changes to the bottom layer will cause changes to the application layer interface as well, which will increase the difficulty of reuse and make it difficult to achieve software platformization. Secondly, the existing SOA application layer software architecture is not clear enough in terms of layers, and cannot achieve decoupling between the upper layer and the bottom layer. The application layer interface directly accesses the bottom layer, which increases the difficulty of troubleshooting once a problem occurs. Summary of the invention

[0005] In view of this, an embodiment of the present invention provides a method and device for building an application layer software architecture based on SOA to realize the stratification of the bottom layer and the application layer, thereby achieving the purpose of modular software reuse.

[0006] To achieve the above objectives, the embodiments of the present invention provide the following technical solutions:

[0007] The first aspect of the embodiment of the present invention discloses a method for building an application layer software architecture based on SOA, which is applied to a vehicle body controller, wherein the vehicle body controller includes: an underlying protocol stack, a runtime environment, an SOA service processing module, and an application layer logic implementation module, and the method includes:

[0008] Establishing a communication connection between the underlying protocol stack and an external Ethernet;

[0009] Using the runtime environment, establishing a connection between the underlying protocol stack and the software components in the SOA service processing module;

[0010] Creating a first executable entity in the software component and creating a second executable entity in the application layer logic implementation module;

[0011] Establishing a communication connection between the software component and the application layer logic implementation module;

[0012] Based on the logic development tool, the first executable entity and the second executable entity, the functional logic required by the user is constructed.

[0013] Preferably, establishing a communication connection between the underlying protocol stack and an external Ethernet comprises:

[0014] Get communication interface data;

[0015] Based on the communication interface data, an ETH module, a TCPIP module and a SOMEIP module are respectively configured in the underlying protocol stack to establish a communication connection between the underlying protocol stack and an external Ethernet.

[0016] Preferably, the acquiring of communication interface data comprises:

[0017] Obtain the server configuration information file provided by the vehicle manufacturer;

[0018] The server configuration information file is parsed using a software development tool to obtain communication interface data.

[0019] Preferably, establishing a communication connection between the software component and the application layer logic implementation module includes:

[0020] Setting a first interface in the software component and setting a second interface in the application layer logic implementation module;

[0021] The first interface is communicatively connected to the second interface to establish a communication connection between the software component and the application layer logic implementation module.

[0022] Preferably, the method further comprises:

[0023] In the underlying protocol stack, the software component and the application layer logic implementation module, debugging information assignment functions are respectively constructed; the debugging information assignment function is used to assign debugging information preset for the functional logic when executing the functional logic.

[0024] The second aspect of the embodiment of the present invention discloses a device for building an application layer software architecture based on SOA, which is applied to a vehicle body controller, wherein the vehicle body controller includes: an underlying protocol stack, a runtime environment, a SOA service processing module, and an application layer logic implementation module, and the device includes:

[0025] An external communication unit, used for establishing a communication connection between the underlying protocol stack and an external Ethernet;

[0026] A first establishing unit, configured to establish a connection between the underlying protocol stack and a software component in the SOA service processing module by using the runtime environment;

[0027] A creation unit, configured to create a first executable entity in the software component and a second executable entity in the application layer logic implementation module;

[0028] A second establishing unit, used to establish a communication connection between the software component and the application layer logic implementation module;

[0029] A logic building unit is used to build the functional logic required by the user based on the logic development tool, the first executable entity and the second executable entity.

[0030] Preferably, the external communication unit comprises:

[0031] An acquisition subunit, used for acquiring communication interface data;

[0032] The configuration subunit is used to configure the ETH module, the TCPIP module and the SOMEIP module in the underlying protocol stack respectively based on the communication interface data, so as to establish a communication connection between the underlying protocol stack and the external Ethernet.

[0033] Preferably, the acquisition subunit is specifically used for:

[0034] Obtain the server configuration information file provided by the vehicle manufacturer;

[0035] The server configuration information file is parsed using a software development tool to obtain communication interface data.

[0036] Preferably, the second establishing unit is specifically used to:

[0037] Setting a first interface in the software component and setting a second interface in the application layer logic implementation module;

[0038] The first interface is communicatively connected to the second interface to establish a communication connection between the software component and the application layer logic implementation module.

[0039] Preferably, the device further comprises:

[0040] A construction unit is used to construct a debugging information assignment function in the underlying protocol stack, the software component and the application layer logic implementation module respectively; the debugging information assignment function is used to assign the debugging information preset for the functional logic when executing the functional logic.

[0041] Based on the above-mentioned embodiment of the present invention, a method and device for building an application layer software architecture based on SOA is provided, which is applied to a body controller, wherein the body controller includes: an underlying protocol stack, a runtime environment, an SOA service processing module and an application layer logic implementation module, and the method includes: establishing a communication connection between the underlying protocol stack and an external Ethernet; using the runtime environment, establishing a connection between the underlying protocol stack and a software component in the SOA service processing module; creating a first executable entity in the software component, and creating a second executable entity in the application layer logic implementation module; establishing a communication connection between the software component and the application layer logic implementation module; and building the functional logic required by the user based on the logic development tool, the first executable entity and the second executable entity. In this solution, compared with the prior art, the SOA service processing module is added to realize the layering of the underlying layer and the application layer, and the layered structure makes the entire architecture clearer. When a problem occurs, debugging information can be added to each layer to locate which part has a problem, and when software platform reuse is performed, it is only necessary to modify the receiving interface at the SOA service processing module, so that modular software reuse can be achieved. BRIEF DESCRIPTION OF THE DRAWINGS

[0042] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings required for use in the embodiments or the description of the prior art will be briefly introduced below. Obviously, the drawings described below are only embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on the provided drawings without paying creative work.

[0043] Figure 1 An application layer software architecture diagram based on SOA disclosed in an embodiment of the present invention;

[0044] Figure 2 A flowchart of a method for building an application layer software architecture based on SOA disclosed in an embodiment of the present invention;

[0045] Figure 3 A structural diagram of a device for building an application layer software architecture based on SOA disclosed in an embodiment of the present invention;

[0046] Figure 4 The present invention is a structural diagram of an electronic device disclosed in an embodiment of the present invention. DETAILED DESCRIPTION

[0047] The following will be combined with the drawings in the embodiments of the present invention to clearly and completely describe the technical solutions in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

[0048] In this application, the terms "comprises", "comprising" or any other variations thereof are intended to cover non-exclusive inclusion, so that a process, method, article or device comprising a series of elements includes not only those elements, but also other elements not explicitly listed, or also includes elements inherent to such process, method, article or device. In the absence of further restrictions, an element defined by the sentence "comprising a ..." does not exclude the presence of other identical elements in the process, method, article or device comprising the element.

[0049] As can be seen from the background technology, when the existing SOA application layer software architecture reuses the software on the developed software platform, there is no layered processing between the bottom layer and the application layer. If the bottom layer is changed, the interface of the application layer will also change, which will increase the difficulty of reuse and make it difficult to achieve software platformization. Secondly, the existing SOA application layer software architecture is not clear enough in terms of layers, and the upper layer and the bottom layer cannot be decoupled. The interface of the application layer directly accesses the bottom layer. Once a problem occurs, it will increase the difficulty of troubleshooting the problem.

[0050] Therefore, the embodiment of the present invention discloses a method and device for building an application layer software architecture based on SOA. In this solution, compared with the prior art, a SOA service processing module is added to realize the layering of the bottom layer and the application layer. The layered structure makes the entire architecture clearer. When a problem occurs, debugging information can be added to each layer to locate which part has the problem. When software platform reuse is performed, it is only necessary to modify the receiving interface at the SOA service processing module, so that modular software reuse can be achieved.

[0051] like Figure 1 As shown, it is a diagram of an application layer software architecture based on SOA disclosed in an embodiment of the present invention.

[0052] In the body controller BCM, Ethernet represents the external Ethernet, SOA_Gateway represents the underlying protocol stack, SOA between Ethernet and SOA_Gateway represents the communication channel of the Service-Oriented Architecture, which is the path for service requests and responses between software components, SOA_Handler represents the SOA service processing module, RTE represents the runtime environment, Control Feature SWC represents the application layer logic implementation module, CAN_Driver represents the bus driver module, and CAN represents the bus.

[0053] When using the running software of the above application layer software architecture, the data processing flow is as follows: the external Ethernet transmits the control instruction in the form of an external Ethernet signal to the underlying protocol stack through the SOA communication channel; the underlying protocol stack performs signal analysis on the control instruction, and analyzes the physical signal (such as high and low levels) into a target signal that can be used by the software; in the runtime environment, the target signal is transmitted to the SOA service processing module through the client / sever interface (client / server interface), and the SOA service processing module is responsible for subscription management, service feedback, etc.; in the SOA service processing module, the target signal processed by the SOA service processing module is continued to be transmitted to the application layer logic implementation module by calling the client / sever interface, and the application layer logic implementation module is responsible for service unpacking and the implementation of functional logic.

[0054] Exemplarily, the application layer logic implementation module parses the target signal in the interface, and after arbitrating with other trigger sources (for example, in the window service, the trigger sources include the window buttons and the central control large screen switches), executes the window service and provides feedback that the window service is executable. If other trigger sources trigger the window service at this time, feedback will be given that the window service is not executable.

[0055] It is understandable that the window service can have multiple control paths on the entire vehicle, such as physical window buttons or the vehicle's central control screen. These are the trigger sources of the window service in the software. If the window is currently being controlled by the window buttons, if the central control screen is triggered at this time, it will feedback that the function cannot be executed.

[0056] It should be noted that the runtime environment provides basic communication services and supports communication between software components, such as communication from basic software to upper-level software, and communication between various functional modules in upper-level software.

[0057] It should also be noted that the SOA service processing module is the core service processing module in the SOA architecture. The SOA service processing module is responsible for managing and coordinating the life cycle of services, including service discovery, request processing, load balancing, error handling, etc. The SOA service processing module includes one or more software components Handler SWC, which are responsible for processing specific service requests. Each software component may focus on different services or functions, such as window control, door locking, etc. These software components communicate with the outside world through the SOA service processing module, receive service requests and return results.

[0058] Among them, the SOA service processing module serves as the entry point for service requests and receives service requests (i.e., the target signal mentioned above) from the underlying protocol stack or other sources. The software components inside the SOA service processing module are responsible for specific business logic processing. The SOA service processing module distributes the request to the corresponding software component based on the type or content of the request. After the software component calls the application layer logic implementation module to process the request, it returns the result to the SOA service processing module, and then feeds the result back to the user.

[0059] Based on the above-mentioned embodiment of the present invention, an application layer software architecture based on SOA is disclosed. Figure 2 As shown, it is a flow chart of a method for building an application layer software architecture based on SOA disclosed in an embodiment of the present invention, which is applied to a body controller, and the body controller includes: an underlying protocol stack, a runtime environment, a SOA service processing module and an application layer logic implementation module, including the following steps:

[0060] Step S201: Establish a communication connection between the bottom layer protocol stack and the external Ethernet.

[0061] In step S201 , configuration is performed using the AUTOSAR (Automotive Open System Architecture) standard.

[0062] In the specific implementation process of step S201, the communication interface data is obtained; based on the communication interface data, the ETH module, TCPIP and SOMEIP modules are respectively configured in the underlying protocol stack to establish a communication connection between the underlying protocol stack and the external Ethernet.

[0063] Among them, the ETH module, TCPIP and SOMEIP modules belong to the BSW project (Basic Software project, which refers to the basic software layer in the AUTOSAR architecture, which provides basic functions such as hardware abstraction and communication services), that is, they belong to the basic software modules. The ETH module is used to implement Ethernet communication in the internal network of the car. The TCPIP module, that is, the Transmission Control Protocol / Internet Protocol module, is used to provide the basis for network communication. The SOMEIP module, that is, the Service-Oriented MiddlewarE over IP module, is used to realize service discovery and communication in the automotive electronic system.

[0064] It should be noted that the communication interface data can be obtained by obtaining the service configuration information file Service ARXML provided by the vehicle manufacturer OEM (original equipment manufacturer), and then using the software development tool Vector to parse the server configuration information file.

[0065] ARXML is the file format of the AUTOSAR architecture description language, which is used to define services and interfaces between automotive electronic control units (ECUs). The Service ARXML file contains the description and configuration information of the service.

[0066] Step S202: using the runtime environment, establishing a connection between the underlying protocol stack and the software components in the SOA service processing module.

[0067] In step S202, a Port Interface connection is established between the underlying protocol stack and the Handler SWC.

[0068] Among them, in the AUTOSAR framework, Port Interface provides a standardized interface definition, including the type, format and method of data or service transmission.

[0069] It can be understood that a communication connection is established between the bottom layer (bottom layer protocol stack) and the software components in the SOA service processing module to ensure that the bottom layer signal (which can be understood as the service instruction for raising and lowering the window) can be transmitted to the software components.

[0070] Step S203: creating a first executable entity in the software component, and creating a second executable entity in the application layer logic implementation module.

[0071] In step S203, the executable entity refers to the runnable in AUTOSAR. The runnable refers to a code segment that can be independently scheduled for execution in the operating system, usually a function. The function can be guaranteed to run through a function call, and the software logic can be built in this function.

[0072] Step S204: Establish a communication connection between the software component and the application layer logic implementation module.

[0073] In the specific implementation process of step S204, a first interface is set in the software component, and a second interface is set in the application layer logic implementation module; the first interface is communicatively connected to the second interface to establish a communication connection between the software component and the application layer logic implementation module.

[0074] The first interface and the second interface may be client (Client) or server (Server) interfaces, which are used for service invocation.

[0075] The purpose of connecting the first interface to the second interface is to ensure that the software component can communicate with the application layer logic implementation module. These interfaces are the basis of communication and allow service requests to be passed. It can be understood that the service instructions for window lifting and lowering are passed to the application layer logic implementation module.

[0076] Step S205: Building the functional logic required by the user based on the logic development tool, the first executable entity and the second executable entity.

[0077] In step S205, which belongs to the AUTOSAR development process, the logic development tool may be Simulink / Stateflow.

[0078] In the specific implementation process of step S205, the software components and application layer logic implementation modules are imported into Simulink / Stateflow, and logic is constructed based on the first executable entity and the second executable entity in the software components and application layer logic implementation modules to realize the specific functions required by the customer, such as raising and lowering the car windows.

[0079] It should be noted that Simulink is a graphical programming environment for simulating, analyzing and designing dynamic systems. It allows developers to build models by dragging and dropping modules, which can represent mathematical operations, control systems, signal processing, etc. Stateflow is a part of Simulink, which is used to design and simulate state-based systems. It provides a graphical way to define the state transitions and behaviors of the system, which is very suitable for implementing complex logic control.

[0080] Understandably, it is necessary to use Simulink / Stateflow to implement specific functions according to customer needs. For example, if the requirement is to control the raising and lowering of the car window, the developer needs to design a state machine in Stateflow to define the behavior of the car window in different states, such as raising, lowering, stopping, etc.

[0081] In one embodiment, the debugging information assignment function is constructed in the bottom layer protocol stack, software component and application layer logic implementation module respectively.

[0082] The debugging information assignment function is used to assign the debugging information preset for the functional logic when executing the functional logic.

[0083] Through the above method, when there is a problem in the software operation, it is possible to clearly locate which part has the problem.

[0084] For example, variable assignment (i.e., debugging information assignment function) is added to the software running path. For example, variable A (i.e., debugging information) is assigned a value of 1 if the software runs through path 1, and a value of 2 if the software runs through path 2, and so on. When a problem occurs, the value change of variable A can be used to see how the software runs. Because debugging information is added at each level, the value change of variable A can be used to see which part has a problem.

[0085] Based on the method for building an application layer software architecture based on SOA disclosed in the above-mentioned embodiment of the present invention, a communication connection between the underlying protocol stack and the external Ethernet is established; a connection between the underlying protocol stack and the software component in the SOA service processing module is established by using the runtime environment; a first executable entity is created in the software component, and a second executable entity is created in the application layer logic implementation module; a communication connection between the software component and the application layer logic implementation module is established; based on the logic development tool, the first executable entity and the second executable entity, the functional logic required by the user is built. In this solution, compared with the prior art, the SOA service processing module is added to realize the layering of the underlying layer and the application layer. The layered structure makes the entire architecture clearer. When a problem occurs, debugging information can be added to each layer to locate which part has a problem. When software platform reuse is performed, it is only necessary to modify the receiving interface at the SOA service processing module, so that modular software reuse can be achieved.

[0086] Corresponding to the method for building an application layer software architecture based on SOA disclosed in the above embodiment of the present invention, Figure 3 As shown, it is a structural diagram of an application layer software architecture building device based on SOA disclosed in an embodiment of the present invention, including: an external communication unit 301, a first building unit 302, a creation unit 303, a second building unit 304 and a logic building unit 305.

[0087] The external communication unit 301 is used to establish a communication connection between the bottom layer protocol stack and the external Ethernet.

[0088] In one embodiment, the external communication unit 301 includes:

[0089] The acquisition subunit is used to acquire communication interface data.

[0090] The configuration subunit is used to configure the ETH module, the TCPIP module and the SOMEIP module in the bottom protocol stack respectively based on the communication interface data, so as to establish a communication connection between the bottom protocol stack and the external Ethernet.

[0091] In one embodiment, the obtaining subunit is specifically used for:

[0092] Obtain the server configuration information file provided by the vehicle manufacturer;

[0093] Use software development tools to parse the server configuration information file and obtain communication interface data.

[0094] The first establishing unit 302 is used to establish a connection between the underlying protocol stack and the software components in the SOA service processing module by using the runtime environment.

[0095] The creation unit 303 is used to create a first executable entity in the software component and create a second executable entity in the application layer logic implementation module.

[0096] The second establishing unit 304 is used to establish a communication connection between the software component and the application layer logic implementation module.

[0097] In one embodiment, the second establishing unit 304 is specifically configured to:

[0098] Setting a first interface in the software component and setting a second interface in the application layer logic implementation module;

[0099] The first interface is communicatively connected to the second interface to establish a communication connection between the software component and the application layer logic implementation module.

[0100] The logic building unit 305 is used to build the functional logic required by the user based on the logic development tool, the first executable entity and the second executable entity.

[0101] In one embodiment, the device further comprises:

[0102] The construction unit is used to construct the debugging information assignment function in the underlying protocol stack, software component and application layer logic implementation module respectively; the debugging information assignment function is used to assign the debugging information preset for the functional logic when executing the functional logic.

[0103] Based on the above-mentioned embodiment of the present invention, a device for building an application layer software architecture based on SOA is disclosed, establishing a communication connection between the underlying protocol stack and the external Ethernet; using the runtime environment, establishing a connection between the underlying protocol stack and the software component in the SOA service processing module; creating a first executable entity in the software component, and creating a second executable entity in the application layer logic implementation module; establishing a communication connection between the software component and the application layer logic implementation module; building the functional logic required by the user based on the logic development tool, the first executable entity and the second executable entity. In this solution, compared with the prior art, the SOA service processing module is added to realize the layering of the underlying layer and the application layer. The layered structure makes the entire architecture clearer. When a problem occurs, debugging information can be added to each layer to locate which part has a problem. When software platform reuse is performed, it is only necessary to modify the receiving interface at the SOA service processing module, so that modular software reuse can be achieved.

[0104] The present invention also provides an electronic device, please refer to Figure 4 , the electronic device includes a memory 401 and a processor 402.

[0105] Wherein, the memory 401 is used to store computer programs;

[0106] The processor 402 is used to execute a computer program, specifically to implement the method for building an application layer software architecture based on SOA provided in any embodiment of the present application.

[0107] The present application also provides a computer storage medium for storing a computer program. When the computer program is executed, it is specifically used to implement the method for building an application layer software architecture based on SOA provided in any embodiment of the present application.

[0108] Each embodiment in this specification is described in a progressive manner, and the same or similar parts between the embodiments can refer to each other, and each embodiment focuses on the differences from other embodiments. In particular, for the system or system embodiment, since it is basically similar to the method embodiment, the description is relatively simple, and the relevant parts can refer to the partial description of the method embodiment. The system and system embodiments described above are merely schematic, wherein the units described as separate components may or may not be physically separated, and the components displayed as units may or may not be physical units, that is, they may be located in one place, or they may be distributed on multiple network units. Some or all of the modules may be selected according to actual needs to achieve the purpose of the scheme of this embodiment. Ordinary technicians in this field can understand and implement it without creative work.

[0109] Professionals may further appreciate that the units and algorithm steps of each example described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, computer software, or a combination of the two. In order to clearly illustrate the interchangeability of hardware and software, the composition and steps of each example have been generally described in the above description according to function. Whether these functions are performed in hardware or software depends on the specific application and design constraints of the technical solution. Professionals and technicians may use different methods to implement the described functions for each specific application, but such implementation should not be considered to be beyond the scope of the present invention.

[0110] The above description of the disclosed embodiments enables one skilled in the art to implement or use the present invention. Various modifications to these embodiments will be apparent to one skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of the present invention. Therefore, the present invention will not be limited to the embodiments shown herein, but rather to the widest scope consistent with the principles and novel features disclosed herein.

Claims

1. A method for building an application layer software architecture based on SOA, characterized in that: Applied to a vehicle body controller, the vehicle body controller includes: an underlying protocol stack, a runtime environment, a SOA service processing module and an application layer logic implementation module, the method includes: Establishing a communication connection between the underlying protocol stack and an external Ethernet; Using the runtime environment, establishing a connection between the underlying protocol stack and the software components in the SOA service processing module; Creating a first executable entity in the software component and creating a second executable entity in the application layer logic implementation module; Establishing a communication connection between the software component and the application layer logic implementation module; Based on the logic development tool, the first executable entity and the second executable entity, the functional logic required by the user is constructed.

2. The method according to claim 1, characterized in that The establishing of a communication connection between the bottom layer protocol stack and the external Ethernet comprises: Get communication interface data; Based on the communication interface data, an ETH module, a TCPIP module and a SOMEIP module are respectively configured in the underlying protocol stack to establish a communication connection between the underlying protocol stack and an external Ethernet.

3. The method according to claim 2, characterized in that The acquiring of communication interface data comprises: Obtain the server configuration information file provided by the vehicle manufacturer; The server configuration information file is parsed using a software development tool to obtain communication interface data.

4. The method according to claim 1, characterized in that: The establishing of a communication connection between the software component and the application layer logic implementation module comprises: Setting a first interface in the software component and setting a second interface in the application layer logic implementation module; The first interface is communicatively connected to the second interface to establish a communication connection between the software component and the application layer logic implementation module.

5. The method according to any one of claims 1 to 4, characterized in that: The method further comprises: In the underlying protocol stack, the software component and the application layer logic implementation module, debugging information assignment functions are respectively constructed; the debugging information assignment function is used to assign debugging information preset for the functional logic when executing the functional logic.

6. A device for building an application layer software architecture based on SOA, characterized in that: Applied to a vehicle body controller, the vehicle body controller includes: an underlying protocol stack, a runtime environment, a SOA service processing module and an application layer logic implementation module, and the device includes: An external communication unit, used for establishing a communication connection between the underlying protocol stack and an external Ethernet; A first establishing unit, configured to establish a connection between the underlying protocol stack and a software component in the SOA service processing module by using the runtime environment; A creation unit, configured to create a first executable entity in the software component and a second executable entity in the application layer logic implementation module; A second establishing unit, used to establish a communication connection between the software component and the application layer logic implementation module; A logic building unit is used to build the functional logic required by the user based on the logic development tool, the first executable entity and the second executable entity.

7. The device according to claim 6, characterized in that The external communication unit comprises: An acquisition subunit, used for acquiring communication interface data; The configuration subunit is used to configure the ETH module, the TCPIP module and the SOMEIP module in the underlying protocol stack respectively based on the communication interface data, so as to establish a communication connection between the underlying protocol stack and the external Ethernet.

8. The device according to claim 7, characterized in that The acquisition subunit is specifically used for: Obtain the server configuration information file provided by the vehicle manufacturer; The server configuration information file is parsed using a software development tool to obtain communication interface data.

9. The device according to claim 6, characterized in that The second establishing unit is specifically used for: Setting a first interface in the software component and setting a second interface in the application layer logic implementation module; The first interface is communicatively connected to the second interface to establish a communication connection between the software component and the application layer logic implementation module.

10. The device according to any one of claims 6 to 9, characterized in that: The device also includes: A construction unit is used to construct a debugging information assignment function in the underlying protocol stack, the software component and the application layer logic implementation module respectively; the debugging information assignment function is used to assign the debugging information preset for the functional logic when executing the functional logic.

Images