检测器

本文档列出了 SpotBugs 中的所有检测器。

标准检测器

以下检测器默认启用：

OverridingMethodsMustInvokeSuperDetector

查找必须调用 super 的重写方法。

• CN: 父类方法被标注了 @OverridingMethodsMustInvokeSuper，但重写方法并未调用父类方法。 (OVERRIDING_METHODS_MUST_INVOKE_SUPER)

FindRoughConstants

查找与 Math.PI 等已知值大致（但并不精确）相等的常量。

• CNT: 发现已知常量的近似值 (CNT_ROUGH_CONSTANT_VALUE)

SynchronizeAndNullCheckField

该检测器查找先进行同步、随后进行空值检查的字段。

• NP: 对同一字段既进行同步又进行空值检查。 (NP_SYNC_AND_NULL_CHECK_FIELD)

InitializeNonnullFieldsInConstructor

查找在构造方法中未被赋值的非空字段。

• NP: 非空字段未初始化 (NP_NONNULL_FIELD_NOT_INITIALIZED_IN_CONSTRUCTOR)

BooleanReturnNull

查找返回类型为 Boolean 但显式返回 null 值的方法。

• NP: 返回类型为 Boolean 的方法显式返回 null (NP_BOOLEAN_RETURN_NULL)

OptionalReturnNull

查找返回类型为 Optional 但显式返回 null 值的方法。

• NP: 返回类型为 Optional 的方法显式返回 null (NP_OPTIONAL_RETURN_NULL)

ConfusionBetweenInheritedAndOuterMethod

查找继承方法与外部类方法之间可能产生的混淆。

• IA: 对继承方法或外部类方法的调用可能存在歧义 (IA_AMBIGUOUS_INVOCATION_OF_INHERITED_OR_OUTER_METHOD)

SynchronizationOnSharedBuiltinConstant

该检测器查找针对共享内置常量（例如 String）的同步操作。

• DL: 对 Boolean 进行同步 (DL_SYNCHRONIZATION_ON_BOOLEAN)

• DL: 对装箱基本类型进行同步 (DL_SYNCHRONIZATION_ON_BOXED_PRIMITIVE)

• DL: 对驻留的 String 进行同步 (DL_SYNCHRONIZATION_ON_INTERNED_STRING)

• DL: 对字符串字面量进行同步 (DL_SYNCHRONIZATION_ON_SHARED_CONSTANT)

• DL: 对装箱的基本类型值进行同步 (DL_SYNCHRONIZATION_ON_UNSHARED_BOXED_PRIMITIVE)

NoteUnconditionalParamDerefs

分析应用程序中的所有方法，以确定哪些方法会无条件地解引用参数。该信息会在后续的分析阶段中使用，用于查找可能向这些方法传递 null 值的调用点。

这是一个较慢的检测器。

• NP: equals() 方法未检查参数是否为 null (NP_EQUALS_SHOULD_HANDLE_NULL_ARGUMENT)

• NP: 参数必须非空，却被标记为可空 (NP_PARAMETER_MUST_BE_NONNULL_BUT_MARKED_AS_NULLABLE)

SynchronizeOnClassLiteralNotGetClass

查找对 getClass 的返回结果进行同步，而不是对类字面量进行同步的代码。

• WL: 对 getClass 而非类字面量进行同步 (WL_USING_GETCLASS_RATHER_THAN_CLASS_LITERAL)

InfiniteRecursiveLoop

查找无限递归循环。

• IL: 集合被添加到自身（IL_CONTAINER_ADDED_TO_ITSELF）

• IL: 明显的无限递归循环（IL_INFINITE_RECURSIVE_LOOP）

InfiniteLoop

查找无限循环。

• IL: 明显的无限循环（IL_INFINITE_LOOP）

VolatileUsage

查找 volatile 字段使用中的缺陷模式。

• VO: 对 volatile 字段的自增不是原子操作（VO_VOLATILE_INCREMENT）

• VO: 指向数组的 volatile 引用并不会将数组元素视为 volatile（VO_VOLATILE_REFERENCE_TO_ARRAY）

InheritanceUnsafeGetResource

查找对 this.getClass().getResource(...) 的使用，如果该类被另一个包中的类继承，可能产生意外结果。

• UI: 如果类被继承，使用 GetResource 可能不安全（UI_INHERITANCE_UNSAFE_GETRESOURCE）

DoInsideDoPrivileged

查找应当在 doPrivileged 块内执行的代码。

• DP: 类加载器应当只在 doPrivileged 块内创建（DP_CREATE_CLASSLOADER_INSIDE_DO_PRIVILEGED）

• DP: 调用的方法应当只在 doPrivileged 块内调用（DP_DO_INSIDE_DO_PRIVILEGED）

HugeSharedStringConstants

此检测器查找在多个类文件中重复出现的字符串常量。

• HSC: 大型字符串常量在多个类文件中重复（HSC_HUGE_SHARED_STRING_CONSTANT）

FinalizerNullsFields

此检测器查找将类字段置为 null 的终结器。这无助于垃圾收集器，将字段置为 null 没有任何效果。

• FI: 终结器将字段置为 null（FI_FINALIZER_NULLS_FIELDS）

• FI: 终结器只将字段置为 null（FI_FINALIZER_ONLY_NULLS_FIELDS）

MutableEnum

查找并警告可变的枚举字段。

• ME: 公开的枚举方法无条件地设置其字段（ME_ENUM_FIELD_SETTER）

• ME: 枚举字段是公开且可变的（ME_MUTABLE_ENUM_FIELD）

InconsistentAnnotations

此检测器发现直接应用于方法参数的类型限定符与这些方法参数的使用之间的不一致之处。

• NP: 参数必须非空，却被标记为可空（NP_PARAMETER_MUST_BE_NONNULL_BUT_MARKED_AS_NULLABLE）

RepeatedConditionals

此检测器查找包含重复条件测试的代码，例如 (x == 5 || x == 5)。

• RpC: 重复的条件测试（RpC_REPEATED_CONDITIONAL_TEST）

RedundantConditions

此检测器查找包含无效条件的代码，例如表达式 (x >= 10 && x >= 5) 中的第二个条件。

• UC: 条件没有任何作用（UC_USELESS_CONDITION）

• UC: 由于变量类型，条件没有任何作用（UC_USELESS_CONDITION_TYPE）

FormatStringChecker

检查不正确的格式字符串。

• FS: 格式字符串应使用 %n 而非 n（VA_FORMAT_STRING_USES_NEWLINE）

LostLoggerDueToWeakReference

该检测器会找出在 OpenJDK 6 下行为不同的代码，因为 OpenJDK 6 使用弱引用来持有 Logger。

• LG: 由于 OpenJDK 中的弱引用导致 Logger 丢失的潜在变更（LG_LOST_LOGGER_DUE_TO_WEAK_REFERENCE）

EqualsOperandShouldHaveClassCompatibleWithThis

检查 equals 方法是否对其操作数是否为某个类的实例进行判断，而该类与定义该 equals 方法的类不兼容。

• Eq: Equals 检查了不兼容的操作数（EQ_CHECK_FOR_OPERAND_NOT_COMPATIBLE_WITH_THIS）

CheckImmutableAnnotation

查找违反标注为 net.jcip.annotations.Immutable 或 javax.annotation.concurrent.Immutable 的类相关规则的情况。

• JCIP: 不可变类的字段应当为 final（JCIP_FIELD_ISNT_FINAL_IN_IMMUTABLE_CLASS）

DontCatchIllegalMonitorStateException

该检测器会查找捕获 IllegalMonitorStateException 的 try-catch 块。

• IMSE: 可疑地捕获 IllegalMonitorStateException（IMSE_DONT_CATCH_IMSE）

CloneIdiom

该检测器会查找编写可克隆类时违反惯用写法的情况。

• CN: 类实现了 Cloneable 但未定义或使用 clone 方法（CN_IDIOM）

• CN: clone 方法未调用 super.clone()（CN_IDIOM_NO_SUPER_CALL）

• CN: 类定义了 clone() 但未实现 Cloneable（CN_IMPLEMENTS_CLONE_BUT_NOT_CLONEABLE）

ComparatorIdiom

该检测器会查找编写实现 Comparator 的类时违反惯用写法的情况。

• Se: Comparator 未实现 Serializable（SE_COMPARATOR_SHOULD_BE_SERIALIZABLE）

FindFieldSelfAssignment

该检测器会查找通过读取同一字段的值来为该字段赋值的位置。

• SA: 字段的自赋值（SA_FIELD_SELF_ASSIGNMENT）

• SA: 局部变量的重复赋值（SA_LOCAL_DOUBLE_ASSIGNMENT）

FindSelfComparison

该检测器会查找将值与自身进行比较的位置。

• SA: 字段的重复赋值（SA_FIELD_DOUBLE_ASSIGNMENT）

• SA: 字段与自身的自比较（SA_FIELD_SELF_COMPARISON）

• SA: 涉及字段的无意义自运算（如 x & x）（SA_FIELD_SELF_COMPUTATION）

• SA: 值与自身的自比较（SA_LOCAL_SELF_COMPARISON）

• SA: 涉及变量的无意义自运算（如 x & x）（SA_LOCAL_SELF_COMPUTATION）

FindSelfComparison2

该检测器会查找将值与自身进行比较的位置。

• SA: 字段与自身的自比较（SA_FIELD_SELF_COMPARISON）

• SA: 涉及字段的无意义自运算（如 x & x）（SA_FIELD_SELF_COMPUTATION）

• SA: 值与自身的自比较（SA_LOCAL_SELF_COMPARISON）

• SA: 涉及变量的无意义自运算（如 x & x）（SA_LOCAL_SELF_COMPUTATION）

DroppedException

该检测器会查找捕获了异常但未对该异常做任何处理的代码。

• DE: 方法可能丢弃异常（DE_MIGHT_DROP）

• DE: 方法可能忽略异常（DE_MIGHT_IGNORE）

LoadOfKnownNullValue

查找对已知为 null 的值的加载操作。

• NP: 加载已知为 null 的值（NP_LOAD_OF_KNOWN_NULL_VALUE）

DumbMethodInvocations

该检测器用于查找传递给方法的错误参数（例如 substring(0)）。

• Dm: 硬编码的数据库密码常量（DMI_CONSTANT_DB_PASSWORD）

• Dm: 空的数据库密码（DMI_EMPTY_DB_PASSWORD）

• DMI: 代码包含对绝对路径名的硬编码引用（DMI_HARDCODED_ABSOLUTE_FILENAME）

• DMI: 调用了 substring(0)，该调用返回原始值（DMI_USELESS_SUBSTRING）

URLProblems

java.net.URL 上的 equals 和 hashCode 方法会解析域名。因此，这些操作的开销可能非常大，该检测器用于查找可能调用这些方法的地方。

• Dm: URL 的 equals 和 hashCode 方法具有阻塞性（DMI_BLOCKING_METHODS_ON_URL）

• Dm: 由 URL 组成的映射和集合可能成为性能负担（DMI_COLLECTION_OF_URLS）

DumbMethods

该检测器用于查找对无意义方法的调用，例如无参的 String 构造函数。

• BC: equals 方法不应对参数类型做任何假设（BC_EQUALS_METHOD_SHOULD_WORK_FOR_ALL_OBJECTS）

• BIT: 对有符号字节值进行按位加法（BIT_ADD_OF_SIGNED_BYTE）

• BIT: 对有符号字节值进行按位或运算（BIT_IOR_OF_SIGNED_BYTE）

• Dm: 无法使用反射检查不带运行时保留策略的注解是否存在（DMI_ANNOTATION_IS_NOT_VISIBLE_TO_REFLECTION）

• DMI: 方法参数顺序颠倒（DMI_ARGUMENTS_WRONG_ORDER）

• DMI: 由无法精确表示的 double 构造 BigDecimal（DMI_BIGDECIMAL_CONSTRUCTED_FROM_DOUBLE）

• DMI: hasNext 方法调用了 next（DMI_CALLING_NEXT_FROM_HASNEXT）

• Dm: 由 URL 组成的映射和集合可能成为性能负担（DMI_COLLECTION_OF_URLS）

• DMI: 噢！一次毫无意义的方法调用（DMI_DOH）

• Dm: 试图更改 ScheduledThreadPoolExecutor 的最大池大小是徒劳的（DMI_FUTILE_ATTEMPT_TO_CHANGE_MAXPOOL_SIZE_OF_SCHEDULED_THREAD_POOL_EXECUTOR）

• DMI: 在 int 上调用了 Double.longBitsToDouble（DMI_LONG_BITS_TO_DOUBLE_INVOKED_ON_INT）

• DMI: Random 对象被创建但仅使用一次（DMI_RANDOM_USED_ONLY_ONCE）

• Dm: 创建了核心线程数为零的 ScheduledThreadPoolExecutor（DMI_SCHEDULED_THREAD_POOL_EXECUTOR_WITH_ZERO_CORE_THREADS）

• Dm: 在需要 Runnable 的位置传入了 Thread（DMI_THREAD_PASSED_WHERE_RUNNABLE_EXPECTED）

• Dm: 对 EasyMock 方法的无效/空洞调用（DMI_VACUOUS_CALL_TO_EASYMOCK_METHOD）

• Dm: 方法调用了低效的 Boolean 构造函数；请改用 Boolean.valueOf(…)（DM_BOOLEAN_CTOR）

• Bx: 通过装箱原始值进行比较（DM_BOXED_PRIMITIVE_FOR_COMPARE）

• Bx：为解析基本类型而装箱/拆箱（DM_BOXED_PRIMITIVE_FOR_PARSING）

• Bx：方法仅为调用 toString 而分配装箱基本类型（DM_BOXED_PRIMITIVE_TOSTRING）

• Dm：建议使用带 Locale 参数的重载方法（DM_CONVERT_CASE）

• Dm：方法调用了 System.exit(…)（DM_EXIT）

• Dm：显式垃圾回收；除非在基准测试代码中，否则极不可取（DM_GC）

• Dm：Math.max 与 Math.min 的错误组合（DM_INVALID_MIN_MAX）

• Dm：在 Condition 上调用了监视器的 wait()（DM_MONITOR_WAIT_ON_CONDITION）

• Dm：方法分配对象只是为了获取其类对象（DM_NEW_FOR_GETCLASS）

• Dm：使用 Random 的 nextInt 方法，而不是通过 nextDouble 来生成随机整数（DM_NEXTINT_VIA_NEXTDOUBLE）

• Dm：方法调用了危险的方法 runFinalizersOnExit（DM_RUN_FINALIZERS_ON_EXIT）

• Dm：方法调用了低效的 new String(String) 构造函数（DM_STRING_CTOR）

• Dm：方法在 String 上调用了 toString() 方法（DM_STRING_TOSTRING）

• Dm：方法调用了低效的 new String() 构造函数（DM_STRING_VOID_CTOR）

• Dm：使用默认的空 run 方法创建了线程（DM_USELESS_THREAD）

• INT：int 值与 long 常量的错误比较（INT_BAD_COMPARISON_WITH_INT_VALUE）

• INT：非负值与负常量或零的错误比较（INT_BAD_COMPARISON_WITH_NONNEGATIVE_VALUE）

• INT：带符号 byte 的错误比较（INT_BAD_COMPARISON_WITH_SIGNED_BYTE）

• INT：对整数取模 1（INT_BAD_REM_BY_1）

• INT：对整数值进行无意义的位掩码运算（INT_VACUOUS_BIT_OPERATION）

• INT：对整数值进行无意义的比较（INT_VACUOUS_COMPARISON）

• NP：立即解引用 readLine() 的结果（NP_IMMEDIATE_DEREFERENCE_OF_READLINE）

• RANGE：数组索引越界（RANGE_ARRAY_INDEX）

• RANGE：数组长度越界（RANGE_ARRAY_LENGTH）

• RANGE：数组偏移量越界（RANGE_ARRAY_OFFSET）

• RANGE：字符串索引越界（RANGE_STRING_INDEX）

• RV：0 到 1 之间的随机值被强制转换为整数 0（RV_01_TO_INT）

• RV：错误地计算带符号 32 位 hashcode 的绝对值（RV_ABSOLUTE_VALUE_OF_HASHCODE）

• RV：错误地计算带符号随机整数的绝对值（RV_ABSOLUTE_VALUE_OF_RANDOM_INT）

• RV：hashCode 的余数可能为负（RV_REM_OF_HASHCODE）

• RV：32 位带符号随机整数的余数（RV_REM_OF_RANDOM_INT）

• SW：某些 swing 方法必须在 Swing 线程中调用（SW_SWING_METHODS_INVOKED_IN_SWING_THREAD）

NumberConstructor

查找以基本类型为参数调用 Number 构造函数的情况。

• Bx：方法调用了低效的浮点 Number 构造函数；应改用静态 valueOf（DM_FP_NUMBER_CTOR）

• Bx: 方法调用了低效的 Number 构造函数，请改用静态 valueOf（DM_NUMBER_CTOR）

FindSqlInjection

该检测器使用数据流分析来查找对 SQL 语句的 execute 方法的调用，其中作为参数传递的并非常量字符串。

• SQL: 向 SQL 语句的 execute 或 addBatch 方法传递了非常量字符串（SQL_NONCONSTANT_STRING_PASSED_TO_EXECUTE）

• SQL: 由非常量字符串生成了预编译语句（SQL_PREPARED_STATEMENT_GENERATED_FROM_NONCONSTANT_STRING）

FindDoubleCheck

该检测器用于查找双重检查锁定的实例。

• DC: 可能对字段进行了双重检查（DC_DOUBLECHECK）

• DC: 可能暴露了部分初始化的对象（DC_PARTIALLY_CONSTRUCTED）

FindFinalizeInvocations

该检测器用于查找对 finalize() 的调用以及其他与终结器相关的问题。

• FI: 空终结器应予删除（FI_EMPTY）

• FI: 显式调用了终结器（FI_EXPLICIT_INVOCATION）

• FI: 终结器未调用超类的终结器（FI_MISSING_SUPER_CALL）

• FI: 终结器将超类的终结器置空（FI_NULLIFY_SUPER）

• FI: 终结器应声明为 protected 而非 public（FI_PUBLIC_SHOULD_BE_PROTECTED）

• FI: 终结器除调用超类终结器外未做任何事情（FI_USELESS）

FindHEmismatch

该检测器用于查找 hashCode() 和 equals() 方法定义中的问题。

• Co: 抽象类定义了协变的 compareTo() 方法（CO_ABSTRACT_SELF）

• Co: 定义了协变的 compareTo() 方法（CO_SELF_NO_OBJECT）

• Eq: 抽象类定义了协变的 equals() 方法（EQ_ABSTRACT_SELF）

• Eq: 类定义了 compareTo(…) 并使用 Object.equals()（EQ_COMPARETO_USE_OBJECT_EQUALS）

• Eq: 类未覆盖超类中的 equals（EQ_DOESNT_OVERRIDE_EQUALS）

• Eq: 为枚举定义了协变的 equals() 方法（EQ_DONT_DEFINE_EQUALS_FOR_ENUM）

• Eq: 定义的 equals() 方法未覆盖 equals(Object)（EQ_OTHER_NO_OBJECT）

• Eq: 定义的 equals() 方法未覆盖 Object.equals(Object)（EQ_OTHER_USE_OBJECT）

• Eq: 定义了协变的 equals() 方法（EQ_SELF_NO_OBJECT）

• Eq: 定义了协变的 equals() 方法，并继承了 Object.equals(Object)（EQ_SELF_USE_OBJECT）

• HE: 类定义了 equals() 但未定义 hashCode()（HE_EQUALS_NO_HASHCODE）

• HE: 类定义了 equals() 并使用 Object.hashCode()（HE_EQUALS_USE_HASHCODE）

• HE: 类定义了 hashCode() 但未定义 equals()（HE_HASHCODE_NO_EQUALS）

• HE: 类定义了 hashCode() 并使用 Object.equals()（HE_HASHCODE_USE_OBJECT_EQUALS）

• HE: 类继承了 equals() 并使用 Object.hashCode()（HE_INHERITS_EQUALS_USE_HASHCODE）

• HE: 签名声明在哈希结构中使用了不可哈希的类（HE_SIGNATURE_DECLARES_HASHING_OF_UNHASHABLE_CLASS）

• HE：在哈希数据结构中使用没有 hashCode() 方法的类（HE_USE_OF_UNHASHABLE_CLASS）

OverridingEqualsNotSymmetrical

查找重写超类中 equals 方法、且其等价关系可能不对称的 equals 方法。

• Eq：equals 方法始终返回 false（EQ_ALWAYS_FALSE）

• Eq：equals 方法始终返回 true（EQ_ALWAYS_TRUE）

• Eq：equals 方法比较的是类名而非类对象（EQ_COMPARING_CLASS_NAMES）

• Eq：equals 方法对子类型失效（EQ_GETCLASS_AND_CLASS_CONSTANT）

• Eq：equals 方法重写了超类中的 equals，且可能不对称（EQ_OVERRIDING_EQUALS_NOT_SYMMETRIC）

• Eq：不寻常的 equals 方法（EQ_UNUSUAL）

FindNakedNotify

该检测器查找看起来不会修改可变对象状态的 notify() 调用。

• NN：裸调用 notify（NN_NAKED_NOTIFY）

FindReturnRef

该检测器查找返回可变静态数据的方法。

• EI：通过返回共享非公共数据的缓冲区，可能暴露内部表示（EI_EXPOSE_BUF）

• EI2：通过创建包含数组引用的缓冲区，可能暴露内部表示（EI_EXPOSE_BUF2）

• EI：通过返回可变对象的引用，可能暴露内部表示（EI_EXPOSE_REP）

• EI2：通过持有可变对象的引用，可能暴露内部表示（EI_EXPOSE_REP2）

• MS：通过创建将外部数组存入静态字段的缓冲区，可能暴露内部静态状态（EI_EXPOSE_STATIC_BUF2）

• MS：通过将可变对象存入静态字段，可能暴露内部静态状态（EI_EXPOSE_STATIC_REP2）

• MS：通过返回共享非公共数据的缓冲区，可能暴露内部表示（MS_EXPOSE_BUF）

• MS：公共静态方法通过返回可变对象或数组，可能暴露内部表示（MS_EXPOSE_REP）

FindRunInvocations

该检测器查找对 Thread.run() 的调用。它是一个快速检测器。

• Ru：在某个线程上调用了 run（您是想调用 start 吗？）（RU_INVOKE_RUN）

SwitchFallthrough

该检测器查找包含贯穿（fall through）的 switch 语句。

• SF：因 switch 语句贯穿而导致的死存储（SF_DEAD_STORE_DUE_TO_SWITCH_FALLTHROUGH）

• SF：因 switch 语句贯穿到 throw 而导致的死存储（SF_DEAD_STORE_DUE_TO_SWITCH_FALLTHROUGH_TO_THROW）

• SF：发现某个 case 贯穿到下一个 case 的 switch 语句（SF_SWITCH_FALLTHROUGH）

• SF：发现缺少 default 分支的 switch 语句（SF_SWITCH_NO_DEFAULT）

FindSpinLoop

该检测器查找通过不断读取某个字段来自旋的循环。

• SP：方法在某个字段上自旋（SP_SPIN_ON_FIELD）

FindNonShortCircuit

该检测器查找可疑的非短路布尔运算符用法（使用了 | 和 & 而不是 || 和 &&）。

• NS：可能危险的非短路逻辑用法（NS_DANGEROUS_NON_SHORT_CIRCUIT）

• NS：可疑的非短路逻辑用法（NS_NON_SHORT_CIRCUIT）

FindTwoLockWait

该检测器用于查找在持有两个（或更多）锁的情况下调用 wait() 的情况。这是一个较慢的检测器。

• TLW：持有两个锁时进行等待（TLW_TWO_LOCK_WAIT）

FindUnconditionalWait

该检测器用于查找不在条件语句或循环中的 wait() 调用。

• UW：无条件等待（UW_UNCOND_WAIT）

FindUninitializedGet

该检测器用于查找构造函数中对未初始化字段的读取。

• UR：在构造函数中读取未初始化的字段（UR_UNINIT_READ）

DontUseEnum

检查字段和方法是否未使用 assert 或 enum 作为名称，因为它们在 Java 5 中是关键字。

• Nm：使用了在更高版本 Java 中为关键字的标识符（NM_FUTURE_KEYWORD_USED_AS_IDENTIFIER）

• Nm：使用了在更高版本 Java 中为关键字的标识符（NM_FUTURE_KEYWORD_USED_AS_MEMBER_IDENTIFIER）

FindUnsyncGet

该检测器用于查找 getter 和 setter 方法中 getter 未加同步而 setter 已加同步的情况。

• UG：get 方法未同步，set 方法已同步（UG_SYNC_SET_UNSYNC_GET）

InitializationChain

该检测器用于查找可能存在的循环类初始化依赖关系。

• IC：初始化循环依赖（IC_INIT_CIRCULARITY）

• SI：在所有 static final 字段赋值完成前静态初始化器创建了实例（SI_INSTANCE_BEFORE_FINALS_ASSIGNED）

IteratorIdioms

该检测器用于查找 Iterator 类定义方式中存在的问题。

• It：Iterator 的 next() 方法不能抛出 NoSuchElementException（IT_NO_SUCH_ELEMENT）

PreferZeroLengthArrays

该检测器用于查找既返回数组又返回显式 null 引用的方法。在这种情况下，通常返回零长度数组比返回 null 引用更可取。

• PZLA：考虑返回零长度数组而非 null（PZLA_PREFER_ZERO_LENGTH_ARRAYS）

SynchronizingOnContentsOfFieldToProtectField

该检测器用于查找似乎为了保护对某个字段的更新而在该字段上进行同步的代码。

• ML：试图通过在字段上同步来保护该字段的更新，但徒劳无功（ML_SYNC_ON_FIELD_TO_GUARD_CHANGING_THAT_FIELD）

MutableLock

该检测器用于查找在从被修改字段中读取的对象上进行同步的情况。

• ML：方法在被更新的字段上进行同步（ML_SYNC_ON_UPDATED_FIELD）

FindUselessObjects

查找无用的对象。

• UC：创建了无用的对象（UC_USELESS_OBJECT）

• UC：在栈上创建了无用的对象（UC_USELESS_OBJECT_STACK）

MutableStaticFields

该检测器用于查找可能被恶意代码修改的静态字段。

• MS：字段不是 final 的，无法防范恶意代码（MS_CANNOT_BE_FINAL）

• MS：字段应同时为 final 且具有包级保护（MS_FINAL_PKGPROTECT）

• MS：字段是可变数组 (MS_MUTABLE_ARRAY)

• MS：字段是可变集合 (MS_MUTABLE_COLLECTION)

• MS：字段是可变集合，应当受包保护 (MS_MUTABLE_COLLECTION_PKGPROTECT)

• MS：字段是可变的 Hashtable (MS_MUTABLE_HASHTABLE)

• MS：字段应当移出接口并设为包保护 (MS_OOI_PKGPROTECT)

• MS：字段应当设为包保护 (MS_PKGPROTECT)

• MS：字段不是 final 的，但应当是 (MS_SHOULD_BE_FINAL)

• MS：字段不是 final 的，但应当重构使其成为 final (MS_SHOULD_BE_REFACTORED_TO_BE_FINAL)

命名

该检测器用于查找可疑的命名方法。

• Nm：类定义了 equal(Object)；它应该是 equals(Object) 吗？ (NM_BAD_EQUAL)

• Nm：类名应以大写字母开头 (NM_CLASS_NAMING_CONVENTION)

• Nm：该类并非派生自 Exception，但其命名却如此 (NM_CLASS_NOT_EXCEPTION)

• Nm：容易混淆的方法名 (NM_CONFUSING)

• Nm：非 final 的字段名应以小写字母开头，final 字段应全部大写并以下划线分隔单词 (NM_FIELD_NAMING_CONVENTION)

• Nm：类定义了 hashcode()；它应该是 hashCode() 吗？ (NM_LCASE_HASHCODE)

• Nm：类定义了 tostring()；它应该是 toString() 吗？ (NM_LCASE_TOSTRING)

• Nm：明显的方法/构造函数混淆 (NM_METHOD_CONSTRUCTOR_CONFUSION)

• Nm：方法名应以小写字母开头 (NM_METHOD_NAMING_CONVENTION)

• Nm：类名不应遮蔽所实现接口的简单名称 (NM_SAME_SIMPLE_NAME_AS_INTERFACE)

• Nm：类名不应遮蔽父类的简单名称 (NM_SAME_SIMPLE_NAME_AS_SUPERCLASS)

• Nm：非常容易混淆的方法名 (NM_VERY_CONFUSING)

• Nm：非常容易混淆的方法名（但可能是有意为之） (NM_VERY_CONFUSING_INTENTIONAL)

• Nm：由于参数所属包错误，方法未能覆盖父类中的方法 (NM_WRONG_PACKAGE)

• Nm：由于参数所属包错误，方法未能覆盖父类中的方法 (NM_WRONG_PACKAGE_INTENTIONAL)

ReadReturnShouldBeChecked

该检测器用于查找调用了 InputStream.read() 或 InputStream.skip() 却忽略其返回值的情况。

• RR：方法忽略了 InputStream.read() 的结果 (RR_NOT_CHECKED)

• RR：方法忽略了 InputStream.skip() 的结果 (SR_NOT_CHECKED)

SerializableIdiom

该检测器用于查找 Serializable 类实现中潜在的问题。

• RS：类的 readObject() 方法被 synchronized 修饰 (RS_READOBJECT_SYNC)

• Se：可序列化类中存在非 transient 的不可序列化实例字段 (SE_BAD_FIELD)

• Se：不可序列化类包含一个可序列化的内部类 (SE_BAD_FIELD_INNER_CLASS)

• Se: 将不可序列化的值存入可序列化类的实例字段中（SE_BAD_FIELD_STORE）

• Se: 可序列化的内部类（SE_INNER_CLASS）

• Se: 方法必须为私有才能进行序列化（SE_METHOD_MUST_BE_PRIVATE）

• Se: serialVersionUID 不是 final 的（SE_NONFINAL_SERIALVERSIONID）

• Se: serialVersionUID 不是 long 类型（SE_NONLONG_SERIALVERSIONID）

• Se: serialVersionUID 不是 static 的（SE_NONSTATIC_SERIALVERSIONID）

• SnVI: 类实现了 Serializable，但未定义 serialVersionUID（SE_NO_SERIALVERSIONID）

• Se: 类实现了 Serializable，但其父类未定义无参构造函数（SE_NO_SUITABLE_CONSTRUCTOR）

• Se: 类实现了 Externalizable，但未定义无参构造函数（SE_NO_SUITABLE_CONSTRUCTOR_FOR_EXTERNALIZATION）

• Se: 防止外部化对象被覆盖（SE_PREVENT_EXT_OBJ_OVERWRITE）

• Se: 私有的 readResolve 方法不会被子类继承（SE_PRIVATE_READ_RESOLVE_NOT_INHERITED）

• Se: readResolve 方法不能声明为静态方法。（SE_READ_RESOLVE_IS_STATIC）

• Se: readResolve 方法的返回类型必须声明为 Object。（SE_READ_RESOLVE_MUST_RETURN_OBJECT）

• Se: 瞬态字段未在反序列化时恢复。（SE_TRANSIENT_FIELD_NOT_RESTORED）

• Se: 非 Serializable 类的瞬态字段。（SE_TRANSIENT_FIELD_OF_NONSERIALIZABLE_CLASS）

• WS: 类的 writeObject() 方法是 synchronized 的，但其他方法都不是（WS_WRITEOBJECT_SYNC）

StartInConstructor

该检测器查找会启动线程的构造函数。

• SC: 构造函数中调用了 Thread.start()（SC_START_IN_CTOR）

FindBadForLoop

该检测器查找不正确的 for 循环。

• QF: for 循环中复杂、微妙或错误的增量（QF_QUESTIONABLE_FOR_LOOP）

ExplicitSerialization

查找通过 readObject 和 writeObject 进行的显式序列化，作为该类确实被序列化的证据。

• ``

UnreadFields

此检测器用于查找其值从未被读取的字段。

• NP: 读取未写入的字段（NP_UNWRITTEN_FIELD）]

• NP: 读取未写入的 public 或 protected 字段（NP_UNWRITTEN_PUBLIC_OR_PROTECTED_FIELD）]

• SIC: 应为静态内部类（SIC_INNER_SHOULD_BE_STATIC）]

• SIC: 可重构为具名静态内部类（SIC_INNER_SHOULD_BE_STATIC_ANON）]

• SIC: 可重构为静态内部类（SIC_INNER_SHOULD_BE_STATIC_NEEDS_THIS）]

• SIC: 非静态内部类与 ThreadLocal 的致命纠缠（SIC_THREADLOCAL_DEADLY_EMBRACE）]

• SS: 未读取的字段：该字段是否应为 static？（SS_SHOULD_BE_STATIC）]

• ST: 从实例方法写入静态字段（ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD）]

• UrF: 未读取的字段（URF_UNREAD_FIELD）]

• UrF: 未读取的 public/protected 字段（URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD）]

• UuF: 未使用的字段（UUF_UNUSED_FIELD）]

• UuF: 未使用的 public 或 protected 字段（UUF_UNUSED_PUBLIC_OR_PROTECTED_FIELD）]

• UwF: 字段未在构造方法中初始化，却在未进行 null 检查的情况下被解引用（UWF_FIELD_NOT_INITIALIZED_IN_CONSTRUCTOR）]

• UwF: 字段始终只被赋值为 null（UWF_NULL_FIELD）]

• UwF: 未写入的字段（UWF_UNWRITTEN_FIELD）]

• UwF: 未写入的 public 或 protected 字段（UWF_UNWRITTEN_PUBLIC_OR_PROTECTED_FIELD）]

WaitInLoop

此检测器用于查找未处于循环中的 wait() 调用。

• No: 使用 notify() 而非 notifyAll()（NO_NOTIFY_NOT_NOTIFYALL）]

• Wa: Condition.await() 不在循环中（WA_AWAIT_NOT_IN_LOOP）]

• Wa: wait 不在循环中（WA_NOT_IN_LOOP）]

FindComparatorProblems

此检测器用于查找 Comparator.compare 或 Comparable.compareTo 实现中的问题。

• Co: compareTo()/compare() 对 float 或 double 值的处理不正确（CO_COMPARETO_INCORRECT_FLOATING）]

• Co: compareTo()/compare() 返回 Integer.MIN_VALUE（CO_COMPARETO_RESULTS_MIN_VALUE）]

FindNullDeref

此检测器用于查找可能发生空指针异常的地方，同时也查找引用值与 null 的冗余比较。这是一个较慢的检测器。

• NP: 空指针解引用（NP_ALWAYS_NULL）]

• NP: 异常路径上方法中的空指针解引用（NP_ALWAYS_NULL_EXCEPTION）]

• NP: 方法未对 null 参数进行检查（NP_ARGUMENT_MIGHT_BE_NULL）]

• NP: clone 方法可能返回 null（NP_CLONE_COULD_RETURN_NULL）]

• NP: 对始终为 null 的值调用 close()（NP_CLOSING_NULL）]

• NP: 未进行 null 检查即解引用 readLine() 的结果（NP_DEREFERENCE_OF_READLINE_VALUE）]

• NP: equals() 方法未对 null 参数进行检查（NP_EQUALS_SHOULD_HANDLE_NULL_ARGUMENT）]

• NP: null 值必定会被解引用（NP_GUARANTEED_DEREF）]

• [NP：值为 null 且在异常路径上必然被解引用（NP_GUARANTEED_DEREF_ON_EXCEPTION_PATH）]](https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#np-guaranteed-deref-on-exception-path)

• [NP：方法调用向非空参数传递了 null（NP_NONNULL_PARAM_VIOLATION）]](https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#np-nonnull-param-violation)

• [NP：方法可能返回 null，但声明为 @Nonnull（NP_NONNULL_RETURN_VIOLATION）]](https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#np-nonnull-return-violation)

• [NP：可能的空指针解引用（NP_NULL_ON_SOME_PATH）]](https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#np-null-on-some-path)

• [NP：方法在异常路径上可能的空指针解引用（NP_NULL_ON_SOME_PATH_EXCEPTION）]](https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#np-null-on-some-path-exception)

• [NP：由于被调用方法的返回值导致的可能的空指针解引用（NP_NULL_ON_SOME_PATH_FROM_RETURN_VALUE）]](https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#np-null-on-some-path-from-return-value)

• [NP：在可能不可行的分支上可能的空指针解引用（NP_NULL_ON_SOME_PATH_MIGHT_BE_INFEASIBLE）]](https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#np-null-on-some-path-might-be-infeasible)

• [NP：方法调用向非空参数传递了 null（NP_NULL_PARAM_DEREF）]](https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#np-null-param-deref)

• [NP：方法调用向非空参数传递了 null（NP_NULL_PARAM_DEREF_ALL_TARGETS_DANGEROUS）]](https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#np-null-param-deref-all-targets-dangerous)

• [NP：非虚方法调用向非空参数传递了 null（NP_NULL_PARAM_DEREF_NONVIRTUAL）]](https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#np-null-param-deref-nonvirtual)

• [NP：将 null 值存入标注为 @Nonnull 的字段（NP_STORE_INTO_NONNULL_FIELD）]](https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#np-store-into-nonnull-field)

• [NP：toString 方法可能返回 null（NP_TOSTRING_COULD_RETURN_NULL）]](https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#np-tostring-could-return-null)

• [RCN：对非空值与 null 进行了冗余比较（RCN_REDUNDANT_COMPARISON_OF_NULL_AND_NONNULL_VALUE）]](https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#rcn-redundant-comparison-of-null-and-nonnull-value)

• [RCN：对两个 null 值进行了冗余比较（RCN_REDUNDANT_COMPARISON_TWO_NULL_VALUES）]](https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#rcn-redundant-comparison-two-null-values)

• [RCN：对已知非空的值进行了冗余的 null 检查（RCN_REDUNDANT_NULLCHECK_OF_NONNULL_VALUE）]](https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#rcn-redundant-nullcheck-of-nonnull-value)

• [RCN：对已知为 null 的值进行了冗余的 null 检查（RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE）]](https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#rcn-redundant-nullcheck-of-null-value)

• [RCN：对先前已被解引用的值进行 null 检查（RCN_REDUNDANT_NULLCHECK_WOULD_HAVE_BEEN_A_NPE）]](https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#rcn-redundant-nullcheck-would-have-been-a-npe)

FindNullDerefsInvolvingNonShortCircuitEvaluation

该检测器用于查找可能发生空指针异常的位置，在这些位置上使用了非短路求值，导致常用的技术手段失效。

• [NP：null 值必然会被解引用（NP_GUARANTEED_DEREF）]](https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#np-guaranteed-deref)

• [NP：可能的空指针解引用（NP_NULL_ON_SOME_PATH）]](https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#np-null-on-some-path)

FindOpenStream

该检测器用于查找未逸出方法、且在方法的所有退出路径上似乎都未被关闭的 IO 流对象。它是一个较慢的检测器。

• [ODR：方法可能未关闭数据库资源（ODR_OPEN_DATABASE_RESOURCE）]](https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#odr-open-database-resource)

• [ODR：方法在异常时可能未关闭数据库资源（ODR_OPEN_DATABASE_RESOURCE_EXCEPTION_PATH）]](https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#odr-open-database-resource-exception-path)

• [OS：方法可能未关闭流（OS_OPEN_STREAM）]](https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#os-open-stream)

• [OS：方法在异常时可能未关闭流（OS_OPEN_STREAM_EXCEPTION_PATH）]](https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#os-open-stream-exception-path)

FindUselessControlFlow

该检测器用于查找没有任何作用的控制流语句。

• [UCF：无用的控制流（UCF_USELESS_CONTROL_FLOW）]](https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#ucf-useless-control-flow)

• [UCF：跳转到下一行的无用控制流（UCF_USELESS_CONTROL_FLOW_NEXT_LINE）]](https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#ucf-useless-control-flow-next-line)

FindUnreleasedLock

此检测器用于查找已被获取、但在方法的所有退出路径上均未释放的 JSR-166（java.util.concurrent）锁。它是一个中等速度的检测器。注意，要使用此检测器，需要在辅助类路径中包含 java.util.concurrent 包（或者正在分析该包本身）。

• UL: 方法未在所有路径上释放锁（UL_UNRELEASED_LOCK）

• UL: 方法未在所有异常路径上释放锁（UL_UNRELEASED_LOCK_EXCEPTION_PATH）

FindRefComparison

此检测器用于查找使用 == 或 != 运算符比较两个引用值的位置，且该类属于某种类型（例如 java.lang.String），比较引用值通常是一种错误。它是一个较慢的检测器。

• DMI: 哎呀！无意义的方法调用（DMI_DOH）

• EC: 使用 equals() 比较数组与非数组（EC_ARRAY_AND_NONARRAY）

• EC: 对数组调用 equals()，等同于 ==（EC_BAD_ARRAY_COMPARE）

• EC: 使用 equals(…) 比较不兼容的数组（EC_INCOMPATIBLE_ARRAY_COMPARE）

• EC: 调用 equals(null)（EC_NULL_ARG）

• EC: 调用 equals() 比较无关的类与接口（EC_UNRELATED_CLASS_AND_INTERFACE）

• EC: 调用 equals() 比较不同的接口类型（EC_UNRELATED_INTERFACES）

• EC: 调用 equals() 比较不同的类型（EC_UNRELATED_TYPES）

• EC: 使用指针相等性比较不同的类型（EC_UNRELATED_TYPES_USING_POINTER_EQUALITY）

• ES: 使用 == 或 != 比较 String 参数（ES_COMPARING_PARAMETER_STRING_WITH_EQ）

• ES: 使用 == 或 != 比较 String 对象（ES_COMPARING_STRINGS_WITH_EQ）

• RC: 可疑的引用比较（RC_REF_COMPARISON）

• RC: 与常量进行的可疑引用比较（RC_REF_COMPARISON_BAD_PRACTICE）

• RC: 对 Boolean 值进行的可疑引用比较（RC_REF_COMPARISON_BAD_PRACTICE_BOOLEAN）

FindMismatchedWaitOrNotify

此检测器用于查找看似未在当前被锁定的对象上调用 wait()、notify() 或 notifyAll() 的情况。它是一个中等速度的检测器。该检测器已被禁用，因为它仍在开发中，并且会产生过多的误报。

• MWN: 不匹配的 notify()（MWN_MISMATCHED_NOTIFY）

• MWN: 不匹配的 wait()（MWN_MISMATCHED_WAIT）

FindEmptySynchronizedBlock

此检测器用于查找空的 synchronized 块。

• ESync: 空的 synchronized 块（ESync_EMPTY_SYNC）

FindInconsistentSync2

此检测器用于查找在加锁方面访问方式不一致的字段。它是一个较慢的检测器。

• IS: 同步不一致（IS2_INCONSISTENT_SYNC）

• IS: 字段未针对并发访问进行防护（IS_FIELD_NOT_GUARDED）

• MSF: 可变的 servlet 字段（MSF_MUTABLE_SERVLET_FIELD）

FindLocalSelfAssignment2

此检测器用于查找局部变量的自赋值。

• SA: 局部变量自赋值 (SA_LOCAL_SELF_ASSIGNMENT)

• SA: 对局部变量自赋值而非赋值给字段 (SA_LOCAL_SELF_ASSIGNMENT_INSTEAD_OF_FIELD)

IncompatMask

该检测器用于查找可疑的按位逻辑表达式。

• BIT: 不兼容的位掩码 (BIT_AND)

• BIT: 检查是否 ((…) & 0) == 0 (BIT_AND_ZZ)

• BIT: 不兼容的位掩码 (BIT_IOR)

• BIT: 检查按位运算的符号 (BIT_SIGNED_CHECK)

• BIT: 检查涉及负数的按位运算的符号 (BIT_SIGNED_CHECK_HIGH_BIT)

LazyInit

该检测器用于查找字段不是 volatile 的延迟字段初始化。这是一个中等速度的检测器。

• LI: 静态字段的延迟初始化不正确 (LI_LAZY_INIT_STATIC)

• LI: 静态字段的延迟初始化和更新不正确 (LI_LAZY_INIT_UPDATE_STATIC)

FindJSR166LockMonitorenter

该检测器用于查找在 JSR166 锁上执行的普通同步。这是一个中等速度的检测器。

• JLM: 在 Lock 上执行同步 (JLM_JSR166_LOCK_MONITORENTER)

• JLM: 在 util.concurrent 实例上执行同步 (JLM_JSR166_UTILCONCURRENT_MONITORENTER)

• JLM: 在 util.concurrent 抽象上使用监视器风格的等待方法 (JML_JSR166_CALLING_WAIT_RATHER_THAN_AWAIT)

FindUncalledPrivateMethods

该检测器用于查找从未被调用的私有方法。

• UPM: 私有方法从未被调用 (UPM_UNCALLED_PRIVATE_METHOD)

UncallableMethodOfAnonymousClass

该检测器用于查找匿名内部类，这些类定义了可能本意是重写、但实际上并未重写父类中方法的方法。

• UMAC: 匿名类中定义的不可调用方法 (UMAC_UNCALLABLE_METHOD_OF_ANONYMOUS_CLASS)

StringConcatenation

该检测器用于查找在循环中使用 + 进行的字符串拼接。

• SBSC: 方法在循环中使用 + 拼接字符串 (SBSC_USE_STRINGBUFFER_CONCATENATION)

InvalidJUnitTest

该检测器用于查找格式不正确的 JUnit 测试。

• IJU: TestCase 声明了错误的 suite 方法 (IJU_BAD_SUITE_METHOD)

• IJU: TestCase 没有任何测试 (IJU_NO_TESTS)

• IJU: TestCase 定义了 setUp 但未调用 super.setUp() (IJU_SETUP_NO_SUPER)

• IJU: TestCase 实现了非静态的 suite 方法 (IJU_SUITE_NOT_STATIC)

• IJU: TestCase 定义了 tearDown 但未调用 super.tearDown() (IJU_TEARDOWN_NO_SUPER)

BadlyOverriddenAdapter

该检测器用于查找扩展 Adapter 类却以错误的签名重写 Listener 方法的代码。

• BOA: 类错误地重写了父类 Adapter 中实现的方法 (BOA_BADLY_OVERRIDDEN_ADAPTER)

BadResultSetAccess

该检测器用于查找对结果集的 getXXX 或 setXXX 方法的调用，其中字段索引为 0。由于 ResultSet 的字段索引从 1 开始，因此这始终是一个错误。

• SQL：方法尝试以索引 0 访问预编译语句参数 (SQL_BAD_PREPARED_STATEMENT_ACCESS)

• SQL：方法尝试以索引 0 访问结果集字段 (SQL_BAD_RESULTSET_ACCESS)

SuperfluousInstanceOf

此检测器查找使用 instanceof 运算符进行的类型检查，其中判断可以静态完成。

• SIO：使用 instanceof 运算符进行的多余类型检查 (SIO_SUPERFLUOUS_INSTANCEOF)

SuspiciousThreadInterrupted

此检测器查找在非静态上下文中对 Thread.interrupted() 的调用。如果它是通过 Thread.currentThread().interrupted() 调用的，那只是无用的操作，直接使用 Thread.interrupted() 即可。但是，如果它是在任意线程对象上调用的，那么这很可能是一个错误，因为 interrupted() 总是在当前线程上调用。

• STI：为调用 interrupted() 而使用了不必要的 currentThread() 调用 (STI_INTERRUPTED_ON_CURRENTTHREAD)

• STI：在 Thread 实例上调用了静态的 Thread.interrupted() 方法 (STI_INTERRUPTED_ON_UNKNOWNTHREAD)

FindDeadLocalStores

此检测器查找对局部变量的赋值，这些赋值随后从未被读取。它是一个中等速度的检测器。

• DLS：return 语句中的无效自增 (DLS_DEAD_LOCAL_INCREMENT_IN_RETURN)

• DLS：对局部变量的无效存储 (DLS_DEAD_LOCAL_STORE)

• DLS：对局部变量的无效 null 存储 (DLS_DEAD_LOCAL_STORE_OF_NULL)

• DLS：对遮蔽字段的局部变量的无效存储 (DLS_DEAD_LOCAL_STORE_SHADOWS_FIELD)

• DLS：类字面量的无效存储 (DLS_DEAD_STORE_OF_CLASS_LITERAL)

• IP：某参数在进入方法时已无效，但随后被覆盖 (IP_PARAMETER_IS_DEAD_BUT_OVERWRITTEN)

FindMaskedFields

此检测器查找被方法中定义的局部字段所遮蔽的类级别字段。

• MF：类定义了遮蔽父类字段的字段 (MF_CLASS_MASKS_FIELD)

• MF：方法定义了遮蔽字段的变量 (MF_METHOD_MASKS_FIELD)

WrongMapIterator

此检测器查找使用从 keySet 迭代器获取的键来访问 Map 条目的值的情况。

• WMI：使用 keySet 迭代器而非 entrySet 迭代器导致的低效用法 (WMI_WRONG_MAP_ITERATOR)

InstantiateStaticClass

此检测器查找基于仅定义静态方法的类来创建对象的代码。

• ISC：对仅提供静态方法的类进行了不必要的实例化 (ISC_INSTANTIATE_STATIC_CLASS)

RuntimeExceptionCapture

此检测器查找捕获 Exception 的 catch 子句，而该代码块中没有任何代码会抛出 Exception。

• REC：在未抛出 Exception 的情况下捕获了 Exception (REC_CATCH_EXCEPTION)

DontCatchNullPointerException

不应捕获空指针异常。

• DCN：捕获了 NullPointerException (DCN_NULLPOINTER_EXCEPTION)

FindFloatEquality

查找浮点数相等性表达式。一个快速的检测器。

• FE: 浮点数相等性测试 (FE_FLOATING_POINT_EQUALITY)

• FE: 对 NaN 进行相等性判断的注定无效测试 (FE_TEST_IF_EQUAL_TO_NOT_A_NUMBER)

FindUnsatisfiedObligation

此检测器用于查找在方法的所有退出路径上均未被清理的 I/O 流和数据库资源。这是一个运行较慢的检测器。

• OBL: 方法可能未清理流或资源 (OBL_UNSATISFIED_OBLIGATION)

• OBL: 方法在受检异常路径上可能未清理流或资源 (OBL_UNSATISFIED_OBLIGATION_EXCEPTION_EDGE)

UnnecessaryMath

此检测器用于查找对常量值调用 java.lang.Math 静态方法的代码，而其结果值在静态分析中是已知常量。直接使用该常量不仅更快，有时也更准确。

• UM: 方法对常量值调用了 Math 类的静态方法 (UM_UNNECESSARY_MATH)

RedundantInterfaces

此检测器用于查找声明实现了与其父类相同接口的类。这是多余的：如果父类实现了某个接口，子类自然也实现了该接口。

• RI: 类实现了与父类相同的接口 (RI_REDUNDANT_INTERFACES)

MultithreadedInstanceAccess

此检测器用于查找实现 Struts 框架时的潜在问题。

• MTIA: 类继承 Servlet 类并使用实例变量 (MTIA_SUSPECT_SERVLET_INSTANCE_FIELD)

• MTIA: 类继承 Struts Action 类并使用实例变量 (MTIA_SUSPECT_STRUTS_INSTANCE_FIELD)

BadUseOfReturnValue

查找在检查返回值非空之后又将其丢弃的情况。

• RV: 方法检查 String.indexOf 的结果是否为正数 (RV_CHECK_FOR_POSITIVE_INDEXOF)

• RV: 方法在检查 readLine 结果非空之后将其丢弃 (RV_DONT_JUST_NULL_CHECK_READLINE)

MethodReturnCheck

此检测器用于查找对方法返回值被可疑地忽略的调用。

• RV: 代码检查 compareTo 返回的特定值 (RV_CHECK_COMPARETO_FOR_SPECIFIC_RETURN_VALUE)

• RV: 异常被创建后丢弃而未抛出 (RV_EXCEPTION_NOT_THROWN)

• RV: 方法忽略返回值 (RV_RETURN_VALUE_IGNORED)

• RV: 方法忽略异常性返回值 (RV_RETURN_VALUE_IGNORED_BAD_PRACTICE)

• RV: 方法忽略返回值，这样可以吗？ (RV_RETURN_VALUE_IGNORED_INFERRED)

• RV: 无副作用方法的返回值被忽略 (RV_RETURN_VALUE_IGNORED_NO_SIDE_EFFECT)

• UC: 无用的非空 void 方法 (UC_USELESS_VOID_METHOD)

IDivResultCastToDouble

此检测器用于查找整数除法结果被转换为 double 的位置。通常，本意是先把整数操作数转换为 double，再进行除法运算。

• ICAST: 整数除法结果被转换为 double 或 float (ICAST_IDIV_CAST_TO_DOUBLE)

• ICAST：整型值被转换为 double，然后传给 Math.ceil（ICAST_INT_CAST_TO_DOUBLE_PASSED_TO_CEIL）

• ICAST：int 值被转换为 float，然后传给 Math.round（ICAST_INT_CAST_TO_FLOAT_PASSED_TO_ROUND）

FindBadCast2

该检测器使用数据流分析查找对象引用的错误转换。

• BC：可疑地转换为抽象集合（BC_BAD_CAST_TO_ABSTRACT_COLLECTION）

• BC：可疑地转换为具体集合（BC_BAD_CAST_TO_CONCRETE_COLLECTION）

• BC：不可能的类型转换（BC_IMPOSSIBLE_CAST）

• BC：不可能的向下转型（BC_IMPOSSIBLE_DOWNCAST）

• BC：对 toArray() 结果的不可能向下转型（BC_IMPOSSIBLE_DOWNCAST_OF_TOARRAY）

• BC：instanceof 将始终返回 false（BC_IMPOSSIBLE_INSTANCEOF）

• BC：未经检查/未确认的转换（BC_UNCONFIRMED_CAST）

• BC：对方法返回值未经检查/未确认的转换（BC_UNCONFIRMED_CAST_OF_RETURN_VALUE）

• BC：instanceof 将始终返回 true（BC_VACUOUS_INSTANCEOF）

• NP：对已知的 null 值检查其是否为某类型的实例（NP_NULL_INSTANCEOF）

FindUseOfNonSerializableValue

该检测器查找在要求可序列化的上下文中使用了不可序列化对象的情况。

• DMI：不可序列化对象被写入 ObjectOutput（DMI_NONSERIALIZABLE_OBJECT_WRITTEN）

• J2EE：将不可序列化对象存入 HttpSession（J2EE_STORE_OF_NON_SERIALIZABLE_OBJECT_INTO_SESSION）

BadSyntaxForRegularExpression

该检测器查找语法无效的正则表达式。

• RE：正则表达式语法无效（RE_BAD_SYNTAX_FOR_REGULAR_EXPRESSION）

• RE：将 File.separator 用作正则表达式（RE_CANT_USE_FILE_SEPARATOR_AS_REGULAR_EXPRESSION）

• RE：“.” 或 “|” 被用作正则表达式（RE_POSSIBLE_UNINTENDED_PATTERN）

VarArgsProblems

查找由 Java 5 可变参数引起的问题。

• VA：将基本类型数组传给期望可变数量对象参数的函数（VA_PRIMITIVE_ARRAY_PASSED_TO_OBJECT_VARARG）

FindPuzzlers

该检测器查找 Joshua Bloch 和 Neal Gafter 在其著作《Programming Puzzlers》中提到的各种小错误。

• BSHIFT：移位运算可能被错误解析（BSHIFT_WRONG_ADD_PRIORITY）

• Bx：基本类型值被装箱后立即拆箱（BX_BOXING_IMMEDIATELY_UNBOXED）

• Bx：基本类型值被装箱后又拆箱以执行基本类型强制转换（BX_BOXING_IMMEDIATELY_UNBOXED_TO_PERFORM_COERCION）

• Bx：基本类型值被拆箱并为三元运算符进行强制转换（BX_UNBOXED_AND_COERCED_FOR_TERNARY_OPERATOR）

• Bx：装箱值被拆箱后立即重新装箱（BX_UNBOXING_IMMEDIATELY_REBOXED）

• DLS：return 语句中的无用赋值（DLS_DEAD_LOCAL_STORE_IN_RETURN）

• DLS: 自增结果被覆盖（DLS_OVERWRITTEN_INCREMENT）

• DMI: 月份常量值错误（DMI_BAD_MONTH）

• DMI: 由于 Entry 对象被复用，添加条目集的元素可能会失败（DMI_ENTRY_SETS_MAY_REUSE_ENTRY_OBJECTS）

• DMI: 对数组调用 hashCode（DMI_INVOKING_HASHCODE_ON_ARRAY）

• USELESS_STRING: 对匿名数组调用 toString（DMI_INVOKING_TOSTRING_ON_ANONYMOUS_ARRAY）

• USELESS_STRING: 对数组调用 toString（DMI_INVOKING_TOSTRING_ON_ARRAY）

• EC: 对数组调用 equals()，其效果等同于 ==（EC_BAD_ARRAY_COMPARE）

• BSHIFT: 32 位 int 进行移位的位数不在 -31..31 范围内（ICAST_BAD_SHIFT_AMOUNT）

• ICAST: 整数乘法的结果被转换为 long（ICAST_INTEGER_MULTIPLY_CAST_TO_LONG）

• BSHIFT: 无符号右移的结果被转换为 short/byte（ICAST_QUESTIONABLE_UNSIGNED_RIGHT_SHIFT）

• IC: 超类在初始化期间使用了子类（IC_SUPERCLASS_USES_SUBCLASS_DURING_INITIALIZATION）

• IJU: run 方法中的 JUnit 断言不会被 JUnit 识别（IJU_ASSERT_METHOD_INVOKED_FROM_RUN_METHOD）

• IM: 平均值的计算可能会溢出（IM_AVERAGE_COMPUTATION_COULD_OVERFLOW）

• IM: 判断奇数的检查对负数不起作用（IM_BAD_CHECK_FOR_ODD）

• IM: 对取余结果进行整数乘法（IM_MULTIPLYING_RESULT_OF_IREM）

• PZ: 不要在迭代器中复用 entry 对象（PZ_DONT_REUSE_ENTRY_OBJECTS_IN_ITERATORS）

• RV: 对 compareTo()/compare() 的结果取负（RV_NEGATING_RESULT_OF_COMPARETO）

IntCast2LongAsInstant

查找使用 32 位值来表示自纪元以来毫秒数的代码。

• ICAST: int 值被转换为 long 并用作绝对时间（ICAST_INT_2_LONG_AS_INSTANT）

FindSleepWithLockHeld

该检测器查找在持有锁的情况下调用 Thread.sleep() 的代码。这是一个运行较慢的检测器。

• SWL: 方法在持有锁的情况下调用 Thread.sleep()（SWL_SLEEP_WITH_LOCK_HELD）

DuplicateBranches

该检测器查找 if/else 或 switch 语句中两个分支包含相同代码的情况，从而使判断失去意义。这通常是由于复制粘贴了两个分支，导致其中一个分支的逻辑不正确。

• DB: 方法的两个分支使用了相同的代码（DB_DUPLICATE_BRANCHES）

• DB: 方法的两个 switch 分支使用了相同的代码（DB_DUPLICATE_SWITCH_CLAUSES）

XMLFactoryBypass

该检测器查找对 XML 接口实现类的直接实例化。这样会使代码与特定实现绑定，而不是使用所提供的工厂模式来创建这些对象。

• XFB: 方法直接实例化了 XML 接口的特定实现（XFB_XML_FACTORY_BYPASS）

ConfusedInheritance

该检测器用于查找声明了 protected 成员的 final 类。由于该类无法被继承，对成员使用 protected 访问权限是不正确的。访问权限应改为 public 或 private，以体现该字段的真实意图。这很可能是由于该类的用途发生了变化，但并未将整个类全部改造成新范式所致。

• CI: 类是 final 但声明了 protected 字段 (CI_CONFUSED_INHERITANCE)

QuestionableBooleanAssignment

该检测器用于查找在条件表达式中将字面布尔值简单赋值给变量的情况。

• QBA: 方法在布尔表达式中赋值布尔字面量 (QBA_QUESTIONABLE_BOOLEAN_ASSIGNMENT)

AppendingToAnObjectOutputStream

查找向对象输出流追加内容的尝试。

• IO: 试图向对象输出流追加内容，注定失败 (IO_APPENDING_TO_OBJECT_OUTPUT_STREAM)

StaticCalendarDetector

该检测器会警告类型为 java.util.Calendar 或 java.text.DateFormat（及其子类）的静态字段，因为 Calendar 在本质上不适用于多线程环境。

• STCAL: 调用静态 Calendar (STCAL_INVOKE_ON_STATIC_CALENDAR_INSTANCE)

• STCAL: 调用静态 DateFormat (STCAL_INVOKE_ON_STATIC_DATE_FORMAT_INSTANCE)

• STCAL: 静态 Calendar 字段 (STCAL_STATIC_CALENDAR_INSTANCE)

• STCAL: 静态 DateFormat (STCAL_STATIC_SIMPLE_DATE_FORMAT_INSTANCE)

CheckTypeQualifiers

检查是否违反 JSR-305 类型限定符注解所指定的属性。

• TQ: 标注为带有某类型限定符的值，被用在要求该值不得带有该限定符的位置 (TQ_ALWAYS_VALUE_USED_WHERE_NEVER_REQUIRED)

• TQ: 比较带有不兼容类型限定符的值 (TQ_COMPARING_VALUES_WITH_INCOMPATIBLE_TYPE_QUALIFIERS)

• TQ: 要求值必须带有类型限定符，但其被标记为未知 (TQ_EXPLICIT_UNKNOWN_SOURCE_VALUE_REACHES_ALWAYS_SINK)

• TQ: 要求值不得带有类型限定符，但其被标记为未知 (TQ_EXPLICIT_UNKNOWN_SOURCE_VALUE_REACHES_NEVER_SINK)

• TQ: 可能不带有类型限定符的值，总是以要求该限定符的方式被使用 (TQ_MAYBE_SOURCE_VALUE_REACHES_ALWAYS_SINK)

• TQ: 可能带有类型限定符的值，总是以禁止其带有该限定符的方式被使用 (TQ_MAYBE_SOURCE_VALUE_REACHES_NEVER_SINK)

• TQ: 标注为从不带有某类型限定符的值，被用在要求该值带有该限定符的位置 (TQ_NEVER_VALUE_USED_WHERE_ALWAYS_REQUIRED)

• TQ: 不带类型限定符的值，被用在要求该值必须带有该限定符的位置 (TQ_UNKNOWN_VALUE_USED_WHERE_ALWAYS_STRICTLY_REQUIRED)

CrossSiteScripting

该检测器用于查找明显、突出的跨站脚本漏洞案例。

• HRS: 由不可信输入构造的 HTTP cookie (HRS_REQUEST_PARAMETER_TO_COOKIE)

• HRS: HTTP 响应拆分漏洞 (HRS_REQUEST_PARAMETER_TO_HTTP_HEADER)

• PT: Servlet 中的绝对路径遍历 (PT_ABSOLUTE_PATH_TRAVERSAL)

• PT: Servlet 中的相对路径遍历 (PT_RELATIVE_PATH_TRAVERSAL)

• XSS: JSP 反射型跨站脚本漏洞 (XSS_REQUEST_PARAMETER_TO_JSP_WRITER)

• XSS: 错误页面中的 Servlet 反射型跨站脚本漏洞 (XSS_REQUEST_PARAMETER_TO_SEND_ERROR)

• XSS: Servlet 反射型跨站脚本漏洞 (XSS_REQUEST_PARAMETER_TO_SERVLET_WRITER)

DontIgnoreResultOfPutIfAbsent

检查在忽略 putIfAbsent 的返回值时，作为第二个参数传入的值没有被重复使用。

• RV: 忽略 putIfAbsent 的返回值，并重复使用传给 putIfAbsent 的值 (RV_RETURN_VALUE_OF_PUTIFABSENT_IGNORED)

ReadOfInstanceFieldInMethodInvokedByConstructorInSuperclass

检查从超类的构造方法中调用的方法。

• UR: 从超类的构造方法中调用的方法对字段进行了未初始化读取 (UR_UNINIT_READ_CALLED_FROM_SUPER_CONSTRUCTOR)

AtomicityProblem

查找在并发抽象上执行的、不会以原子方式执行的操作序列（例如 get/put）。

• AT: 对并发抽象的一系列调用可能不是原子的 (AT_OPERATION_SEQUENCE_ON_CONCURRENT_ABSTRACTION)

DefaultEncodingDetector

检查对那些使用用户默认平台编码进行字节与 String（或 String 与字节）转换的方法的调用。这会导致应用程序的行为在不同平台之间存在差异。

• Dm: 依赖默认编码 (DM_DEFAULT_ENCODING)

CheckReliasingNullnessAnnotation

检查重写的方法是否放宽了返回值上的 @Nonnull（改为 @CheckForNull），或放宽了参数上的 @CheckForNull（改为 @Nonnull）。

• NP: 方法放宽了参数上的空值注解 (NP_METHOD_PARAMETER_TIGHTENS_ANNOTATION)

• NP: 方法放宽了返回值上的空值注解 (NP_METHOD_RETURN_RELAXING_ANNOTATION)

DontAssertInstanceofInTests

用于检测 JUnit 测试中通过断言 instanceof 运算符来检查对象类型的模式。

应当避免这种做法，因为不正确的强制类型转换所导致的 ClassCastException，可能比断言 instanceof 运算符结果时产生的 "false is not true" 消息提供更多关于错误原因的信息。

这是一个快速检测器

• JUA: 不建议在测试中断言 instanceof 的结果。(JUA_DONT_ASSERT_INSTANCEOF_IN_TESTS)

FindBadEndOfStreamCheck

用于检测在与 -1 比较之前先对 java.io.FileInputStream.read() 或 java.io.FileReader.read() 的返回值进行转换的模式。

两个方法都返回一个 int。如果将该 int 转换为 byte（FileInputStream.read() 的情况），则 -1 与字节 0xFF 将无法区分。如果转换为 char（FileReader.read() 的情况），则 -1 会变为 0xFFFF，即 Character.MAX_VALUE，因为在 Java 中字符是无符号的。

• EOS: 数据读取在与 -1 比较之前被转换 (EOS_BAD_END_OF_STREAM_CHECK)

ReflectionIncreaseAccessibility

检测其实例化参数中所传入类的公共方法。

攻击者可能会用一个没有公共构造方法的类来调用此方法。

• REFLC: 公共方法使用反射创建其参数中传入的类，这可能会提高任何类的可访问性 (REFLC_REFLECTION_MAY_INCREASE_ACCESSIBILITY_OF_CLASS)

• REFLF: 公共方法使用反射修改其参数中传入的字段，这可能会提高任何类的可访问性 (REFLF_REFLECTION_MAY_INCREASE_ACCESSIBILITY_OF_FIELD)

FindOverridableMethodCall

检测构造方法、clone() 或 readObject() 方法调用可被重写方法的模式。

从构造方法中调用可被重写的方法可能导致使用未初始化的数据。从 clone() 或 readObject() 方法中调用此类方法则不安全。

• MC: 在 clone() 方法中调用了可被重写的方法。(MC_OVERRIDABLE_METHOD_CALL_IN_CLONE)

• MC: 在构造方法中调用了可被重写的方法 (MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR)

• MC: 在 readObject 方法中调用了可被重写的方法。(MC_OVERRIDABLE_METHOD_CALL_IN_READ_OBJECT)

ConstructorThrow

查找会抛出异常的构造方法。

• CT: 注意避免让构造方法抛出异常。(CT_CONSTRUCTOR_THROW)

FindInstanceLockOnSharedStaticData

检测共享静态数据被实例级别的非静态同步方法修改，或在使用非静态锁对象的同步块内被修改的模式。

程序不得使用实例锁来保护静态共享数据，因为当创建两个或多个类的实例时，实例锁将不起作用。因此，若不使用静态锁对象，共享状态将无法免受并发访问的影响。

• SSD: 在共享静态数据上使用了实例级锁 (SSD_DO_NOT_USE_INSTANCE_LOCK_ON_SHARED_STATIC_DATA)

DontUseFloatsAsLoopCounters

检查循环计数器中的浮点数。

• FL: 不要将浮点变量用作循环计数器 (FL_FLOATS_AS_LOOP_COUNTERS)

PermissionsSuper

检查实现接口 java.security.SecureClassLoader 的类的 getPermissions() 方法。这些方法必须始终调用 super.getPermissions()，以获取其最终返回对象的初始值。

• PERM: 自定义类加载器未调用其父类的 getPermissions() (PERM_SUPER_NOT_CALLED_IN_GETPERMISSIONS)

FindPotentialSecurityCheckBasedOnUntrustedSource

查找在进入 doPrivileged 块之前，基于不可信源进行的潜在安全检查。

• USC: 基于不可信源的潜在安全检查。(USC_POTENTIAL_SECURITY_CHECK_BASED_ON_UNTRUSTED_SOURCE)

FindAssertionsWithSideEffects

查找具有副作用的断言。

• ASE: 断言中的表达式可能产生副作用 (ASE_ASSERTION_WITH_SIDE_EFFECT)

• ASE: 断言中调用的方法可能产生副作用 (ASE_ASSERTION_WITH_SIDE_EFFECT_METHOD)

FindPublicAttributes

该检测器查找既为 public、又被类的方法写入的属性。

• PA: 数组类型的字段为 public (PA_PUBLIC_ARRAY_ATTRIBUTE)

• PA: 可变对象类型的字段为 public (PA_PUBLIC_MUTABLE_OBJECT_ATTRIBUTE)

• PA: 基本类型的字段为 public (PA_PUBLIC_PRIMITIVE_ATTRIBUTE)

FindVulnerableSecurityCheckMethods

执行安全检查的方法应当防止被覆盖，因此它们必须声明为 private 或 final。否则，当恶意子类覆盖这些方法并跳过检查时，这些方法可能被破坏。

• VSC: 非 private 且非 final 的安全检查方法存在漏洞 (VSC_VULNERABLE_SECURITY_CHECK_METHODS)

FindArgumentAssertions

查找用于校验 public 方法参数的断言。

• AA: 断言被用于校验 public 方法的参数 (AA_ASSERTION_OF_ARGUMENTS)

UnnecessaryEnvUsage

检查对 System.getenv() 的调用，其中相应变量同样存在等价的 Java 属性。

• ENV: 建议使用可移植的 Java 属性而不是环境变量。(ENV_USE_PROPERTY_INSTEAD_OF_ENV)

MultipleInstantiationsOfSingletons

该检测器查找对使用单例设计模式编写类的相关惯用写法的违反情况。

• SING: 使用单例设计模式的类的实例获取方法未同步。(SING_SINGLETON_GETTER_NOT_SYNCHRONIZED)

• SING: 使用单例设计模式的类具有非 private 的构造器。(SING_SINGLETON_HAS_NONPRIVATE_CONSTRUCTOR)

• SING: 使用单例设计模式的类直接实现了 Cloneable 接口。(SING_SINGLETON_IMPLEMENTS_CLONEABLE)

• SING: 使用单例设计模式的类实现了 clone() 方法，但并非无条件地抛出 CloneNotSupportedException。(SING_SINGLETON_IMPLEMENTS_CLONE_METHOD)

• SING: 使用单例设计模式的类直接或间接实现了 Serializable 接口。(SING_SINGLETON_IMPLEMENTS_SERIALIZABLE)

• SING: 使用单例设计模式的类间接实现了 Cloneable 接口。(SING_SINGLETON_INDIRECTLY_IMPLEMENTS_CLONEABLE)