public  void afterPropertiesSet() throws TransactionSystemException 
{
	     
		super.afterPropertiesSet();
		loadWebLogicTransactionClasses();
}

 public Transaction createTransaction(String name,
    int timeout) throws SystemException, NotSupportedException 
{
		if (this.weblogicUserTransactionAvailable && name != null) {
			try {
				if (timeout  >= 0) {
					this.beginWithNameAndTimeoutMethod.invoke(getUserTransaction(), new Object[] {name, new Integer(timeout)});
				}
				else {
					this.beginWithNameMethod.invoke(getUserTransaction(), new Object[] {name});
				}
			}
			catch (InvocationTargetException ex) {
				if (ex.getTargetException() instanceof NotSupportedException) {
					throw (NotSupportedException) ex.getTargetException();
				}
				else if (ex.getTargetException() instanceof SystemException) {
					throw (SystemException) ex.getTargetException();
				}
				else if (ex.getTargetException() instanceof RuntimeException) {
					throw (RuntimeException) ex.getTargetException();
				}
				else {
					throw new SystemException(
							"WebLogic's begin() method failed with an unexpected error: " + ex.getTargetException());
				}
			}
			catch (Exception ex) {
				throw new SystemException("Could not invoke WebLogic's UserTransaction.begin() method: " + ex);
			}
			return getTransactionManager().getTransaction();
		}
		else {
			// No name specified - standard JTA is sufficient.
			return super.createTransaction(name, timeout);
		}
}

 protected  void doJtaBegin(JtaTransactionObject txObject,
    TransactionDefinition definition) throws SystemException, NotSupportedException 
{
		int timeout = determineTimeout(definition);
		// Apply transaction name (if any) to WebLogic transaction.
		if (this.weblogicUserTransactionAvailable && definition.getName() != null) {
			try {
				if (timeout  > TransactionDefinition.TIMEOUT_DEFAULT) {
					/*
					weblogic.transaction.UserTransaction wut = (weblogic.transaction.UserTransaction) ut;
					wut.begin(definition.getName(), timeout);
					*/
					this.beginWithNameAndTimeoutMethod.invoke(txObject.getUserTransaction(),
							new Object[] {definition.getName(), new Integer(timeout)});
				}
				else {
					/*
					weblogic.transaction.UserTransaction wut = (weblogic.transaction.UserTransaction) ut;
					wut.begin(definition.getName());
					*/
					this.beginWithNameMethod.invoke(txObject.getUserTransaction(),
							new Object[] {definition.getName()});
				}
			}
			catch (InvocationTargetException ex) {
				throw new TransactionSystemException(
						"WebLogic's UserTransaction.begin() method failed", ex.getTargetException());
			}
			catch (Exception ex) {
				throw new TransactionSystemException(
						"Could not invoke WebLogic's UserTransaction.begin() method", ex);
			}
		}
		else {
			// No WebLogic UserTransaction available or no transaction name specified
			// - > standard JTA begin call.
			applyTimeout(txObject, timeout);
			txObject.getUserTransaction().begin();
		}
		// Specify isolation level, if any, through corresponding WebLogic transaction property.
		if (this.weblogicTransactionManagerAvailable) {
			if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
				try {
					Transaction tx = getTransactionManager().getTransaction();
					Integer isolationLevel = new Integer(definition.getIsolationLevel());
					/*
					weblogic.transaction.Transaction wtx = (weblogic.transaction.Transaction) tx;
					wtx.setProperty(ISOLATION_LEVEL_KEY, isolationLevel);
					*/
					this.setPropertyMethod.invoke(tx, new Object[] {ISOLATION_LEVEL_KEY, isolationLevel});
				}
				catch (InvocationTargetException ex) {
					throw new TransactionSystemException(
							"WebLogic's Transaction.setProperty(String, Serializable) method failed", ex.getTargetException());
				}
				catch (Exception ex) {
					throw new TransactionSystemException(
							"Could not invoke WebLogic's Transaction.setProperty(String, Serializable) method", ex);
				}
			}
		}
		else {
			applyIsolationLevel(txObject, definition.getIsolationLevel());
		}
}

 protected  void doJtaResume(JtaTransactionObject txObject,
    Object suspendedTransaction) throws SystemException, InvalidTransactionException 
{
		try {
			getTransactionManager().resume((Transaction) suspendedTransaction);
		}
		catch (InvalidTransactionException ex) {
			if (!this.weblogicTransactionManagerAvailable) {
				throw ex;
			}
			if (logger.isDebugEnabled()) {
				logger.debug("Standard JTA resume threw InvalidTransactionException: " + ex.getMessage() +
				    " - trying WebLogic JTA forceResume");
			}
			/*
			weblogic.transaction.TransactionManager wtm =
					(weblogic.transaction.TransactionManager) getTransactionManager();
			wtm.forceResume(suspendedTransaction);
			*/
			try {
				this.forceResumeMethod.invoke(getTransactionManager(), new Object[] {suspendedTransaction});
			}
			catch (InvocationTargetException ex2) {
				throw new TransactionSystemException(
						"WebLogic's TransactionManager.forceResume(Transaction) method failed", ex2.getTargetException());
			}
			catch (Exception ex2) {
				throw new TransactionSystemException(
						"Could not access WebLogic's TransactionManager.forceResume(Transaction) method", ex2);
			}
		}
}

 protected TransactionManager retrieveTransactionManager() throws TransactionSystemException 
{
		loadWebLogicTransactionHelperClass();
		try {
			logger.debug("Retrieving JTA TransactionManager from WebLogic TransactionHelper/TxHelper");
			Method getTransactionManagerMethod =
					this.transactionHelperClass.getMethod("getTransactionManager", new Class[0]);
			return (TransactionManager) getTransactionManagerMethod.invoke(this.transactionHelper, new Object[0]);
		}
		catch (InvocationTargetException ex) {
			throw new TransactionSystemException(
					"WebLogic's TransactionHelper/TxHelper.getTransactionManager() method failed", ex.getTargetException());
		}
		catch (Exception ex) {
			throw new TransactionSystemException(
					"Could not invoke WebLogic's TransactionHelper/TxHelper.getTransactionManager() method", ex);
		}
}

 protected UserTransaction retrieveUserTransaction() throws TransactionSystemException 
{
		loadWebLogicTransactionHelperClass();
		try {
			logger.debug("Retrieving JTA UserTransaction from WebLogic TransactionHelper/TxHelper");
			Method getUserTransactionMethod =
					this.transactionHelperClass.getMethod("getUserTransaction", new Class[0]);
			return (UserTransaction) getUserTransactionMethod.invoke(this.transactionHelper, new Object[0]);
		}
		catch (InvocationTargetException ex) {
			throw new TransactionSystemException(
					"WebLogic's TransactionHelper/TxHelper.getUserTransaction() method failed", ex.getTargetException());
		}
		catch (Exception ex) {
			throw new TransactionSystemException(
					"Could not invoke WebLogic's TransactionHelper/TxHelper.getUserTransaction() method", ex);
		}
}