Show TOC

Example documentationProcessing a tRFC/bgRFC Call Locate this document in the navigation structure

 

If the following ABAP statement is called up:

Syntax Syntax

  1. CALL FUNCTION 'STFC_CONNECTION'
   DESTINATION RFCDEST
      IN BACKGROUND TASK // (bgRFC: IN BACKGROUND UNIT)
End of the code.

fRFC or bgRFC processing takes place.

Note Note

The prerequisite for this is the implementation of a separate JCoServerTIDHandler.

End of the note.

This means that the following call sequence is triggered:

  1. boolean checkTID(String tid) //against your JCoServerTIDHandler implementation

    Note Note

    At this point, the application must be informed that the next call is to be processed with this TID. The application must return the value true in order to signal that execution is possible.

    End of the note.

  2. calls the function module.

  3. commit(String tid) or rollback(String tid) depends on the result of the function distribution. If handleRequest has not thrown any exception, onCommit is called.

  4. protected void methods onConfirmTID(String tid).

    Note Note

    At this point, the application is informed that execution has been ended by the call with the specified TID. Under certain circumstances, this call might be received in a different Listener or, if problems arise, may not be received in the ABAP backend system at all.

    End of the note.

Syntax Syntax

tRFC Call

    2. 

    3. 

  3. static class MyTIDHandler implements JCoServerTIDHandler
    4. 

  4.     {
    5. 

  5.         
    6. 

  6.         Map<String, TIDState> availableTIDs = new Hashtable<String, TIDState>();
    7. 

  7.         
    8. 

  8.         public boolean checkTID(JCoServerContext serverCtx, String tid)
    9. 

  9.         {
    10. 

  10.         // This example uses a hash table to store status information.                 
    11. 

  11.         // Usually you would use a database. If the DB is down,  
    12. 

  12.         // throw a RuntimeException at this point. JCo will then abort  
    13. 

  13.             //the tRFC and the SAP backend will try again later.
    14. 

    15. 

  15.            System.out.println("TID Handler: checkTID for " + tid);
    16. 

  16.             TIDState state = availableTIDs.get(tid);
    17. 

  17.             if(state == null)
    18. 

  18.             {
    19. 

  19.                 availableTIDs.put(tid, TIDState.CREATED);
    20. 

  20.                 return true;
    21. 

  21.             }
    22. 

  22.             
    23. 

  23.             if(state == TIDState.CREATED || state == TIDState.ROLLED_BACK)
    24. 

  24.                 return true;
    25. 

    26. 

  26.             return false;
    27. 

  27.             // "true" means that JCo will now execute the transaction,  
    28. 

  28.             // "false" means that we have already executed this
    29. 

  29.             // transaction previously, so JCo will skip the 
    30. 

  30.             // handleRequest() step and will immediately return an OK  
    31. 

  31.             // code to SAP.
    32. 

  32.         }
    33. 

  33.         
    34. 

  34.         public void commit(JCoServerContext serverCtx, String tid)
    35. 

  35.         {
    36. 

  36.             System.out.println("TID Handler: commit for " + tid);
    37. 

  37.             
    38. 

  38.             // react on commit e.g. commit on the database
    39. 

  39.             // if necessary throw a RuntimeException, if the commit  
    40. 

  40.             // was not possible
    41. 

  41.             availableTIDs.put(tid, TIDState.COMMITTED);
    42. 

  42.         }
    43. 

  43.         
    44. 

  44.         public void rollback(JCoServerContext serverCtx, String tid)
    45. 

  45.         {
    46. 

  46.             System.out.println("TID Handler: rollback for " + tid);
    47. 

  47.             availableTIDs.put(tid, TIDState.ROLLED_BACK);
    48. 

  48.             
    49. 

  49.             // react on rollback e.g. rollback on the database
    50. 

  50.         }
    51. 

  51.         
    52. 

  52.         public void confirmTID(JCoServerContext serverCtx, String tid)
    53. 

  53.         {
    54. 

  54.             System.out.println("TID Handler: confirmTID for " + tid);
    55. 

  55.             
    56. 

  56.             try
    57. 

  57.             {
    58. 

  58.                 // clean up the resources
    59. 

  59.             }
    60. 

  60.             // catch(Throwable t) {} //partner wont react on an 
    61. 

  61.             // exception at this point
    62. 

  62.             finally
    63. 

  63.             {
    64. 

  64.                 availableTIDs.remove(tid);
    65. 

  65.             }
    66. 

  66.         }
    67. 

  67.         
    68. 

  68.         public void execute(JCoServerContext serverCtx)
    69. 

  69.         {
    70. 

  70.             String tid = serverCtx.getTID();
    71. 

  71.             if(tid != null)
    72. 

  72.             {
    73. 

  73.                 System.out.println("TID Handler: execute for " + tid);
    74. 

  74.                 availableTIDs.put(tid, TIDState.EXECUTED);
    75. 

  75.             }
    76. 

  76.         }
    77. 

  77.         
    78. 

  78.         private enum TIDState
    79. 

  79.         {
    80. 

  80.             CREATED, EXECUTED, COMMITTED, ROLLED_BACK, CONFIRMED;
    81. 

  81.         }
    82. 

  82.     }
    83. 

  83.     
    84. 

  84.     static void step3SimpleTRfcServer()
    85. 

  85.     {
    86. 

  86.         JCoServer server;
    87. 

  87.         try
    88. 

  88.         {
    89. 

  89.             server = JCoServerFactory.getServer(SERVER_NAME1);
    90. 

  90.         }
    91. 

  91.         catch(JCoException ex)
    92. 

  92.         {
    93. 

  93.             throw new RuntimeException("Unable to create the server " + SERVER_NAME1 + ", because of " + ex.getMessage(), ex);
    94. 

  94.         }
    95. 

  95.         
    96. 

  96.         JCoServerFunctionHandler stfcConnectionHandler = new StfcConnectionHandler();
    97. 

  97.         DefaultServerHandlerFactory.FunctionHandlerFactory factory = new DefaultServerHandlerFactory.FunctionHandlerFactory();
    98. 

  98.         factory.registerHandler("STFC_CONNECTION", stfcConnectionHandler);
    99. 

  99.         server.setCallHandlerFactory(factory);
    100. 

  100.         
    101. 

  101.         // in addition to step 1
    102. 

  102.         myTIDHandler = new MyTIDHandler();
    103. 

  103.         server.setTIDHandler(myTIDHandler);
    104. 

  104.         
    105. 

  105.         server.start();
    106. 

  106.         System.out.println("The program can be stopped using <ctrl>+<c>");
    107. 

  107.     }
    108. 

  108.     
    109. 

  109.     public static void main(String[] a)
    110. 

  110.     {
    111. 

  111.         // step1SimpleServer();
    112. 

  112.         step2SimpleServer();
    113. 

  113.         // step3SimpleTRfcServer();
    114. 

  114.     }
    115. 

  115. }
    116. 

    117. 

    118. 



End of the code.