Jco服务配置以及程序编写

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 = ‘HELLO WORLD’.
RFCDEST = ‘LDKJCO’. “corresponds to the destination name defined in the SM59

CALL FUNCTION ‘STFC_CONNECTION’ DESTINATION RFCDEST
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: / ‘Call STFC_CONNECTION         SY-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发数据。