Jco服务配置以及程序编写
SAP 与第三方面软件进行数据通信时,运用到的中间件JCO,以下是JCO的服务配置.以及程序的编写,希望能给大家带来点帮助
SAP与java进行通信的流程：
操作步骤
ABAP（作为Clint端），调用JAVA（作为服务器端）。
首先，JCo服务器程序在网管中的注册
下面给出该程序的JCo服务器程序在SAP网关中的注册步骤。
（1） 在SM59中，定义一个连接类型为T的远程目标
单击创建按钮，如下图所示，要步骤一步一步填入所需要的数据
RFC目标系统，是RFC调用时候使用的。 Program ID，是JAVA程序中使用的，此处为LDKJCO，
这里的Geteway Host就是下图的应用程序服务器地址。 TCP服务sapgw是固定的，后面的00就是下图的系统编号。
特别要注意的是，下面图要默认NON-Unicode，因为这个标示影响Java代码中的Unicode设置。其它的默认就可以
上述配置完成即可。
测试连接，当然在做这测试连接之前先要将sap程序和JAVA程序的参数设置好，具体步骤看 sap程序和JAVA程序的设置，如下
sap程序编写
创建一个测试程序，程序名zldkjco（自定义）
代码如下：
REPORT ZLDKJCO.
DATA:REQUTEXT LIKE SY-LISEL,
RESPTEXT LIKE SY-LISEL,
ECHOTEXT LIKE SY-LISEL.
DATA:RFCDEST like rfcdes-rfcdest VALUE ‘NONE’.
DATA:RFC_MESS(128).
REQUTEXT= ‘HELLOWORLD’.
RFCDEST=
‘LDKJCO’.
“correspondstothedestinationnamedefinedintheSM59
CALL FUNCTION ‘STFC_CONNECTION’ DESTINATIONRFCDEST
EXPORTING
REQUTEXT=REQUTEXT
IMPORTING
RESPTEXT=RESPTEXT
ECHOTEXT=ECHOTEXT
EXCEPTIONS
SYSTEM_FAILURE= 1 MESSAGE RFC_MESS
COMMUNICATION_FAILURE= 2 MESSAGE RFC_MESS.
IF SY-SUBRC NE 0.
WRITE:/ ‘CallSTFC_CONNECTIONSY-SUBRC=’,SY-SUBRC.
WRITE:/RFC_MESS.
ENDIF.
接下来JAVA开发代码,代码的具体的操作可以在ECLIPSE中完成（要完成JCO的布置和JDK路径的设置）
public class
StepByStepServer
{
static String SERVER_NAME1 = “SERVER”;
static String DESTINATION_NAME1 = “ABAP_AS_WITHOUT_POOL”;
static String DESTINATION_NAME2 = “ABAP_AS_WITH_POOL”;
static MyTIDHandler myTIDHandler = null ;
static
{
Properties connectProperties = new Properties();
connectProperties.setProperty(DestinationDataProvider. JCO_ASHOST , “10.0.0.6″ );
connectProperties.setProperty(DestinationDataProvider. JCO_SYSNR , “00″ );
connectProperties.setProperty(DestinationDataProvider. JCO_CLIENT , “800″ );
connectProperties.setProperty(DestinationDataProvider. JCO_USER , “XIAOFR”) ;
connectProperties.setProperty(DestinationDataProvider. JCO_PASSWD , “123456789″ );
connectProperties.setProperty(DestinationDataProvider. JCO_LANG , “en”);
createDataFile ( DESTINATION_NAME1 , “jcoDestination”, connectProperties);
connectProperties.setProperty(DestinationDataProvider. JCO_POOL_CAPACITY , “3″);
connectProperties.setProperty(DestinationDataProvider. JCO_PEAK_LIMIT , “10″);
createDataFile ( DESTINATION_NAME2 , “jcoDestination”, connectProperties);
Properties servertProperties = new Properties();
servertProperties.setProperty(ServerDataProvider. JCO_GWHOST , “10.0.0.6″ );
servertProperties.setProperty(ServerDataProvider. JCO_GWSERV , “sapgw00″ );
servertProperties.setProperty(ServerDataProvider. JCO_PROGID , “LDKJCO” );
servertProperties.setProperty(ServerDataProvider. JCO_REP_DEST , “ABAP_AS_WITH_POOL”);
servertProperties.setProperty(ServerDataProvider. JCO_CONNECTION_COUNT , “2″);
createDataFile ( SERVER_NAME1 , “jcoServer”, servertProperties);
}
static void createDataFile(String name, String suffix, Properties properties)
{
File cfg = new File(name + “.” + suffix);
if (!cfg.exists())
{
try
{
FileOutputStream fos = new FileOutputStream(cfg, false );
properties.store(fos, “for tests only !”);
fos.close();
}
catch (Exception e)
{
throw new RuntimeException(“Unable to create the destination file “ + cfg.getName(), e);
}
}
}
static class StfcConnectionHandler implements JCoServerFunctionHandler
{
public void handleRequest(JCoServerContext serverCtx, JCoFunction function)
{
System. out .println(“—————————————————————-”);
System. out .println(“call : “ + function.getName());
System. out .println(“ConnectionId : “ + serverCtx.getConnectionID());
System. out .println(“SessionId : “ + serverCtx.getSessionID());
System. out .println(“TID : “ + serverCtx.getTID());
System. out .println(“repository name : “ + serverCtx.getRepository().getName());
System. out .println(“is in transaction : “ + serverCtx.isInTransaction());
System. out .println(“is stateful : “ + serverCtx.isStatefulSession());
System. out .println(“—————————————————————-”);
System. out .println(“gwhost: “ + serverCtx.getServer().getGatewayHost());
System. out .println(“gwserv: “ + serverCtx.getServer().getGatewayService());
System. out .println(“progid: “ + serverCtx.getServer().getProgramID());
System. out .println(“—————————————————————-”);
System. out .println(“attributes : “);
System. out .println(serverCtx.getConnectionAttributes().toString());
System. out .println(“—————————————————————-”);
System. out .println(“CPIC conversation ID: “ + serverCtx.getConnectionAttributes().getCPICConversationID());
System. out .println(“—————————————————————-”);
System. out .println(“req text: “ + function.getImportParameterList().getString(“REQUTEXT”));
function.getExportParameterList().setValue(“ECHOTEXT”, function.getImportParameterList().getString(“REQUTEXT”));
function.getExportParameterList().setValue(“RESPTEXT”, “Hello World”);
// In sample 3 (tRFC Server) we also set the status to executed:
if ( myTIDHandler != null )
myTIDHandler .execute(serverCtx);
}
}
static void step1SimpleServer()
{
JCoServer server;
try
{
server = JCoServerFactory. getServer ( SERVER_NAME1 );
}
catch (JCoException ex)
{
throw new RuntimeException(“Unable to create the server “ + SERVER_NAME1 + “, because of “ + ex.getMessage(), ex);
}
JCoServerFunctionHandler stfcConnectionHandler = new StfcConnectionHandler();
DefaultServerHandlerFactory.FunctionHandlerFactory factory = new DefaultServerHandlerFactory.FunctionHandlerFactory();
factory.registerHandler(“STFC_CONNECTION”, stfcConnectionHandler);
server.setCallHandlerFactory(factory);
server.start();
System. out .println(“The program can be stoped using <ctrl>+<c>”);
}
static class MyThrowableListener implements JCoServerErrorListener, JCoServerExceptionListener
{
public void serverErrorOccurred(JCoServer jcoServer, String connectionId, JCoServerContextInfo serverCtx, Error error)
{
System. out .println(“>>> Error occured on “ + jcoServer.getProgramID() + ” connection “ + connectionId);
error.printStackTrace();
}
public void serverExceptionOccurred(JCoServer jcoServer, String connectionId, JCoServerContextInfo serverCtx, Exception error)
{
System. out .println(“>>> Error occured on “ + jcoServer.getProgramID() + ” connection “ + connectionId);
error.printStackTrace();
}
}
static class MyStateChangedListener implements JCoServerStateChangedListener
{
public void serverStateChangeOccurred(JCoServer server, JCoServerState oldState, JCoServerState newState)
{
// Defined states are: STARTED, DEAD, ALIVE, STOPPED;
// see JCoServerState class for details.
// Details for connections managed by a server instance
// are available via JCoServerMonitor
System. out .println(“Server state changed from “ + oldState.toString() + ” to “ + newState.toString() + ” on server with program id “
+ server.getProgramID());
}
}
static void step2SimpleServer()
{
JCoServer server;
try
{
server = JCoServerFactory. getServer ( SERVER_NAME1 );
}
catch (JCoException ex)
{
throw new RuntimeException(“Unable to create the server “ + SERVER_NAME1 + “, because of “ + ex.getMessage(), ex);
}
JCoServerFunctionHandler stfcConnectionHandler = new StfcConnectionHandler();
DefaultServerHandlerFactory.FunctionHandlerFactory factory = new DefaultServerHandlerFactory.FunctionHandlerFactory();
factory.registerHandler(“STFC_CONNECTION”, stfcConnectionHandler);
server.setCallHandlerFactory(factory);
// additionally to step 1
MyThrowableListener eListener = new MyThrowableListener();
server.addServerErrorListener(eListener);
server.addServerExceptionListener(eListener);
MyStateChangedListener slistener = new MyStateChangedListener();
server.addServerStateChangedListener(slistener);
server.start();
System. out .println(“The program can be stoped using <ctrl>+<c>”);
}
static class MyTIDHandler implements JCoServerTIDHandler
{
Map<String, TIDState> availableTIDs = new Hashtable<String, TIDState>();
public boolean checkTID(JCoServerContext serverCtx, String tid)
{
// This example uses a Hashtable to store status information. But usually
// you would use a database. If the DB is down, throw a RuntimeException at
// this point. JCo will then abort the tRFC and the R/3 backend will try
// again later.
System. out .println(“TID Handler: checkTID for “ + tid);
TIDState state = availableTIDs.get(tid);
if (state == null )
{
availableTIDs.put(tid, TIDState. CREATED );
return true ;
}
if (state == TIDState. CREATED || state == TIDState. ROLLED_BACK )
return true ;
return false ;
// “true” means that JCo will now execute the transaction, “false” means
// that we have already executed this transaction previously, so JCo will
// skip the handleRequest() step and will immediately return an OK code to R/3.
}
public void commit(JCoServerContext serverCtx, String tid)
{
System. out .println(“TID Handler: commit for “ + tid);
// react on commit e.g. commit on the database
// if necessary throw a RuntimeException, if the commit was not
// possible
availableTIDs.put(tid, TIDState. COMMITTED );
}
public void rollback(JCoServerContext serverCtx, String tid)
{
System. out .println(“TID Handler: rollback for “ + tid);
availableTIDs.put(tid, TIDState. ROLLED_BACK );
// react on rollback e.g. rollback on the database
}
public void confirmTID(JCoServerContext serverCtx, String tid)
{
System. out .println(“TID Handler: confirmTID for “ + tid);
try
{
// clean up the resources
}
// catch(Throwable t) {} //partner wont react on an exception at
// this point
finally
{
availableTIDs.remove(tid);
}
}
public void execute(JCoServerContext serverCtx)
{
String tid = serverCtx.getTID();
if (tid != null )
{
System. out .println(“TID Handler: execute for “ + tid);
availableTIDs.put(tid, TIDState. EXECUTED );
}
}
private enum TIDState
{
CREATED , EXECUTED , COMMITTED , ROLLED_BACK , CONFIRMED ;
}
}
static void step3SimpleTRfcServer()
{
JCoServer server;
try
{
server = JCoServerFactory. getServer ( SERVER_NAME1 );
}
catch (JCoException ex)
{
throw new RuntimeException(“Unable to create the server “ + SERVER_NAME1 + “, because of “ + ex.getMessage(), ex);
}
JCoServerFunctionHandler stfcConnectionHandler = new StfcConnectionHandler();
DefaultServerHandlerFactory.FunctionHandlerFactory factory = new DefaultServerHandlerFactory.FunctionHandlerFactory();
factory.registerHandler(“STFC_CONNECTION”, stfcConnectionHandler);
server.setCallHandlerFactory(factory);
// additionally to step 1
myTIDHandler = new MyTIDHandler();
server.setTIDHandler( myTIDHandler );
server.start();
System. out .println(“The program can be stoped using <ctrl>+<c>”);
}
public static void main(String[] a)
{
// step1SimpleServer();
step2SimpleServer ();
// step3SimpleTRfcServer();
}
}
在ECLIPSE中编写完成后，在ECLIPSE中可以运行程序，运行成功如下图：
运行成功后会产生一个SERVER.jcoserver,点击此文件可以看到如果下的信息，连接成功。
最后在SAP中，运行TCODE：SM59，选中你所创建的远程目标，此处为LDKJCO。点连接后出下图，说明SAP可以与JCO通信，SAP可以往JCO发数据。
