1.第一种 （抽取基类+回调）

public class PermissionActivity extends AppCompatActivity {

    private PermissionsResultListener mListener;
    private int mRequestCode;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }

    protected void checkPermissions(@NonNull String[] permissions, int requestCode, PermissionsResultListener listener) {
        List<String> permissionsList = new ArrayList<>();
        //权限不能为空
        if (permissions != null || permissions.length != 0) {
            mListener = listener;
            mRequestCode = requestCode;
            for (int i = 0; i < permissions.length; i++) {
                if (!isHavePermissions(permissions[i])) {
                    permissionsList.add(permissions[i]);
                } else {
                    mListener.onPermissionGranted(permissions[i]);
                }
            }
            //遍历完后申请
            requestPermissions(permissionsList);
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == mRequestCode) {
            if (grantResults.length > 0) {
                for (int i = 0; i < grantResults.length; i++) {
                    if (grantResults[i] == PackageManager.PERMISSION_GRANTED) {
                        mListener.onPermissionGranted(permissions[i]);
                    } else {
                        //如果应用之前请求过此权限但用户拒绝了请求，ActivityCompat.shouldShowRequestPermissionRationale(this,permissions[i])方法将返回 true,
                        // 但实际使用过程中发现第一次出现权限对话框也会返回true，如果用户在过去拒绝了权限请求，并在权限请求系统对话框中选择了 Don’t ask again 选项，
                        // 此方法将返回 false
                        if (!(ActivityCompat.shouldShowRequestPermissionRationale(this, permissions[i]))) {
                            mListener.onPermissionDeniedDontAskAgain(permissions[i]);
                        } else {
                            mListener.onPermissionDenied(permissions[i]);
                        }

                    }
                }
            } else {
                mListener.onPermissionFailure();
            }
        }
    }

    //判断权限是否申请
    private boolean isHavePermissions(@NonNull String permissions) {
        if (ContextCompat.checkSelfPermission(this, permissions) != PackageManager.PERMISSION_GRANTED) {
            return false;
        }
        return true;
    }

    //申请权限
    private void requestPermissions(List<String> permissionsList) {
        ActivityCompat.requestPermissions(this, permissionsList.toArray(new String[permissionsList.size()]), mRequestCode);
    }

    public interface PermissionsResultListener {

        //拒绝权限
        void onPermissionDenied(String permissions);

        //获取权限失败
        void onPermissionFailure();

        //成功获取权限
        void onPermissionGranted(String permissions);

        //拒绝了权限并且勾选了不再提示
        void onPermissionDeniedDontAskAgain(String permissions);
    }
}

在使用过程中需要将Activity继承自PermissionActivity ，并实现回调方法，如下所示

public class MainActivity extends PermissionActivity implements PermissionActivity.PermissionsResultListener {

    private String TAG = "MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        checkPermissions(new String[]{Manifest.permission.CALL_PHONE, Manifest.permission.WRITE_EXTERNAL_STORAGE}, 1, this);


    }

    @Override
    public void onPermissionDenied(String permission) {
        switch (permission) {
            case Manifest.permission.CALL_PHONE:
                Log.e(TAG, "拒绝了拨打电话的权限");
                break;
            case Manifest.permission.WRITE_EXTERNAL_STORAGE:
                Log.e(TAG, "拒绝了写存储卡的权限");
                break;
        }
    }

    @Override
    public void onPermissionFailure() {
        Log.e(TAG, "申请权限失败");
    }

    @Override
    public void onPermissionGranted(String permission) {
        switch (permission) {
            case Manifest.permission.CALL_PHONE:
                Log.e(TAG, "同意了拨打电话的权限");
                break;
            case Manifest.permission.WRITE_EXTERNAL_STORAGE:
                Log.e(TAG, "同意了写存储卡的权限");
                break;
        }

    }

    @Override
    public void onPermissionDeniedDontAskAgain(String permission) {
        switch (permission) {
            case Manifest.permission.CALL_PHONE:
                Log.e(TAG, "拒绝了拨打电话的权限并且不再询问");
                break;
            case Manifest.permission.WRITE_EXTERNAL_STORAGE:
                Log.e(TAG, "拒绝了写存储卡的权限并且不再询问");
                break;
        }
    }

}

上述方法看起来通俗易懂，但是在申请的权限较多时，需要进行多次的switch语句进行判断。代码稍显多。

第二种（注解+反射）

1.添加两个注解

//权限授予后执行的方法注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface PermissionGrantedMethod {
    public int requestCode();
}

//权限拒绝后执行的方法注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface PermissionDeniedMethod {
    public int requestCode();
}

2.增加权限的处理类PermissionHelper

public class PermissionHelper {
    private Object mObject;  //Fragment or Activity
    private int mRequestCode;  //请求码
    private String[] mRequestPermissions;  //请求的权限

    public PermissionHelper(Object object) {
        this.mObject = object;
    }

    public static void requestPermission(FragmentActivity activity, int requestCode, String[] permissions) {
        PermissionHelper.with(activity).requestCode(requestCode).requestPermission(permissions).request();
    }

    //链式调用
    public PermissionHelper with(Fragment fragment) {
        return new PermissionHelper(fragment);
    }

    public static PermissionHelper with(FragmentActivity activity) {
        return new PermissionHelper(activity);
    }

    public PermissionHelper requestCode(int requestCode) {
        mRequestCode = requestCode;
        return this;
    }

    public PermissionHelper requestPermission(String... permissions) {
        mRequestPermissions = permissions;
        return this;
    }

    //真正实现和发起权限请求
    public void request() {
        //判断当前版本是不是6.0及以上
        if (!PermissionUtil.isOverMarshmallow()) {
            //如果不是6.0以上则直接执行方法，通过反射获取方法执行
            PermissionUtil.excuteGrantedMethod(mObject, mRequestCode);
            return;
        } else {
            //如果是6.0以上，首先判断权限是否已经授予，获取还没有授予的权限
            List<String> deniedPermissionsList = PermissionUtil.getDeniedPermissionsList(mObject, mRequestPermissions);
            if (deniedPermissionsList.size() > 0) {
                //列表中含有没有授予的权限，则需要去请求权限
                PermissionUtil.requestPermissions(mObject, deniedPermissionsList, mRequestCode);

            } else {
                //如果权限已经授予则直接执行
                PermissionUtil.excuteGrantedMethod(mObject, mRequestCode);
            }
        }

    }

    /**
     * 判断原来没有申请到的权限是否由用户点击授予
     *
     * @param object
     * @param requestCode
     * @param permissions
     */
    public static void requestPermissionResult(Object object, int requestCode, String[] permissions, @NonNull int[] grantResults) {
        List<String> deniedPermissionsList = new ArrayList<>();
        //表示第一次申请，或上次申请权限均拒绝
        if (permissions.length == grantResults.length) {
            deniedPermissionsList = Arrays.asList(permissions);
        } else {
            deniedPermissionsList = PermissionUtil.getDeniedPermissionsList(object, permissions);
        }


        if (deniedPermissionsList.size() == 0) {
            //用户都同意授予权限，则执行方法
            PermissionUtil.excuteGrantedMethod(object, requestCode);
        } else {
            //申请的权限中有用户不同意的，同意则执行同意的代码。需要对权限进行区分。
            List<String> grantPermissionsList = PermissionUtil.getGrantPermissionsList();
            for (int i = 0; i < grantPermissionsList.size(); i++) {
                PermissionUtil.excuteGrantedMethod(object, requestCode, grantPermissionsList.get(i));
            }
            for (int i = 0; i < deniedPermissionsList.size(); i++) {
                if (grantResults[i] == PackageManager.PERMISSION_GRANTED) {
                    PermissionUtil.excuteGrantedMethod(object, requestCode, deniedPermissionsList.get(i));
                } else {
                    PermissionUtil.excuteDeniedMethod(object, requestCode, deniedPermissionsList.get(i));
                }
            }

        }
    }


}

3.权限的辅助工具类

public class PermissionUtil {
    private static List<String> grantPermissionsList = new ArrayList<>();

    public PermissionUtil() {
        throw new UnsupportedOperationException("Can not instantiated");
    }

    //判断当前版本是否在6.0及以上
    public static boolean isOverMarshmallow() {
        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.M;
    }

    public static void excuteGrantedMethod(Object mObject, int mRequestCode, String mRequestPermission) {
        Class clazz = mObject.getClass();
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method : methods) {
            //反射获取带有PermissionGrantedMethod的方法
            PermissionGrantedMethod permissionGrantedMethod = method.getAnnotation(PermissionGrantedMethod.class);
            //找到了有该注解的方法
            if (permissionGrantedMethod != null) {
                //获取注解中的请求码
                int requestCode = permissionGrantedMethod.requestCode();
                String requestPermission = permissionGrantedMethod.requestPermission();
                //若注解中的请求码和传递的请求码一直，则执行这个方法
                if (requestCode == mRequestCode && requestPermission == mRequestPermission) {
                    //反射执行该方法，第一个参数是这个方法属于哪个类，第二个参数是该方法的参数
                    excuteMethod(mObject, method);
                }
            }

        }
    }

    public static void excuteGrantedMethod(Object mObject, int mRequestCode) {
        Class clazz = mObject.getClass();
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method : methods) {
            //反射获取带有PermissionGrantedMethod的方法
            PermissionGrantedMethod permissionGrantedMethod = method.getAnnotation(PermissionGrantedMethod.class);
            //找到了有该注解的方法
            if (permissionGrantedMethod != null) {
                //获取注解中的请求码
                int requestCode = permissionGrantedMethod.requestCode();
                //若注解中的请求码和传递的请求码一直，则执行这个方法
                if (requestCode == mRequestCode) {
                    //反射执行该方法，第一个参数是这个方法属于哪个类，第二个参数是该方法的参数
                    excuteMethod(mObject, method);
                }
            }

        }
    }

    /**
     * 用户拒绝了权限，则执行拒绝的方法
     *
     * @param mObject
     * @param mRequestCode
     */
    public static void excuteDeniedMethod(Object mObject, int mRequestCode, String mRequestPermission) {
        Class clazz = mObject.getClass();
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method : methods) {
            //反射获取带有PermissionDeniedMethod的方法
            PermissionDeniedMethod permissionDeniedMethod = method.getAnnotation(PermissionDeniedMethod.class);
            //找到了有该注解的方法
            if (permissionDeniedMethod != null) {
                //获取注解中的请求码
                int requestCode = permissionDeniedMethod.requestCode();
                String requestPermission = permissionDeniedMethod.requestPermission();
                //若注解中的请求码和传递的请求码一直，则执行这个方法
                if (requestCode == mRequestCode && requestPermission == mRequestPermission) {
                    //反射执行该方法，第一个参数是这个方法属于哪个类，第二个参数是该方法的参数
                    excuteMethod(mObject, method);
                }
            }
        }
    }

    //反射执行方法
    private static void excuteMethod(Object mObject, Method method) {
        try {
            method.setAccessible(true);
            method.invoke(mObject, new Object[]{});
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取没有授予的权限
     *
     * @param object
     * @param requestPermissions
     * @return
     */
    public static List<String> getDeniedPermissionsList(Object object, String[] requestPermissions) {
        grantPermissionsList.clear();
        List<String> deniedPermissionsList = new ArrayList<>();
        for (String requestPermission : requestPermissions) {
            if (!isHavePermissions(object, requestPermission)) {
                //没有申请到这个权限则将其添加到列表中
                deniedPermissionsList.add(requestPermission);
            } else {
                grantPermissionsList.add(requestPermission);
            }
        }

        return deniedPermissionsList;
    }

    public static List<String> getGrantPermissionsList() {
        return grantPermissionsList;
    }


    //判断权限是否申请
    private static boolean isHavePermissions(Object object, @NonNull String permission) {
        if (ContextCompat.checkSelfPermission(getActivity(object), permission) != PackageManager.PERMISSION_GRANTED) {
            return false;
        }
        return true;
    }

    private static FragmentActivity getActivity(Object object) {
        if (object instanceof Fragment) {
            return ((Fragment) object).getActivity();
        } else if (object instanceof FragmentActivity) {
            return (FragmentActivity) object;
        }
        return null;
    }

    //申请权限
    public static void requestPermissions(Object object, List<String> deniedPermissionsList, int requestCode) {
        ActivityCompat.requestPermissions(getActivity(object), deniedPermissionsList.toArray(new String[deniedPermissionsList.size()]), requestCode);
    }
}

4.使用框架实例

public class SecondActivity extends AppCompatActivity {

    private String TAG = "MainActivity";
    private static final int CALL_PHONE_REQUEST_CODE = 0x11;
    private static final String CALL_PHONE_PERMISSION = Manifest.permission.CALL_PHONE;
    private static final String WRITE_EXTERNAL_STORAGE_PERMISSION = Manifest.permission.WRITE_EXTERNAL_STORAGE;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //checkPermissions(new String[]{Manifest.permission.CALL_PHONE, Manifest.permission.WRITE_EXTERNAL_STORAGE}, 1, this);
        PermissionHelper.requestPermission(this, CALL_PHONE_REQUEST_CODE, new String[]{CALL_PHONE_PERMISSION, WRITE_EXTERNAL_STORAGE_PERMISSION});
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == CALL_PHONE_REQUEST_CODE)
            PermissionHelper.requestPermissionResult(this, CALL_PHONE_REQUEST_CODE, new String[]{CALL_PHONE_PERMISSION, WRITE_EXTERNAL_STORAGE_PERMISSION}, grantResults);
    }

    @PermissionGrantedMethod(requestCode = CALL_PHONE_REQUEST_CODE, requestPermission = CALL_PHONE_PERMISSION)
    public void Call() {
        Log.e(TAG, "拨打电话");
    }

    @PermissionDeniedMethod(requestCode = CALL_PHONE_REQUEST_CODE, requestPermission = CALL_PHONE_PERMISSION)
    private void error() {
        Log.e(TAG, "拨打电话权限取消");
    }

    @PermissionGrantedMethod(requestCode = CALL_PHONE_REQUEST_CODE, requestPermission = WRITE_EXTERNAL_STORAGE_PERMISSION)
    private void write() {
        Log.e(TAG, "写存储卡");
    }

    @PermissionDeniedMethod(requestCode = CALL_PHONE_REQUEST_CODE, requestPermission = WRITE_EXTERNAL_STORAGE_PERMISSION)
    private void writeQuit() {
        Log.e(TAG, "写存储卡权限取消");
    }

}

目前框架还不够完善，如果我在申请权限中一个申请码对应两种以上权限，如果拒绝一种，则全部拒绝的问题。后序将修改。