在SAP接口编程之 NCo3.0系列(06) : 会话管理 这篇文章中，对会话管理的相关知识点已经说得很详细了，请参考。现在用JCo3.0来实现。

如果SAP中多个函数需要在一个session中运行，需要JCoContext来提供保证。如果在同一个线程中，大体模式这样：

  1. JCoContext.begin(sapDestination);
  3. fm1.execute(sapDestination);
  4. fm2.execute(sapDestination);
  6. JCoContext.end(destination);

begin()和end()之间的函数execute之后，SAP不会释放连接，确保同一个session之中。

第二种情况：如果不同的函数不在同一个线程中，需要由开发人员实现SessionReferenceProvider接口，在类中提供session id。逻辑跟nco3.0也是一样的。JCo3.0提供了一个示例代码，但是搞的太复杂，我弄了一个简单的，方便理解。

我们要使用的函数是从标准系统函数INCREMENT_COUNTER
，GET_COUNTER拷贝而来的。在SAP系统中INCREMENT_COUNTER
，GET_COUNTER在同一个function group中，共享一个变量count（计数器），每次运行INCREMENT_COUNTER
, count就会加一，GET_COUNTER函数
可以获得这个count。因为这两个函数不能被远程调用，所以我们将这两个函数拷贝出另外两个函数ZINCREMENT_COUNTER和ZGET_COUNTER。

首先我们把两个函数定义在一个类RfcFunctions中：

  1. package jco3.demo6;
  3. import com.sap.conn.jco.JCoDestination;
  4. import com.sap.conn.jco.JCoException;
  5. import com.sap.conn.jco.JCoFunction;
  7. public class RfcFunctions
  8. {
  9.     public static int runGetCounter(JCoDestination dest) throws JCoException
  10.     {
  11.         JCoFunction counterFM = dest.getRepository().getFunction("ZGET_COUNTER");
  12.         counterFM.execute(dest);
  13.         int counter = (int) counterFM.getExportParameterList().getValue("GET_VALUE");
  15.         return counter;        
  16.     }
  18.     public static void runIncrement(JCoDestination dest) throws JCoException
  19.     {
  20.         JCoFunction increment = dest.getRepository().getFunction("ZINCREMENT_COUNTER");
  21.         increment.execute(dest);        
  22.     }
  23. }

然后编写测试类进行测试：

  1. package jco3.demo6;
  3. import com.sap.conn.jco.JCoContext;
  4. import com.sap.conn.jco.JCoDestination;
  5. import com.sap.conn.jco.JCoDestinationManager;
  6. import com.sap.conn.jco.JCoException;
  8. public class TestSessionSameThread
  9. {
  10.     public static void main(String[] args) throws JCoException, InterruptedException
  11.     {        
  12.         // get JCoDestination object instance
  13.         JCoDestination destination = JCoDestinationManager.getDestination("ECC");
  15.         // make sure the two functions will be executed in the same session
  16.         JCoContext.begin(destination);
  18.         // Before increment
  19.         System.out.println("Before execution of ZINCREMENT_COUNTER:");
  20.         System.out.println("Counter:" + RfcFunctions.runGetCounter(destination));
  22.         // Run incrementCounter five times
  23.         for(int i = 0; i < 5; i++){
  24.             RfcFunctions.runIncrement(destination);
  25.             System.out.println("Add:" + (i + 1));
  26.         }
  28.         // After increment    
  29.         System.out.println("After execution of ZINCREMENT_COUNTER:");
  30.         System.out.println("Counter:" + RfcFunctions.runGetCounter(destination));    
  32.         // release the connection 
  33.         JCoContext.end(destination);
  34.     }
  35. }

代码很直观，就不多说了。函数执行前，counter的值为0，运行函数5次之后，counter的值为5。如果我们注释掉JCoContext.begin(destination);和JCoContext.end(destination);，可以对比出不同的效果。

如果在不同的线程中执行不同的函数，需要开发者提供session id。我准备将两个函数放在不同的线程中：

  • 在JVM的主线程中调用ZGET_COUNTER，查看counter的结果。
  • 在另外一个线程中运行ZINCREMENT_COUNTER，两个线程通过JCoContext，保持在同一个session ID下。

JCoSessionRefence实现类的主要作用是提供session ID:

  1. package jco3.session;
  3. import java.util.concurrent.atomic.AtomicInteger;
  4. import com.sap.conn.jco.ext.JCoSessionReference;
  6. public class JCoSessionRefenceImpl implements JCoSessionReference
  7. {
  8.     private AtomicInteger atomInt = new AtomicInteger(0);
  9.     private String id = "session"+String.valueOf(atomInt.addAndGet(1));
  11.     public void contextFinished()
  12.     {        
  13.     }
  15.     public void contextStarted()
  16.     {    
  17.     }
  19.     @Override
  20.     public String getID()
  21.     {
  22.         /**
  23.          * We need to override getID() method
  24.          */
  26.         return id;
  27.     }
  28. }

在SessionReferenceProvider接口的实现类中，改写getCurrentSessionReference()方法，获取上面定义的JCoSessionRefence，从而获得session ID。其他方法保持不动。

  1. package jco3.session;
  3. import com.sap.conn.jco.ext.JCoSessionReference;
  4. import com.sap.conn.jco.ext.SessionException;
  5. import com.sap.conn.jco.ext.SessionReferenceProvider;
  7. public class SessionReferencProviderImpl implements SessionReferenceProvider
  8. {
  10.     @Override
  11.     public JCoSessionReference getCurrentSessionReference(String scopeType)
  12.     {
  13.         /**
  14.          *  We need to override getCurrentSessionReference() method
  15.          */
  17.         JCoSessionRefenceImpl sessionRef = new JCoSessionRefenceImpl();
  18.         return sessionRef;
  19.     }
  21.     @Override
  22.     public boolean isSessionAlive(String sessionID)
  23.     {
  24.         return false;
  25.     }
  27.     public void jcoServerSessionContinued(String sessionID) throws SessionException
  28.     {        
  29.     }
  31.     public void jcoServerSessionFinished(String sessionID)
  32.     {        
  33.     }
  35.     public void jcoServerSessionPassivated(String sessionID) throws SessionException
  36.     {        
  37.     }
  39.     public JCoSessionReference jcoServerSessionStarted() throws SessionException
  40.     {
  41.         return null;
  42.     }
  43. }

注册SessionReferenceProvider接口的实现类，这样JCoDestination就有状态管理功能了。

  1. package jco3.session;
  3. import com.sap.conn.jco.JCoDestination;
  4. import com.sap.conn.jco.JCoDestinationManager;
  5. import com.sap.conn.jco.JCoException;
  6. import com.sap.conn.jco.ext.Environment;
  7. import com.sap.conn.jco.ext.SessionReferenceProvider;
  9. public class DestinationProvider
  10. {
  11.     public static JCoDestination getDestination() throws JCoException
  12.     {
  13.         // create an instance of SessionReferenceProvider
  14.         // and register in environment
  15.         SessionReferenceProvider provider = new SessionReferencProviderImpl();
  16.         Environment.registerSessionReferenceProvider(provider);
  18.         JCoDestination destination = JCoDestinationManager.getDestination("ECC");
  20.         return destination;
  21.     }
  22. }

定义WorkingThread, 从Thread类继承，在这个线程中执行函数ZINCREMENT_COUNTER 5次。

  1. package jco3.demo6;
  3. import com.sap.conn.jco.JCoDestination;
  4. import com.sap.conn.jco.JCoException;
  6. public class WorkingThread extends Thread
  7. {
  8.     private boolean doneSignal;
  9.     private JCoDestination destination;
  11.     // constructor
  12.     public WorkingThread(JCoDestination destination, boolean doneSignal)
  13.     {
  14.         this.destination = destination;
  15.         this.doneSignal = doneSignal;
  16.     }
  18.     public boolean hasDone()
  19.     {
  20.         return doneSignal;
  21.     }
  23.     @Override
  24.     public void run()
  25.     {
  26.         /**
  27.          * run method of runIncrement() for five times
  28.          */
  30.         for (int i = 0; i < 5; i++){
  31.             try {
  32.                 RfcFunctions.runIncrement(this.destination);    
  33.                 System.out.println("Run " + (i+1) + " times.");
  34.             } catch (JCoException e) {                
  35.                 e.printStackTrace();
  36.             }
  37.         }
  39.         this.doneSignal = true;
  40.     }    
  41. }

doneSignal用于标识该线程是否结束。线程本身结束，是run()方法运行完毕。

好了，最后来测试在多线程中函数调用：

  1. package jco3.demo6;
  3. import com.sap.conn.jco.JCoContext;
  4. import com.sap.conn.jco.JCoDestination;
  5. import com.sap.conn.jco.JCoException;
  6. import jco3.session.DestinationProvider;
  8. public class TestSAPSessionMultiThread
  9. {    
  10.     public static void main(String[] args) throws JCoException, InterruptedException
  11.     {
  12.         /**
  13.          * Run ZINCREMENT_COUNTER & ZGET_COUNTER functions in
  14.          * different threads in a stateful way.
  15.          * 
  16.          * The SAP will keep a session id which was created in
  17.          * JCoSessionReferenceImpl class 
  18.          * and used in SessionReferenceProviderImpl class.
  19.          * 
  20.          * Before using, SessionReferenceProviderImpl class should be
  21.          * registered using Environment.registerSessionReferenceProvider() method.
  22.          */
  24.         // get JCoDestination object instance
  25.         JCoDestination destination = DestinationProvider.getDestination();
  27.         // make sure the two functions will be executed in the same session
  28.         JCoContext.begin(destination);
  30.         // Before increment
  31.         System.out.println("Before execution of ZINCREMENT_COUNTER:");
  32.         System.out.println("Counter:" + RfcFunctions.runGetCounter(destination));
  34.         // start a new Thread in which function ZINCREMENT_COUNTER
  35.         // will be executed for five times
  36.         WorkingThread workingThread = new WorkingThread(destination, false);
  37.         workingThread.start();
  39.         // wait and switch thread
  40.         Thread.sleep(1000);
  42.         // After increment
  43.         if (workingThread.hasDone() == true){
  44.             System.out.println("After execution of ZINCREMENT_COUNTER:");
  45.             System.out.println("Counter:" + RfcFunctions.runGetCounter(destination));    
  46.         }
  48.         // release the connection 
  49.         JCoContext.end(destination);
  50.     }
  51. }

与前面同一个线程中代码的主要区别是：
定义一个WorkingThread类的实例，然后启动线程：

  1. WorkingThread workingThread = new WorkingThread(destination, false);
  2. workingThread.start();

然后通过Thread.sleep(), 将线程切换到workingThread中执行，执行完毕再回到主线程显示结果。

文／StoneWM（简书作者）
原文链接：http://www.jianshu.com/p/2ce28196483c
著作权归作者所有，转载请联系作者获得授权，并标注“简书作者”。

版权声明：本文为zfswff原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/zfswff/p/5671160.html