SAP接口编程之 JCo3.0系列(04) : 会话管理

桃扇骨 2022-02-26 00:30 339阅读 0赞

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

# 1. JCoContext #

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

JCoContext.begin(sapDestination);
    
    fm1.execute(sapDestination);
    fm2.execute(sapDestination);
    
    JCoContext.end(destination);

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

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

# 2. SAP函数 #

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

# 3. 同一线程中执行函数 #

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

package jco3.demo6;
    
    import com.sap.conn.jco.JCoDestination;
    import com.sap.conn.jco.JCoException;
    import com.sap.conn.jco.JCoFunction;
    
    public class RfcFunctions
    {
        public static int runGetCounter(JCoDestination dest) throws JCoException
        {
            JCoFunction counterFM = dest.getRepository().getFunction("ZGET_COUNTER");
            counterFM.execute(dest);
            int counter = (int) counterFM.getExportParameterList().getValue("GET_VALUE");
            
            return counter;     
        }
        
        public static void runIncrement(JCoDestination dest) throws JCoException
        {
            JCoFunction increment = dest.getRepository().getFunction("ZINCREMENT_COUNTER");
            increment.execute(dest);        
        }
    }

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

package jco3.demo6;
    
    import com.sap.conn.jco.JCoContext;
    import com.sap.conn.jco.JCoDestination;
    import com.sap.conn.jco.JCoDestinationManager;
    import com.sap.conn.jco.JCoException;
    
    public class TestSessionSameThread
    {
        public static void main(String[] args) throws JCoException, InterruptedException
        {       
            // get JCoDestination object instance
            JCoDestination destination = JCoDestinationManager.getDestination("ECC");
            
            // make sure the two functions will be executed in the same session
            JCoContext.begin(destination);
            
            // Before increment
            System.out.println("Before execution of ZINCREMENT_COUNTER:");
            System.out.println("Counter:" + RfcFunctions.runGetCounter(destination));
            
            // Run incrementCounter five times
            for(int i = 0; i < 5; i++){
                RfcFunctions.runIncrement(destination);
                System.out.println("Add:" + (i + 1));
            }
            
            // After increment  
            System.out.println("After execution of ZINCREMENT_COUNTER:");
            System.out.println("Counter:" + RfcFunctions.runGetCounter(destination));   
            
            // release the connection 
            JCoContext.end(destination);
        }
    }

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

# 4. 不同线程中执行函数 #

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

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

## 4.1 实现JCoSessionReference接口 ##

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

package jco3.session;
    
    import java.util.concurrent.atomic.AtomicInteger;
    import com.sap.conn.jco.ext.JCoSessionReference;
    
    public class JCoSessionRefenceImpl implements JCoSessionReference
    {
        private AtomicInteger atomInt = new AtomicInteger(0);
        private String id = "session"+String.valueOf(atomInt.addAndGet(1));
        
        public void contextFinished()
        {       
        }
    
        public void contextStarted()
        {   
        }
    
        @Override
        public String getID()
        {
            /**
             * We need to override getID() method
             */
            
            return id;
        }
    }

## 4.2 实现SessionReferenceProvider接口 ##

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

package jco3.session;
    
    import com.sap.conn.jco.ext.JCoSessionReference;
    import com.sap.conn.jco.ext.SessionException;
    import com.sap.conn.jco.ext.SessionReferenceProvider;
    
    public class SessionReferencProviderImpl implements SessionReferenceProvider
    {
    
        @Override
        public JCoSessionReference getCurrentSessionReference(String scopeType)
        {
            /**
             *  We need to override getCurrentSessionReference() method
             */
            
            JCoSessionRefenceImpl sessionRef = new JCoSessionRefenceImpl();
            return sessionRef;
        }
    
        @Override
        public boolean isSessionAlive(String sessionID)
        {
            return false;
        }
    
        public void jcoServerSessionContinued(String sessionID) throws SessionException
        {       
        }
    
        public void jcoServerSessionFinished(String sessionID)
        {       
        }
    
        public void jcoServerSessionPassivated(String sessionID) throws SessionException
        {       
        }
    
        public JCoSessionReference jcoServerSessionStarted() throws SessionException
        {
            return null;
        }
    }

## 4.3 注册 SessionReferenceProvider接口 ##

package jco3.session;
    
    import com.sap.conn.jco.JCoDestination;
    import com.sap.conn.jco.JCoDestinationManager;
    import com.sap.conn.jco.JCoException;
    import com.sap.conn.jco.ext.Environment;
    import com.sap.conn.jco.ext.SessionReferenceProvider;
    
    public class DestinationProvider
    {
        public static JCoDestination getDestination() throws JCoException
        {
            // create an instance of SessionReferenceProvider
            // and register in environment
            SessionReferenceProvider provider = new SessionReferencProviderImpl();
            Environment.registerSessionReferenceProvider(provider);
            
            JCoDestination destination = JCoDestinationManager.getDestination("ECC");
            
            return destination;
        }
    }

## 4.4 在单独线程中执行ZINCREMENT\_COUNTER ##

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

package jco3.demo6;
    
    import com.sap.conn.jco.JCoDestination;
    import com.sap.conn.jco.JCoException;
    
    public class WorkingThread extends Thread
    {
        private boolean doneSignal;
        private JCoDestination destination;
        
        // constructor
        public WorkingThread(JCoDestination destination, boolean doneSignal)
        {
            this.destination = destination;
            this.doneSignal = doneSignal;
        }
        
        public boolean hasDone()
        {
            return doneSignal;
        }
        
        @Override
        public void run()
        {
            /**
             * run method of runIncrement() for five times
             */
            
            for (int i = 0; i < 5; i++){
                try {
                    RfcFunctions.runIncrement(this.destination);    
                    System.out.println("Run " + (i+1) + " times.");
                } catch (JCoException e) {              
                    e.printStackTrace();
                }
            }
            
            this.doneSignal = true;
        }   
    }

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

## 4.5 测试多线程函数调用 ##

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

package jco3.demo6;
    
    import com.sap.conn.jco.JCoContext;
    import com.sap.conn.jco.JCoDestination;
    import com.sap.conn.jco.JCoException;
    import jco3.session.DestinationProvider;
    
    public class TestSAPSessionMultiThread
    {   
        public static void main(String[] args) throws JCoException, InterruptedException
        {
            /**
             * Run ZINCREMENT_COUNTER & ZGET_COUNTER functions in
             * different threads in a stateful way.
             * 
             * The SAP will keep a session id which was created in
             * JCoSessionReferenceImpl class 
             * and used in SessionReferenceProviderImpl class.
             * 
             * Before using, SessionReferenceProviderImpl class should be
             * registered using Environment.registerSessionReferenceProvider() method.
             */
            
            // get JCoDestination object instance
            JCoDestination destination = DestinationProvider.getDestination();
            
            // make sure the two functions will be executed in the same session
            JCoContext.begin(destination);
            
            // Before increment
            System.out.println("Before execution of ZINCREMENT_COUNTER:");
            System.out.println("Counter:" + RfcFunctions.runGetCounter(destination));
            
            // start a new Thread in which function ZINCREMENT_COUNTER
            // will be executed for five times
            WorkingThread workingThread = new WorkingThread(destination, false);
            workingThread.start();
            
            // wait and switch thread
            Thread.sleep(1000);
            
            // After increment
            if (workingThread.hasDone() == true){
                System.out.println("After execution of ZINCREMENT_COUNTER:");
                System.out.println("Counter:" + RfcFunctions.runGetCounter(destination));   
            }
            
            // release the connection 
            JCoContext.end(destination);
        }
    }

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

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

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

[SAP_ NCo3.0_06_ _]: https://www.jianshu.com/p/d34555b981f0