Developing the Bank Checking MTS Server Component by Gopalan Suresh Raj

Once the IDL has been created, we now have to create the MTS server component.

1. Create a new COM DLL project
An MTS component should always be packaged as a DLL. Select New Project and from the File menu, choose the COM DLL project template in Visual J++. Name the project BankServer.

3. Mark the class as COM/MTS-enabled
To deploy the class in MTS, you need to make it a COM/MTS class. You can easily make it one by right-clicking the mouse on the BankServer class from the Class Outline tab and Selecting Class Properties. Mark the MTS Support as Enabled and say OK.

You will immediately notice that some code similar to this is added to the CheckingImpl class

/** @com.register(clsid=07D690F5-FB95-11D2-97E3-006097A7D34F,
* typelib=07D690F0-FB95-11D2-97E3-006097A7D34F, version="1.0")
* @com.transaction (required)
*/

The final code for the CheckingPKImpl and CheckingPK looks like this:

CheckingImpl.java

package bank;

import com.ms.com.*;
import com.ms.com.IUnknown;
import com.ms.com.Variant;
import com.ms.mtx.*;
import com.ms.wfc.data.*;

/** @com.register(clsid=07D690F5-FB95-11D2-97E3-006097A7D34F,
* typelib=07D690F0-FB95-11D2-97E3-006097A7D34F, version="1.0")
* @com.transaction (required)
*/
public class CheckingImpl implements IUnknown,com.ms.com.NoAutoScripting,
bank.ICheckingHomeDefault,bank.ICheckingDefault {

static final int ALL_FIELDS   = 0;
static final int NAME_FIELD   = 1;
static final int BALANCE_FIELD= 2;

//odbc type connection string
static final String m_strOpenConn = "FILEDSN=Bank";

////////////////////////////////////////////////////////////////////
//          Home Interface methods
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
public void create(bank.IAccountKey key, String name, double startingBalance) {
////////////////////////////////////////////////////////////////////
if (startingBalance < 0)
   return;

boolean bSuccess = false;
System.out.println("Invoking Checkings::create");

IObjectContext context = null;

try {
   // Get the Object Context
   context = (IObjectContext)MTx.GetObjectContext ();
   truePut (CheckingImpl.ALL_FIELDS, (CheckingPKImpl)key,
            (new Double (startingBalance)).toString (), name);
   bSuccess = true;
}
catch (Exception e) {
   bSuccess = false;
   e.printStackTrace ();
}
// Upon exit, always call SetComplete () if happy,
// or SetAbort () if unhappy
// We do this since we never save state across method calls.
finally {
   if (context!=null) {
    if (bSuccess == true)
     context.SetComplete ();
    else
     context.SetAbort ();
   }
}
}

////////////////////////////////////////////////////////////////////
//          Remote Interface methods
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
public void credit(double amount, bank.IAccountKey key) {
////////////////////////////////////////////////////////////////////

double balance = 0.0;
boolean bSuccess = false;
System.out.println("Invoking Checkings::credit");

try {
   balance = getBalance (key);
}
catch (Exception e) {
   e.printStackTrace ();
}

System.out.println("changing Checkings::balance from " + balance);

   // Get the Object Context
IObjectContext context = (IObjectContext)MTx.GetObjectContext ();

try {
   if( amount > 0 ) {
    balance += amount;
    truePut (CheckingImpl.BALANCE_FIELD, (CheckingPKImpl)key,
             (new Double(balance)).toString (), "");
    bSuccess = true;
   }
}
catch (Exception e) {
   bSuccess = false;
   e.printStackTrace ();
}
// Upon exit, always call SetComplete () if happy,
// or SetAbort () if unhappy
// We do this since we never save state across method calls.
finally {
   if (context!=null) {
    if (bSuccess == true)
     context.SetComplete ();
    else
     context.SetAbort ();
   }
}
System.out.println(" to " + balance);
}

////////////////////////////////////////////////////////////////////
public void debit(double amount, bank.IAccountKey key) {
////////////////////////////////////////////////////////////////////
double balance = 0.0;
boolean bSuccess = false;
System.out.println("Invoking Checkings::debit");

try {
balance = getBalance (key);
}
catch (Exception e) {
e.printStackTrace ();
}

System.out.println("changing Checkings::balance from " + balance);

   // Get the Object Context
IObjectContext context = (IObjectContext)MTx.GetObjectContext ();

try {
   if ( (amount > 0) && (balance >= amount) ) {
    balance -= amount;
    truePut (CheckingImpl.BALANCE_FIELD, (CheckingPKImpl)key,
             (new Double (balance)).toString (), "");
    bSuccess = true;
   }
}
catch (Exception e) {
   bSuccess = false;
   e.printStackTrace ();
}
// Upon exit, always call SetComplete () if happy,
// or SetAbort () if unhappy
// We do this since we never save state across method calls.
finally {
   if (context!=null) {
    if (bSuccess == true)
     context.SetComplete ();
    else
     context.SetAbort ();
   }
}
System.out.println(" to " + balance);
}

////////////////////////////////////////////////////////////////////
public double getBalance(bank.IAccountKey key) {
////////////////////////////////////////////////////////////////////

double balance = 0.0;
boolean bSuccess= false;
System.out.println ("Invoking Checkings::getBalance");
IObjectContext context = null;

try {
   // Get the Object Context
   context = (IObjectContext)MTx.GetObjectContext ();

   String result = trueGet (CheckingImpl.BALANCE_FIELD, (CheckingPKImpl)key);
   balance = (new Double (result)).doubleValue();
   bSuccess = true;
}
catch (Exception e) {
   bSuccess = false;
   e.printStackTrace ();
}
// Upon exit, always call SetComplete () if happy,
// or SetAbort () if unhappy
// We do this since we never save state across method calls.
finally {
   if (context!=null) {
    if (bSuccess == true)
     context.SetComplete ();
    else
     context.SetAbort ();
   }
}

System.out.println("Checkings::balance is " + balance);
return balance;
}

////////////////////////////////////////////////////////////////////
public String getCustomerName(bank.IAccountKey key) {
////////////////////////////////////////////////////////////////////

String name = null;
boolean bSuccess= false;
System.out.println ("Invoking Checkings::getCustomerName");

IObjectContext context = null;

try {
   // Get the Object Context
   context = (IObjectContext)MTx.GetObjectContext ();
   name = trueGet (CheckingImpl.NAME_FIELD, (CheckingPKImpl)key);
   bSuccess = true;
}
catch (Exception e) {
   bSuccess = false;
   e.printStackTrace ();
}
// Upon exit, always call SetComplete () if happy,
// or SetAbort () if unhappy
// We do this since we never save state across method calls.
finally {
   if (context!=null) {
    if (bSuccess == true)
     context.SetComplete ();
    else
     context.SetAbort ();
   }
}

System.out.println ("Checkings::customer_name is " + name);
return name;
}

////////////////////////////////////////////////////////////////////
//          Other Internal methods
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
String trueGet (int type, CheckingPKImpl key) {
////////////////////////////////////////////////////////////////////
Connection connection = null;
Recordset rset = null;
Variant    rowCount = new Variant ();
String     result = null;
String     query = null;
String     fieldName = null;

switch (type) {
   case CheckingImpl.NAME_FIELD:
    query = "SELECT CUSTOMER_NAME FROM Checkings WHERE ACCOUNT_NUMBER=";
    fieldName = "CUSTOMER_NAME";
    break;

   case CheckingImpl.BALANCE_FIELD:
    query = "SELECT BALANCE FROM Checkings WHERE ACCOUNT_NUMBER=";
    fieldName = "BALANCE";
    break;
}
query += key.m_accountNumber;

try {
   //STEP1 : open the connection
   connection = new Connection ();
   connection.open (CheckingImpl.m_strOpenConn);

   //STEP 2: Obtain the desired recordset with a query
   rset = connection.execute (query);

   //STEP 3:Get the appropriate fields
   if (!rset.getEOF()) {
    result = rset.getField (fieldName).getString ();
   }
}
catch (Exception e) {
   e.printStackTrace ();
}
finally {
   // Cleanup that needs to occur whether we leave via a return or exception
   if (rset != null) {
    if (rset.getState () == AdoEnums.ObjectState.OPEN)
     rset.close ();
    ComLib.release (rset);
    rset = null;
   }

   if (connection != null) {
    if (connection.getState () == AdoEnums.ObjectState.OPEN)
     connection.close ();
    ComLib.release (connection);
    connection = null;
   }
}
return result;
}

////////////////////////////////////////////////////////////////////
String truePut (int type, CheckingPKImpl key, String balance,
                 String name) {
////////////////////////////////////////////////////////////////////
Connection connection = null;
Recordset rset = null;
Variant    rowCount = new Variant ();
String     result = null;
String     query = null;

switch (type) {
   case CheckingImpl.NAME_FIELD:
    query = "INSERT INTO Checkings VALUES ( '"+ key.m_accountNumber
            +"','"+ name +"','"+balance+"')";
    break;

   case CheckingImpl.BALANCE_FIELD:
    query = "UPDATE Checkings SET BALANCE=" + balance +
            " WHERE ACCOUNT_NUMBER="+ key.m_accountNumber;
    break;

   case CheckingImpl.ALL_FIELDS:
   default:
    query = "INSERT INTO Checkings VALUES ( '"+ key.m_accountNumber
            +"','"+ name +"','"+balance+"')";
    break;
}

try {
   //STEP1 : open the connection
   connection = new Connection ();
   connection.open (CheckingImpl.m_strOpenConn);

   //STEP 2: Obtain the desired recordset with a query
   connection.execute (query);

}
catch (Exception e) {
   e.printStackTrace ();
}
finally {
   // Cleanup that needs to occur whether we leave via a return or exception
   if (rset != null) {
    if (rset.getState () == AdoEnums.ObjectState.OPEN)
     rset.close ();
    ComLib.release (rset);
    rset = null;
   }

   if (connection != null) {
    if (connection.getState () == AdoEnums.ObjectState.OPEN)
     connection.close ();
    ComLib.release (connection);
    connection = null;
   }
}
return result;
}

////////////////////////////////////////////////////////////////////
public CheckingImpl () {
////////////////////////////////////////////////////////////////////
System.out.println ("Invoking CheckingImpl::CheckingImpl");
}
}

4. Build the project
Select the Build menu and Build the project. This creates an MTS component DLL called BankServer.dll. This contains the Class files and all the appropriate stub code so that the DLL can be registered and deployed in MTS.

5. Deploy the DLL into The Microsoft Transaction Server
Start up the MTS Explorer. Go to the computer you want to install your component on and select "Packages Installed". Right click and create a New empty Package called BankServer. Select the newly created BankServer package and create a New Component. Select the Component through the Browse button into MTS. (Make sure you Install New Component rather than Import Components...) The Checking MTS Server component is now deployed on MTS and is ready for client invocations.