二、SonarQube自定义规则

灰太狼 2023-03-01 12:27 135阅读 0赞

### 一、介绍 ###

不可避免的，在实际的开发中sonar提供的官方的代码检测经常不满足我们的要求，比如如下代码：

/** * 以下代码sonar会认证name和age是从来没有使用过的，它不认识lombok的注解 */
    @lombok.Data
    public class SonarDto implements Serializable { 
        private static final long serialVersionUID = -8224351388102104833L;
        
        private String name;
        private String age;
    }

因为存在一些这样的问题，所以我们需要自定义数据自己的规则

--------------------

### 二、定义自己的规则 ###

登录到[http://localhost:8080][http_localhost_8080]新建规则

###### 不了解的同学可点击 三、项目介绍 前往查看介绍 ######

--------------------

### 三、项目介绍 ###

git地址：[https://gitee.com/chenzeze/cheez-custom-rules][https_gitee.com_chenzeze_cheez-custom-rules] 同学们可自行下载  
![在这里插入图片描述][format_png]

**org.sonar.template.java.JavaCustomRulesPlugin.java**

/** * 自定义插件的入口，将扩展类添加到容器中 */
    public class JavaCustomRulesPlugin implements Plugin { 
    
        @Override
        public void define(Context context) { 
            /** * server extensions -> objects are instantiated during server startup * 自定义规则的definition添加到组件中 */
            context.addExtension(JavaCustomRulesDefinition.class);
    
            /** * batch extensions -> objects are instantiated during code analysis * 将检查的类注册到组件中 */
            context.addExtension(JavaCustomRulesCheckRegistrar.class);
        }
    }

**org.sonar.template.java.JavaCustomRulesCheckRegistrar.java**

/** * 自定义规则注册 * Provide the "checks" (implementations of rules) classes that are going to be executed during * source code analysis. * <p> * This class is a batch extension by implementing the {@link org.sonar.plugins.java.api.CheckRegistrar} interface. */
    public class JavaCustomRulesCheckRegistrar implements CheckRegistrar { 
    
        /** * Register the classes that will be used to instantiate checks during analysis. */
        @Override
        public void register(RegistrarContext registrarContext) { 
            // Call to registerClassesForRepository to associate the classes with the correct repository key
            registrarContext.registerClassesForRepository(JavaCustomRulesDefinition.REPOSITORY_KEY, JavaCustomRulesList.getJavaChecks(), JavaCustomRulesList.getJavaTestChecks());
        }
    }

**org.sonar.template.java.JavaCustomRulesDefinition.java**

/** * 规则定义：可对等理解成Spring里面的BeanDefinition * <p> * Declare rule metadata in server repository of rules. * That allows to list the rules in the page "Rules". */
    public class JavaCustomRulesDefinition implements RulesDefinition { 
    
        // don't change that because the path is hard coded in CheckVerifier
        private static final String RESOURCE_BASE_PATH = "/org.sonar.l10n.java.rules.squid";
    
        public static final String REPOSITORY_KEY = "mycompany-java";
    
        private final Gson gson = new Gson();
    
        @Override
        public void define(Context context) { 
            NewRepository repository = context
                    .createRepository(REPOSITORY_KEY, "java")
                    .setName("MyCompany Custom Repository");
    
            for (Class<? extends JavaCheck> check : JavaCustomRulesList.getChecks()) { 
                new RulesDefinitionAnnotationLoader().load(repository, check);
                newRule(check, repository);
            }
            repository.done();
        }
    
        protected void newRule(Class<? extends JavaCheck> ruleClass, NewRepository repository) { 
    
            org.sonar.check.Rule ruleAnnotation = AnnotationUtils.getAnnotation(ruleClass, org.sonar.check.Rule.class);
            if (ruleAnnotation == null) { 
                throw new IllegalArgumentException("No Rule annotation was found on " + ruleClass);
            }
            String ruleKey = ruleAnnotation.key();
            if (StringUtils.isEmpty(ruleKey)) { 
                throw new IllegalArgumentException("No key is defined in Rule annotation of " + ruleClass);
            }
            NewRule rule = repository.rule(ruleKey);
            if (rule == null) { 
                throw new IllegalStateException("No rule was created for " + ruleClass + " in " + repository.key());
            }
            ruleMetadata(rule);
    
            rule.setTemplate(AnnotationUtils.getAnnotation(ruleClass, RuleTemplate.class) != null);
        }
    
        private void ruleMetadata(NewRule rule) { 
            String metadataKey = rule.key();
            addHtmlDescription(rule, metadataKey);
            addMetadata(rule, metadataKey);
        }
    
        private void addMetadata(NewRule rule, String metadataKey) { 
            URL resource = JavaCustomRulesDefinition.class.getResource(RESOURCE_BASE_PATH + "/" + metadataKey + "_java.json");
            if (resource != null) { 
                RuleMetatada metatada = gson.fromJson(readResource(resource), RuleMetatada.class);
                rule.setSeverity(metatada.defaultSeverity.toUpperCase(Locale.US));
                rule.setName(metatada.title);
                rule.addTags(metatada.tags);
                rule.setType(RuleType.valueOf(metatada.type));
                rule.setStatus(RuleStatus.valueOf(metatada.status.toUpperCase(Locale.US)));
                if (metatada.remediation != null) { 
                    rule.setDebtRemediationFunction(metatada.remediation.remediationFunction(rule.debtRemediationFunctions()));
                    rule.setGapDescription(metatada.remediation.linearDesc);
                }
            }
        }
    
        private static void addHtmlDescription(NewRule rule, String metadataKey) { 
            URL resource = JavaCustomRulesDefinition.class.getResource(RESOURCE_BASE_PATH + "/" + metadataKey + "_java.html");
            if (resource != null) { 
                rule.setHtmlDescription(readResource(resource));
            }
        }
    
        private static String readResource(URL resource) { 
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(resource.openStream()))) { 
                return reader.lines().collect(Collectors.joining("\n"));
            } catch (Exception e) { 
                throw new IllegalStateException("Failed to read: " + resource, e);
            }
        }
    
        private static class RuleMetatada { 
            String title;
            String status;
            @Nullable
            Remediation remediation;
    
            String type;
            String[] tags;
            String defaultSeverity;
        }
    
        private static class Remediation { 
            String func;
            String constantCost;
            String linearDesc;
            String linearOffset;
            String linearFactor;
    
            public DebtRemediationFunction remediationFunction(DebtRemediationFunctions drf) { 
                if (func.startsWith("Constant")) { 
                    return drf.constantPerIssue(constantCost.replace("mn", "min"));
                }
                if ("Linear".equals(func)) { 
                    return drf.linear(linearFactor.replace("mn", "min"));
                }
                return drf.linearWithOffset(linearFactor.replace("mn", "min"), linearOffset.replace("mn", "min"));
            }
        }
    
    }

**org.sonar.template.java.JavaCustomRulesList.java**

/** * 规则的集合 */
    public final class JavaCustomRulesList { 
    
        private JavaCustomRulesList() { 
        }
    
        public static List<Class> getChecks() { 
            return ImmutableList.<Class>builder().addAll(getJavaChecks()).addAll(getJavaTestChecks()).build();
        }
    
        /** * 自定义校验文件需要加到list中 */
        public static List<Class<? extends JavaCheck>> getJavaChecks() { 
            return Collections.unmodifiableList(Arrays.asList(
                    AbstractClassNameRule.class));
        }
    
        public static List<Class<? extends JavaCheck>> getJavaTestChecks() { 
            return ImmutableList.<Class<? extends JavaCheck>>builder()
                    // add HERE rules targeting test files
                    .build();
        }
    }

**org.sonar.template.java.checks.AbstractClassNameRule.java**

/** * @author chenze * @create: 2020-07-13 11:08 */
    @Rule(key = "AbstractClassName")
    /*@Rule(key = "AbstractClassNameCheck", name = "Avoid usage of the smaller length in local variable name", description = "This rule detects usage of smaller length local variable name. Variable name should not be smaller than 4 characters.", tags = {"coding-guideline"}, priority = Priority.MINOR)*/
    /*@SqaleSubCharacteristic(RulesDefinition.SubCharacteristics.ARCHITECTURE_CHANGEABILITY) //SQALE全称是Software Quality Assessment based on Lifecycle Expectations，是一套评估代码质量的方法。 @SqaleConstantRemediation("10min")*/
    public class AbstractClassNameRule extends BaseTreeVisitor implements JavaFileScanner { 
        public static final Logger LOGGER = LoggerFactory.getLogger(AbstractClassNameRule.class);
    
        private JavaFileScannerContext context;
    
        @Override
        public void scanFile(JavaFileScannerContext javaFileScannerContext) { 
            this.context = javaFileScannerContext;
            scan(context.getTree());
        }
    
        @Override
        public void visitClass(ClassTree tree) { 
            String className = tree.simpleName().name();
            LOGGER.info(className + "<<>>" + tree.symbol().isAbstract());
            if (tree.symbol().isAbstract()) { 
                //判断名称是否以Abstract 或 Base 开头
                String abName = "Abstract";
                String bsName = "Base";
                //判断类名如果小于Abstract 或 Base
                if (className.length() < abName.length()) { 
                    context.reportIssue(this, tree, "The Name Of Abstract Class should use Abstract or Base first");
                } else { 
                    //判断是否存在 Abstract 或 Base
                    if (!className.contains(abName)) { 
                        if (!className.contains(bsName)) { 
                            context.reportIssue(this, tree, "The Name Of Abstract Class should use Abstract or Base first");
                        } else { 
                            if (className.indexOf(bsName) != 0) { 
                                context.reportIssue(this, tree, "The Name Of Abstract Class should use Abstract or Base first");
                            }
                        }
                    } else { 
                        if (className.indexOf(abName) != 0) { 
                            context.reportIssue(this, tree, "The Name Of Abstract Class should use Abstract or Base first");
                        }
                    }
                }
            }
            super.visitClass(tree);
        }
    
    }

**org.sonar.l10n.java.rules.squid/AbstractClassName\_java.html**

<p>AbstractClassNameCheck Check</p>
    <h2>Noncompliant Code Example</h2>
    <pre>
        public abstract class HiClass {// Noncompliant
        }
    
        public abstract class MyNameIsAbstract {// Noncompliant
        }
    </pre>
    <h2>Compliant Solution》》正确写法</h2>
    <pre>
        public abstract class AbstractMysql {
        }
    
        public abstract class BaseMysql {
        }
    </pre>

**org.sonar.l10n.java.rules.squid/AbstractClassName\_java.json**

{ 
      "title": "The Name Of Abstract Class should use Abstract or Base first",
      "type": "BUG",
      "status": "ready",
      "remediation": { 
        "func": "Constant\/Issue",
        "constantCost": "5min"
      },
      "tags": [
        "bug",
        "pitfall"
      ],
      "defaultSeverity": "CRITICAL"
    }

--------------------

上一篇：[一、SonarQube安装与介绍][SonarQube]

[http_localhost_8080]: http://localhost:8080
[https_gitee.com_chenzeze_cheez-custom-rules]: https://gitee.com/chenzeze/cheez-custom-rules
[format_png]: /images/20230208/cbbcf1b836564b3c835123104b15b60b.png
[SonarQube]: https://blog.csdn.net/sinat_32869075/article/details/107578647