事务未回滚Java Android Sql

*我正在尝试一个接一个地运行三个异步任务。 彼此依赖。 如果任务中的任何一个出现异常，则应回滚所有三个任务。 这是以前的职位。 但是只有得到异常的任务才被回滚，而不是其他任务 我的代码在下面

               public static int executeOrder() {
    int mOrderId=-1;
    Connection conn = null;
    JtdsCallableStatement jtdsproc = null;
    ResultSet orderResult = null;

    try {
        conn = ConnectionProvider.getConnection();
        jtdsproc = (JtdsCallableStatement) conn
                .prepareCall("{call SaveOrder(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)}");
        jtdsproc.setInt(1, SqlOrderQueries.getORDERID());
        jtdsproc.setInt(2, SqlOrderQueries.getPOSID());
        jtdsproc.setInt(3, SqlOrderQueries.getEMP_CASH_ID());
        jtdsproc.setInt(4, SqlOrderQueries.getCUST_ID());
        jtdsproc.setInt(5, SqlOrderQueries.getTRANSTYPE());
        jtdsproc.setString(6, ""+SqlOrderQueries.getMDEBIT());
        jtdsproc.setString(7, ""+SqlOrderQueries.getADEBIT());
        jtdsproc.setString(8, ""+SqlOrderQueries.getMCREDIT());
        jtdsproc.setString(9, ""+SqlOrderQueries.getACREDIT());
        jtdsproc.setString(10, ""+SqlOrderQueries.getBCREDIT());
        jtdsproc.setInt(11, SqlOrderQueries.getMEALPLANID());
        jtdsproc.setInt(12, SqlOrderQueries.getCASHRESULTID());
        jtdsproc.setInt(13, SqlOrderQueries.getLUNCHTYPE());
        jtdsproc.setInt(14, SqlOrderQueries.getSCHOOL_ID());
        jtdsproc.setString(15, SqlOrderQueries.getORDERDATE());
        jtdsproc.setInt(16, SqlOrderQueries.getCREDITAUTH());

        if(SqlOrderQueries.getCHECKNUM()== -1)
        {
            jtdsproc.setNull(17, Types.INTEGER);
        }else{
            jtdsproc.setInt(17, SqlOrderQueries.getCHECKNUM());
        }
        jtdsproc.setInt(18, SqlOrderQueries.getOVERRIDE());
        jtdsproc.setInt(19, SqlOrderQueries.getVOID());
        jtdsproc.setInt(20, SqlOrderQueries.getORDLOG_ID());
        jtdsproc.setString(21, SqlOrderQueries.getORDLOGNOTE());
        orderResult = jtdsproc.executeQuery();
        while (orderResult.next()) {

            mOrderId=orderResult.getInt(1);
            Log.w("Data For Sales Handler: OrderId",
                    "$--" + orderResult.getInt(1));
            Log.w("Data For Sales Handler OrderIdLog:",
                    "$--" + orderResult.getInt(2));
            Log.w("Data For Sales Handler Customerid:",
                    "$--" + orderResult.getInt(3));
            Log.w("Data For Sales Handler Abalance:",
                    "$--" + orderResult.getFloat(4));
            Log.w("Data For Sales Handler Mbalance:",
                    "$--" + orderResult.getFloat(5));
            Log.w("Data For Sales Handler Bonacebalance:", "$--"
                    + orderResult.getFloat(6));
            Log.w("Data For Sales Handler Error:",
                    "$--" + orderResult.getString(7));
        }
    } catch (Exception ee) {
        try {
            conn.rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        ee.printStackTrace();
        return mOrderId = Utilities.NETWORK_ERROR;
    }
    return mOrderId;
}
public static boolean insertItem(int mOrderid, ArrayList<Integer> itemsIds,
        ArrayList<Integer> menuItemIds, ArrayList<Integer> itemsQuantity,
        ArrayList<Integer> itemsSoldType, ArrayList<Float> itemsPrice) {
    boolean insertStatus = false;
    Connection conn = ConnectionProvider.getConnection();
    PreparedStatement pStmt = null;
    String insertString = "insert into items values (?,?,?,?,?,?,?,?,?,?)";
    try {
        conn.setAutoCommit(false);
        pStmt = conn.prepareStatement(insertString);
        for(int i=0;i<itemsIds.size();)
        {
            pStmt.setInt(1, itemsIds.get(i));
            pStmt.setInt(2, mOrderid);
            pStmt.setInt(3, menuItemIds.get(i));
            pStmt.setInt(4, itemsQuantity.get(i));
            pStmt.setString(5, ""+itemsPrice.get(i));
            pStmt.setString(6, ""+itemsPrice.get(i));
            pStmt.setString(7, ""+1.00);
            pStmt.setInt(8, 0);
            pStmt.setInt(9, itemsSoldType.get(i));
            pStmt.setNull(10, Types.NULL);
            int a = pStmt.executeUpdate();
            Log.d("no of row affected for insert", "" + a);

            i++;
        }
        insertStatus = true;
    } catch (Exception ee) {
        ee.printStackTrace();
        if (conn != null) {
            try {
                System.err.print("Transaction is being rolled back");
                conn.rollback();
            } catch (SQLException excep) {
                excep.printStackTrace();
            }
        }
        insertStatus=false;
    } finally {
        try {
            pStmt.close();
            conn.setAutoCommit(true);
        } catch (SQLException eee) {
            eee.printStackTrace();
        }
    }
    return insertStatus;
}
public static ArrayList<Integer> getNewItemId(int totalItems) {
    Connection conn = ConnectionProvider.getConnection();
    JtdsCallableStatement jtdsproc = null;
    ArrayList<Integer> itemsIds = new ArrayList<Integer>();
    for (int i = 0; i < totalItems; i++) {
        try {
            jtdsproc = (JtdsCallableStatement) conn
                    .prepareCall("{call FASTINDEXGEN(1,1,0)}");
            ResultSet rs = jtdsproc.executeQuery();
            while (rs.next()) {
                Log.d("Value", "" + rs.getInt(1));
                itemsIds.add(rs.getInt(1));
            }
        } catch (Exception ee) {
            ee.printStackTrace();
            if (conn != null) {
                try {
                    System.err.print("Transaction is being rolled back");
                    conn.rollback();
                } catch (SQLException excep) {
                    excep.printStackTrace();
                }
            }
            itemsIds=null;
        }
    }
    return itemsIds;
}*



            public void completeOrder(InputBean input){

    setNO_PaYMENT(false);

    SqlOrderQueries.setPOSID(((HomeActivity)mActivity).mSessionManager.getPosId());
    SqlOrderQueries.setEMP_CASH_ID(((HomeActivity)mActivity).mSessionManager.getCustomerId());
    /*Customer id will be different for student and guest cash sale*/
    SqlOrderQueries.setCUST_ID(input.getCustomer_id());
    SqlOrderQueries.setTRANSTYPE(getTransType());
    SqlOrderQueries.setMDEBIT(input.getmDebit());
    SqlOrderQueries.setADEBIT(input.getaDebit());
    SqlOrderQueries.setMCREDIT(input.getmCredit());
    SqlOrderQueries.setACREDIT(input.getaCredit());
    SqlOrderQueries.setBCREDIT(""+0.00);

    /*Do not need to change the meal plan id ,it is default by default*/
    SqlOrderQueries.setCASHRESULTID(((HomeActivity)mActivity).mSessionManager.getCashColumnId());

    SqlOrderQueries.setLUNCHTYPE(DetailsFragment.getLUNCH_TYPE());
    SqlOrderQueries.setSCHOOL_ID(((HomeActivity)mActivity).mSessionManager.getSchoolId());
    SqlOrderQueries.setORDERDATE(getDate());
    /*Credit auth is passed default for the time being*/
    SqlOrderQueries.setCHECKNUM(input.getCheckNumber());
    /*override is passed 0 for the time being*/
    /*void ordlog_id  ordlognote  are  0 ,default ,default respectfully*/


    new AsyncTask<Void, Void, Integer>() {

        @Override
        protected Integer doInBackground(Void... params) {
            if(ConnectionProvider.checkConnection()==false){

                return null;
            }
            return OrderSalesHandler.executeOrder();
        }

        @Override
        protected void onPostExecute(Integer result) {
            super.onPostExecute(result);

            if(result == Utilities.NETWORK_ERROR)
            {
                AlertDialog.Builder mEAlert = new AlertDialog.Builder(mActivity);
                mEAlert.setMessage("Network Problem");
                mEAlert.create().show();
            }
            if(result>0){

                mItemshandler.onSucessOrder(result);
            }

        }


    }.execute();
}

@Override
public void onSucessOrder(int orderId) {

    mOrderid=orderId;
    new AsyncTask<Void, Void, ArrayList<Integer>>(){

        @Override
        protected ArrayList<Integer> doInBackground(Void... params) {
            if(ConnectionProvider.checkConnection()==false){
                return null;
            }
            return OrderSalesHandler.getNewItemId(mTotalItems);
        }

        @Override
        protected void onPostExecute(ArrayList<Integer> result) {
            super.onPostExecute(result);

            if(result==null)
            {
                AlertDialog.Builder mEAlert = new AlertDialog.Builder(mActivity);
                mEAlert.setMessage("Network Problem and Order not Completed");
                mEAlert.create().show();
            }else{

                mItemshandler.onSucessItemId(result);
            }

        }


    }.execute();
}

@Override
public void onSucessItemId(ArrayList<Integer> itemIds) {



    itemsIds=itemIds;
    new AsyncTask<Void, Void, Boolean>(){

        @Override
        protected Boolean doInBackground(Void... params) {

            if(ConnectionProvider.checkConnection()==false)
            {
                return false;
            }

            return OrderSalesHandler.insertItem(mOrderid,itemsIds,menuItemIds,itemsQuantity,itemsSoldType,itemsPrice);
        }

        @Override
        protected void onPostExecute(Boolean result) {
            super.onPostExecute(result);

            if(result==true){

                if(isNO_PaYMENT()==false){

                    ((HomeActivity)mActivity).mSalesFragment.mPaymentDialog.dismiss();
                }

                ((HomeActivity)mActivity).mSalesFragment.onClick(((HomeActivity)mActivity).mSalesFragment.mCancelButton);


            }

            if(result==false){

                AlertDialog.Builder mEAlert = new AlertDialog.Builder(mActivity);
                mEAlert.setMessage("Network Problem and Order Not Completed");
                mEAlert.create().show();
            }
        }



    }.execute();
}



public static boolean isNO_PaYMENT() {
    return NO_PaYMENT;
}

public static void setNO_PaYMENT(boolean nO_PaYMENT) {
    NO_PaYMENT = nO_PaYMENT;
}

public static int executeOrder（）{
int-mOrderId=-1；
连接conn=null；
JtdsCallableStatement jtdsproc=null；
ResultSet orderResult=null；
试一试{
conn=ConnectionProvider.getConnection（）；
jtdsproc=（JtdsCallableStatement）连接
.prepareCall（{调用存储顺序（？，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，）}）；
jtdsproc.setInt（1，sqlorderquerys.getORDERID（））；
setInt（2，sqlorderquerys.getPOSID（））；
jtdsproc.setInt（3，sqlorderquerys.getEMP_CASH_ID（））；
jtdsproc.setInt（4，sqlorderquerys.getCUST_ID（））；
jtdsproc.setInt（5，sqlorderquerys.getTRANSTYPE（））；
jtdsproc.setString（6，“+sqlorderquerys.getMDEBIT（））；
jtdsproc.setString（7，“+sqlorderquerys.getADEBIT（））；
jtdsproc.setString（8，“+sqlorderquerys.getMCREDIT（））；
jtdsproc.setString（9，“+sqlorderquerys.getACREDIT（））；
jtdsproc.setString（10，“+sqlorderquerys.getBCREDIT（））；
jtdsproc.setInt（11，sqlorderquerys.getMEALPLANID（））；
jtdsproc.setInt（12，sqlorderquerys.getcashfresultid（））；
jtdsproc.setInt（13，sqlorderquerys.get午餐类型（））；
jtdsproc.setInt（14，sqlorderquerys.getSCHOOL_ID（））；
jtdsproc.setString（15，SqlOrderQueries.getORDERDATE（））；
jtdsproc.setInt（16，sqlorderquerys.getCREDITAUTH（））；
if（sqlorderquerys.getCHECKNUM（）=-1）
{
jtdsproc.setNull（17，Types.INTEGER）；
}否则{
jtdsproc.setInt（17，sqlorderquerys.getCHECKNUM（））；
}
setInt（18，sqlorderquerys.getOVERRIDE（））；
jtdsproc.setInt（19，sqlorderquerys.getVOID（））；
jtdsproc.setInt（20，sqlorderquerys.getORDLOG_ID（））；
jtdsproc.setString（21，sqlorderquerys.getORDLOGNOTE（））；
orderResult=jtdsproc.executeQuery（）；
while（orderResult.next（））{
mOrderId=orderResult.getInt（1）；
Log.w（“销售处理程序的数据：OrderId”，
“$--”+orderResult.getInt（1））；
Log.w（“销售处理程序OrderIdLog的数据：”，
“$--”+orderResult.getInt（2））；
Log.w（“销售处理程序客户ID的数据：”，
“$--”+orderResult.getInt（3））；
Log.w（“销售处理程序平衡数据：”，
“$--”+orderResult.getFloat（4））；
Log.w（“销售人员的数据：”，
“$--”+orderResult.getFloat（5））；
Log.w（“销售处理程序Bonacebalance的数据：，”$--”
+getFloat（6））；
Log.w（“销售处理程序数据错误：”，
“$--”+orderResult.getString（7））；
}
}捕获（异常ee）{
试一试{
连接回滚（）；
}捕获（SQLE异常）{
e、 printStackTrace（）；
}
ee.printStackTrace（）；
return mOrderId=Utilities.NETWORK\u错误；
}
返回莫德里德；
}
公共静态布尔插入项（int-mOrderid，ArrayList-itemsid，
ArrayList MenuItemId、ArrayList itemsQuantity、，
ArrayList itemsSoldType，ArrayList itemsPrice）{
布尔insertStatus=false；
Connection conn=ConnectionProvider.getConnection（）；
PreparedStatement pStmt=null；
String insertString=“插入项目值（？，，，，，，，，，，，，，，？）”；
试一试{
连接设置自动提交（错误）；
pStmt=连接准备状态（插入字符串）；
对于（int i=0；i0）{
mItemshandler.onSucessOrder（结果）；
}
}
}.execute（）；
}
@凌驾
用户订单上的公共无效（int orderId）{
mOrderid=orderId；
新建异步任务（）{
@凌驾
受保护的ArrayList doInBackground（无效…参数）{
if（ConnectionProvider.checkConnection（）==false）{
返回null；
}
returnOrderSalesHandler.getNewItemId（mTotalItems）；
}
@凌驾
受保护的void onPostExecute（ArrayList结果）{
super.onPostExecute（结果）；
如果（结果==null）
{
AlertDialog.Builder mEAlert=新建AlertDialog.Builder（MacActivity）；
mEAlert.setMessage（“网络问题和订单未完成”）；
mEAlert.create（）.show（）；
}否则{
onSuccessItemId（结果）；
}
}
}.execute（）；
}
@凌驾
公共void onSucesItemId（ArrayList ItemId）{
itemsIds=itemIds；
新建异步任务（）{
@凌驾
受保护的布尔doInBackground（Void…params）{
if（ConnectionProvider.checkConnection（）==false）
{
返回false；
}
return OrderSalesHandler.insertItem（mOrderid、ItemsId、MenuItemId、itemsQuantity、itemsSoldType、itemsPrice）；
}
@凌驾
受保护的void onPostExecute（布尔结果）{
super.onPostExecute（结果）；
如果（结果==真）{
如果（isNO_PaYMENT（）==false）{
（（HomeActivity）mActivity.mSalesFragment.mPaymentDialog.Disclease（）；
}
（（HomeActivity）mActivity.mSalesFragment.onClick（（（HomeActivity）mActivity.mSalesFragment.McCancelButton）；
}
如果（结果==false）{
AlertDialog.Builder mEAlert=新建AlertDialog.Builder（MacActivity）；
mEAlert.setMessage（“网络问题和订单未完成”）；
mEAlert.create（）.show（）；
}
}
}.execute（）；
}
公共静态布尔值isNO_PaYMENT（）{
不退还任何款项；
}
公共静态无效设置无付款（布尔无付款）{
不付款=不付款
public void onSucessOrder(int result);
public void onSucessItemId(ArrayList<Integer> itemsIds);