这可能是一个很晚的回复，但使用setCancelable就可以了。

alertDial.setCancelable(false);

编辑：这只适用于一些评论中提到的API 8+。

这是一个迟到的回答，但您可以在AlertDialog中添加一个onShowListener，然后可以覆盖按钮的onClickListener。

final AlertDialog dialog = new AlertDialog.Builder(context)
        .setView(v)
        .setTitle(R.string.my_title)
        .setPositiveButton(android.R.string.ok, null) //Set to null. We override the onclick
        .setNegativeButton(android.R.string.cancel, null)
        .create();

dialog.setOnShowListener(new DialogInterface.OnShowListener() {

    @Override
    public void onShow(DialogInterface dialogInterface) {

        Button button = ((AlertDialog) dialog).getButton(AlertDialog.BUTTON_POSITIVE);
        button.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View view) {
                // TODO Do something

                //Dismiss once everything is OK.
                dialog.dismiss();
            }
        });
    }
});
dialog.show();

以下是针对所有类型对话框的一些解决方案，包括AlertDialog.Builder的解决方案，该解决方案可以在所有API级别上工作（低于API 8，而这里的另一个答案则不适用）。有使用AlertDialog.Builder、DialogFragment和DialogPreference的AlertDialog解决方案。

下面的代码示例显示了如何覆盖默认的公共按钮处理程序，并防止这些不同形式的对话框关闭对话框。所有示例都显示了如何防止肯定按钮关闭对话框。

注意：对于那些需要更多详细信息的人来说，下面的示例描述了基本android类的对话框关闭是如何在后台工作的，以及为什么选择以下方法

AlertDialog.Builder-显示后立即更改默认按钮处理程序（）

AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
builder.setMessage("Test for preventing dialog close");
builder.setPositiveButton("Test", 
        new DialogInterface.OnClickListener()
        {
            @Override
            public void onClick(DialogInterface dialog, int which)
            {
                //Do nothing here because we override this button later to change the close behaviour. 
                //However, we still need this because on older versions of Android unless we 
                //pass a handler the button doesn't get instantiated
            }
        });
final AlertDialog dialog = builder.create();
dialog.show();
//Overriding the handler immediately after show is probably a better approach than OnShowListener as described below
dialog.getButton(AlertDialog.BUTTON_POSITIVE).setOnClickListener(new View.OnClickListener()
      {            
          @Override
          public void onClick(View v)
          {
              Boolean wantToCloseDialog = false;
              //Do stuff, possibly set wantToCloseDialog to true then...
              if(wantToCloseDialog)
                  dialog.dismiss();
              //else dialog stays open. Make sure you have an obvious way to close the dialog especially if you set cancellable to false.
          }
      });
      

DialogFragment-重写onResume（）

@Override
public Dialog onCreateDialog(Bundle savedInstanceState)
{
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
    builder.setMessage("Test for preventing dialog close");
    builder.setPositiveButton("Test", 
        new DialogInterface.OnClickListener()
        {
            @Override
            public void onClick(DialogInterface dialog, int which)
            {
                //Do nothing here because we override this button later to change the close behaviour. 
                //However, we still need this because on older versions of Android unless we 
                //pass a handler the button doesn't get instantiated
            }
        });
    return builder.create();
}

//onStart() is where dialog.show() is actually called on 
//the underlying dialog, so we have to do it there or 
//later in the lifecycle.
//Doing it in onResume() makes sure that even if there is a config change 
//environment that skips onStart then the dialog will still be functioning
//properly after a rotation.
@Override
public void onResume()
{
    super.onResume();    
    final AlertDialog d = (AlertDialog)getDialog();
    if(d != null)
    {
        Button positiveButton = (Button) d.getButton(Dialog.BUTTON_POSITIVE);
        positiveButton.setOnClickListener(new View.OnClickListener()
                {
                    @Override
                    public void onClick(View v)
                    {
                        Boolean wantToCloseDialog = false;
                        //Do stuff, possibly set wantToCloseDialog to true then...
                        if(wantToCloseDialog)
                            d.dismiss();
                        //else dialog stays open. Make sure you have an obvious way to close the dialog especially if you set cancellable to false.
                    }
                });
    }
}

DialogPreference-覆盖showDialog（）

@Override
protected void onPrepareDialogBuilder(Builder builder)
{
    super.onPrepareDialogBuilder(builder);
    builder.setPositiveButton("Test", this);   //Set the button here so it gets created
}

@Override
protected void showDialog(Bundle state)
{       
    super.showDialog(state);    //Call show on default first so we can override the handlers

    final AlertDialog d = (AlertDialog) getDialog();
    d.getButton(AlertDialog.BUTTON_POSITIVE).setOnClickListener(new View.OnClickListener()
            {            
                @Override
                public void onClick(View v)
                {
                    Boolean wantToCloseDialog = false;
                    //Do stuff, possibly set wantToCloseDialog to true then...
                    if(wantToCloseDialog)
                        d.dismiss();
                    //else dialog stays open. Make sure you have an obvious way to close the dialog especially if you set cancellable to false.
                }
            });
}

方法说明：

通过查看Android源代码，AlertDialog默认实现通过向OnCreate（）中的所有实际按钮注册公共按钮处理程序来工作。单击按钮时，通用按钮处理程序会将单击事件转发给您在setButton（）中传递的任何处理程序，然后调用该处理程序会关闭对话框。如果希望在按下其中一个按钮时阻止对话框关闭，则必须替换按钮实际视图的通用按钮处理程序。因为它是在OnCreate（）中分配的，所以必须在调用默认的OnCreate（（）实现后替换它。在show（）方法的过程中调用OnCreate。您可以创建一个自定义对话框类，并重写OnCreate（）以调用super.OnCreate（），然后重写按钮处理程序，但是如果您创建了自定义对话框，则无法免费获得Builder，在这种情况下，有什么意义？因此，按照对话框的设计方式使用对话框，但同时控制何时关闭对话框，一种方法是首先调用dialog.Show（），然后使用dialog.getButton（）获取对按钮的引用，以覆盖单击处理程序。另一种方法是使用setOnShowListener（）并实现查找按钮视图并替换OnShowListen中的处理程序。两者之间的功能差异“几乎”为零，这取决于最初创建对话框实例的线程。通过查看源代码，onShowListener被发送到创建该对话框的线程上运行的处理程序的消息调用。所以，由于OnShowListener是由发布在消息队列上的消息调用的，所以从技术上讲，调用侦听器可能会在显示完成后延迟一段时间。因此，我认为最安全的方法是首先调用show.Dialog（），然后立即在同一执行路径中替换按钮处理程序。由于调用show（）的代码将在主GUI线程上运行，这意味着在该线程上执行任何其他代码之前，都将先执行您跟随show（）执行的代码，而OnShowListener方法的计时取决于消息队列。

另一种解决方案

我想从用户体验的角度提出另一个答案。

为什么要在单击按钮时阻止对话框关闭？大概是因为您有一个自定义对话框，用户尚未在其中做出选择或尚未完全填写所有内容。如果他们还没有完成，那么你根本不应该让他们点击肯定按钮。只要禁用它，直到一切就绪。

这里的其他答案提供了许多技巧来覆盖积极的按钮点击。如果这一点很重要的话，安卓系统难道不会提供一个方便的方法吗？他们没有。

相反，Dialogs设计指南显示了这种情况的一个示例。在用户做出选择之前，“确定”按钮将被禁用。根本不需要任何压倒一切的技巧。用户很明显，在继续之前，仍需要做一些事情。

如何禁用正极按钮

有关创建自定义对话框布局的信息，请参阅Android文档。它建议您将AlertDialog放在DialogFragment中。然后，您需要做的就是在布局元素上设置侦听器，以知道何时启用或禁用肯定按钮。

如果自定义对话框具有单选按钮，请使用RadioGroup.OnCheckedChangeListener。如果自定义对话框有复选框，请使用CompoundButton.OnCheckedChangeListener。如果自定义对话框具有EditText，则使用TextWatcher。

正面按钮可以这样禁用：

AlertDialog dialog = (AlertDialog) getDialog();
dialog.getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(false);

这是一个完整的正在工作的DialogFragment，带有一个禁用的肯定按钮，如上图所示。

import android.support.v4.app.DialogFragment;
import android.support.v7.app.AlertDialog;

public class MyDialogFragment extends DialogFragment {

    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {

        // inflate the custom dialog layout
        LayoutInflater inflater = getActivity().getLayoutInflater();
        View view = inflater.inflate(R.layout.my_dialog_layout, null);

        // add a listener to the radio buttons
        RadioGroup radioGroup = (RadioGroup) view.findViewById(R.id.radio_group);
        radioGroup.setOnCheckedChangeListener(new RadioGroup.OnCheckedChangeListener() {
            @Override
            public void onCheckedChanged(RadioGroup radioGroup, int i) {
                // enable the positive button after a choice has been made
                AlertDialog dialog = (AlertDialog) getDialog();
                dialog.getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(true);
            }
        });

        // build the alert dialog
        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
        builder.setView(view)
                .setPositiveButton("OK", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int id) {
                        // TODO: use an interface to pass the user choice back to the activity
                    }
                })
                .setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int id) {
                        MyDialogFragment.this.getDialog().cancel();
                    }
                });
        return builder.create();
    }

    @Override
    public void onResume() {
        super.onResume();

        // disable positive button by default
        AlertDialog dialog = (AlertDialog) getDialog();
        dialog.getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(false);
    }
}

自定义对话框可以从如下活动运行：

MyDialogFragment dialog = new MyDialogFragment();
dialog.show(getFragmentManager(), "MyTag");

笔记

为了简洁起见，我省略了将用户选择信息传递回活动的通信接口。不过，文档显示了如何做到这一点。该按钮在onCreateDialog中仍然为空，因此我在onResume中禁用了它。如果用户切换到另一个应用程序，然后在不关闭对话框的情况下返回，则会再次禁用它。这可以通过取消选择任何用户选项或从onCreateDialog调用Runnable来在下次运行循环中禁用按钮来解决。view.post（newRunnable（）{@覆盖公共空运行（）{AlertDialogdialog=（AlertDialog）getDialog（）；dialog.getButton（AlertDialog.BUTTON.POSITIVE）.setEnabled（false）；}});

相关的

带有一个、两个和三个按钮的Android警报对话框如何在Android警报对话框中显示列表视图？

我编写了一个简单的类（AlertDialogBuilder），您可以使用它在按下对话框按钮时禁用自动关闭功能。

它还与Android 1.6兼容，因此它不使用OnShowListener（仅API>=8可用）。

因此，您可以使用此CustomAlertDialogBuilder，而不是使用AlertDialogBuilder。最重要的部分是不应该调用create（），而应该只调用show（）方法。我添加了setCanceledOnTouchOutside（）和setOnDismissListener等方法，这样您仍然可以直接在生成器上设置它们。

我在Android 1.6、2.x、3.x和4.x上测试了它，所以它应该工作得很好。如果你发现一些问题，请在这里评论。

package com.droidahead.lib.utils;

import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.view.View;
import android.view.View.OnClickListener;

public class CustomAlertDialogBuilder extends AlertDialog.Builder {
    /**
     * Click listeners
     */
    private DialogInterface.OnClickListener mPositiveButtonListener = null;
    private DialogInterface.OnClickListener mNegativeButtonListener = null;
    private DialogInterface.OnClickListener mNeutralButtonListener = null;

    /**
     * Buttons text
     */
    private CharSequence mPositiveButtonText = null;
    private CharSequence mNegativeButtonText = null;
    private CharSequence mNeutralButtonText = null;

    private DialogInterface.OnDismissListener mOnDismissListener = null;

    private Boolean mCancelOnTouchOutside = null;

    public CustomAlertDialogBuilder(Context context) {
        super(context);
    }

    public CustomAlertDialogBuilder setOnDismissListener (DialogInterface.OnDismissListener listener) {
        mOnDismissListener = listener;
        return this;
    }

    @Override
    public CustomAlertDialogBuilder setNegativeButton(CharSequence text, DialogInterface.OnClickListener listener) {
        mNegativeButtonListener = listener;
        mNegativeButtonText = text;
        return this;
    }

    @Override
    public CustomAlertDialogBuilder setNeutralButton(CharSequence text, DialogInterface.OnClickListener listener) {
        mNeutralButtonListener = listener;
        mNeutralButtonText = text;
        return this;
    }

    @Override
    public CustomAlertDialogBuilder setPositiveButton(CharSequence text, DialogInterface.OnClickListener listener) {
        mPositiveButtonListener = listener;
        mPositiveButtonText = text;
        return this;
    }

    @Override
    public CustomAlertDialogBuilder setNegativeButton(int textId, DialogInterface.OnClickListener listener) {
        setNegativeButton(getContext().getString(textId), listener);
        return this;
    }

    @Override
    public CustomAlertDialogBuilder setNeutralButton(int textId, DialogInterface.OnClickListener listener) {
        setNeutralButton(getContext().getString(textId), listener);
        return this;
    }

    @Override
    public CustomAlertDialogBuilder setPositiveButton(int textId, DialogInterface.OnClickListener listener) {
        setPositiveButton(getContext().getString(textId), listener);
        return this;
    }

    public CustomAlertDialogBuilder setCanceledOnTouchOutside (boolean cancelOnTouchOutside) {
        mCancelOnTouchOutside = cancelOnTouchOutside;
        return this;
    }



    @Override
    public AlertDialog create() {
        throw new UnsupportedOperationException("CustomAlertDialogBuilder.create(): use show() instead..");
    }

    @Override
    public AlertDialog show() {
        final AlertDialog alertDialog = super.create();

        DialogInterface.OnClickListener emptyOnClickListener = new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) { }
        };


        // Enable buttons (needed for Android 1.6) - otherwise later getButton() returns null
        if (mPositiveButtonText != null) {
            alertDialog.setButton(AlertDialog.BUTTON_POSITIVE, mPositiveButtonText, emptyOnClickListener);
        }

        if (mNegativeButtonText != null) {
            alertDialog.setButton(AlertDialog.BUTTON_NEGATIVE, mNegativeButtonText, emptyOnClickListener);
        }

        if (mNeutralButtonText != null) {
            alertDialog.setButton(AlertDialog.BUTTON_NEUTRAL, mNeutralButtonText, emptyOnClickListener);
        }

        // Set OnDismissListener if available
        if (mOnDismissListener != null) {
            alertDialog.setOnDismissListener(mOnDismissListener);
        }

        if (mCancelOnTouchOutside != null) {
            alertDialog.setCanceledOnTouchOutside(mCancelOnTouchOutside);
        }

        alertDialog.show();

        // Set the OnClickListener directly on the Button object, avoiding the auto-dismiss feature
        // IMPORTANT: this must be after alert.show(), otherwise the button doesn't exist..
        // If the listeners are null don't do anything so that they will still dismiss the dialog when clicked
        if (mPositiveButtonListener != null) {
            alertDialog.getButton(AlertDialog.BUTTON_POSITIVE).setOnClickListener(new OnClickListener() {

                @Override
                public void onClick(View v) {
                    mPositiveButtonListener.onClick(alertDialog, AlertDialog.BUTTON_POSITIVE);
                }
            });
        }

        if (mNegativeButtonListener != null) {
            alertDialog.getButton(AlertDialog.BUTTON_NEGATIVE).setOnClickListener(new OnClickListener() {

                @Override
                public void onClick(View v) {
                    mNegativeButtonListener.onClick(alertDialog, AlertDialog.BUTTON_NEGATIVE);
                }
            });
        }

        if (mNeutralButtonListener != null) {
            alertDialog.getButton(AlertDialog.BUTTON_NEUTRAL).setOnClickListener(new OnClickListener() {

                @Override
                public void onClick(View v) {
                    mNeutralButtonListener.onClick(alertDialog, AlertDialog.BUTTON_NEUTRAL);
                }
            });
        }

        return alertDialog;
    }   
}

EDIT下面是一个关于如何使用CustomAlertDialogBuilder的小示例：

// Create the CustomAlertDialogBuilder
CustomAlertDialogBuilder dialogBuilder = new CustomAlertDialogBuilder(context);

// Set the usual data, as you would do with AlertDialog.Builder
dialogBuilder.setIcon(R.drawable.icon);
dialogBuilder.setTitle("Dialog title");
dialogBuilder.setMessage("Some text..");

// Set your buttons OnClickListeners
dialogBuilder.setPositiveButton ("Button 1", new DialogInterface.OnClickListener() {
    public void onClick (DialogInterface dialog, int which) {
        // Do something...

        // Dialog will not dismiss when the button is clicked
        // call dialog.dismiss() to actually dismiss it.
    }
});

// By passing null as the OnClickListener the dialog will dismiss when the button is clicked.               
dialogBuilder.setNegativeButton ("Close", null);

// Set the OnDismissListener (if you need it)       
dialogBuilder.setOnDismissListener(new DialogInterface.OnDismissListener() {
    public void onDismiss(DialogInterface dialog) {
        // dialog was just dismissed..
    }
});

// (optional) set whether to dismiss dialog when touching outside
dialogBuilder.setCanceledOnTouchOutside(false);

// Show the dialog
dialogBuilder.show();

干杯

Yuvi

这可能是一个很晚的回复，但使用setCancelable就可以了。

alertDial.setCancelable(false);