How to simulate and implement Java Spring dependency injection in ABAP (picture and text)

The content of this article is about how to simulate and implement Java Spring dependency injection in ABAP (pictures and texts). It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you. .

Dependency Injection- Dependency injection is widely used in the Java Spring framework. Through dependency injection, we don't have to tediously initialize dependent resources in the application code, which is very convenient.

So can ABAP also support dependency injection from the language level and enjoy the convenience brought by this design idea? Let's give it a try.

Try the scene

In real life, every light has a switch control. Press the switch and the light is turned on; press it again and the light goes out.

Let’s not look at the conventional implementation using dependency injection:

Design an ABAP interface ZIF_SWITCHABLE, providing two methods, corresponding to on and off respectively.

Naturally, I have an ABAP class ZCL_LAMP that implements the above interface. Each instance of ZCL_LAMP is a lamp.

CLASS ZCL_LAMP IMPLEMENTATION.
method ZIF_SWITCHABLE~OFF.
WRITE: / 'lamp off'.
endmethod.
method ZIF_SWITCHABLE~ON.
WRITE: / 'lamp on'.
endmethod.
ENDCLASS.

Design a switch class. This class has a member variable mo_switchable, pointing to the ZIF_SWITCHABLE interface.

The switch has a "press" method. After pressing, if the current state is on, then call the off method of the mo_switchable member to turn it off, and set the switch state to off. vice versa.

METHOD push.
IF isswitchon = abap_true.
mo_switchable->off( ).
isswitchon = abap_false.
ELSE.
mo_switchable->on( ).
isswitchon = abap_true.
ENDIF.
ENDMETHOD.

Provide a setter method to inject the passed variable of type ZIF_SWITCHABLE into the member variable mo_switchable.

method SET_SWITCHABLE.

mo_switchable = io_switchable.

endmethod.

I put the two classes created so far: ZCL_LAMP and ZCL_SWITCH into package $ZDEV_INVERSION.

Consumption code of the ABAP Summer framework

As can be seen from the code below, ZCL_SWITCH and ZCL_LAMP creates a strong dependency. This dependency is manually injected by the application developer by calling the set method.

To summarize, which of the codes in the above figure can be completely avoided in Java Spring through the idea of ​​dependency injection.

line 8: Manually create an instance of ZCL_LAMP (light).

line 9: Manually create an instance of ZCL_SWITCH (switch).

Line 11: Call the set method to manually inject the dependencies of lights and switches.

Using the ABAP Summer framework to implement dependency injection

I used ABAP to simulate the Java Spring dependency injection framework, and developed a prototype named ABAP Summer, which is compatible with Java Spring echoes.

First think about how to implement this simple example with Java Spring. A Java programmer can easily write the following code. Using Spring's @Inject annotation, we do not need to manually instantiate ISwitchable and call the set method to establish dependencies. Everything is implemented by the Spring framework for us.

Now, how to use ABAP to achieve these "magic"?

1. Add the annotation @Inject in the description field of the member variable mo_switchable of the ZCL_SWITCH class. The purpose is to tell the ABAP Summer framework that I hope that the mo_switchable member can automatically be injected with a correct dependency. What kind of dependency is correct? How does the Summer framework know how to inject? Please read on.

Note: The ABAP language is different from Java and cannot support annotations at the language level, so the @Inject maintained on the Description field here is just one simulation.

2. Let’s first look at the ABAP consumption code after using dependency injection. Does it feel a lot cleaner all of a sudden?

data(summer) = zcl_summer=>get_instance( ).
data(lo_switch) = cast zcl_switch( summer->get_bean( EXPORTING iv_bean_name = 'ZCL_SWITCH' ) ).
lo_switch->push( ).
lo_switch->push( ).

The following figure is a comparison of two sets of consumption codes based on ABAP conventional implementation and ABAP dependency injection idea. It can be clearly found that after ABAP dependency injection is adopted,

The three manual operations mentioned before are completely avoided. The member variable mo_switchable in the switch instance returned by the GET_BEAN method contains the automatically injected instance of the ZCL_LAMP class.

line 8: Manually create an instance of ZCL_LAMP (light).

line 9: Manually create an instance of ZCL_SWITCH (switch).

Line 11: Call the set method to manually inject the dependencies of lights and switches.

Let us take another look at the authentic consumption code in Java Spring to ensure that the ABAP Summer we invented is indeed the original dependency injection.

The implementation principle of ABAP Summer dependency injection

The implementation of this ABAP dependency injection framework is in my On github:

https://github.com/i042416/je...

About Java Spring dependency injection Explain, there are many wonderfully written books on the Internet.

The following is the core implementation of ABAP Summer dependency injection, refer to the explanation of Java Spring in the book above.

The above is the detailed content of How to simulate and implement Java Spring dependency injection in ABAP (picture and text). For more information, please follow other related articles on the PHP Chinese website!