Share
In de tutorial van vandaag leren we hoe we een hoge kwaliteit Android-code kunnen garanderen in onze projecten met behulp van een aantal statische codeanalysetools voor Java. We zullen kijken naar Checkstyle, FindBugs, PMD en Android Studio Lint-allemaal gratis en open source!
Dit zijn hulpmiddelen die uw broncode analyseren en analyseren zonder deze daadwerkelijk uit te voeren. Het doel is om potentiële kwetsbaarheden te vinden, zoals fouten en beveiligingsproblemen. Een populaire gratis statische codeanalysator zoals FindBugs controleert uw code tegen een reeks regels waaraan uw code moet voldoen. Als de code deze regels niet volgt, is dit een teken dat er iets mis is. Denk aan statische codeanalysetools als een aanvullende compiler die wordt uitgevoerd vóór de definitieve compilatie in de systeemtaal.
Veel softwarebedrijven eisen dat projecten statische codeanalysetests doorgeven, naast het uitvoeren van coderevisies en testen van eenheden in het bouwproces. Zelfs beheerders van open-sourceprojecten bevatten vaak een of meer statische codeanalysestappen in het bouwproces. Dus het leren van statische analyse is een belangrijke stap in het schrijven van kwaliteitscode. Houd er rekening mee dat statische code-analyse, ook wel "white-box" -test genoemd, niet gezien mag worden als een vervanging voor het testen van de unit van uw broncode..
In deze zelfstudie leren we enkele populaire statische analysetools die beschikbaar zijn voor Android en Java. Maar laten we eerst eens kijken naar de voordelen van statische analyse.
Alle codeanalysetools waarover we in deze tutorial leren, zijn beschikbaar als Gradle-plug-ins, zodat we voor elk van hen afzonderlijke Gradle-taken kunnen maken. Laten we een enkel Gradle-bestand gebruiken dat ze allemaal zal bevatten. Maar laten we eerst een map maken die al onze bestanden bevat voor de statische code-analyse.
Open Android Studio en in de app-module (in project weergave), maak een nieuwe map en geef deze een naam code_quality_tools. Deze map bevat de XML-bestanden voor de codeanalysetools en heeft ook een Gradle-bestand, quality.gradle, waarmee onze statische analysetaken worden uitgevoerd.
Bezoek alsjeblieft je build.gradle in de map met de app-module en voeg deze regel toe aan het einde van het bestand:
toepassen vanaf: '/code_quality_tools/quality.gradle'
Hier, onze kwaliteit.gradle Gradle-script wordt toegepast met een verwijzing naar de lokale bestandslocatie.
Gegeven regels die u in een XML-bestand opgeeft om een coderingsstandaard voor uw project af te dwingen, dwingt Checkstyle die regels af door uw broncode te analyseren en te vergelijken met bekende codestandaarden of conventies.
Checkstyle is een open-source tool die actief wordt onderhouden door de community. Dit betekent dat u uw eigen aangepaste controles kunt maken of bestaande kunt aanpassen aan uw behoeften. Checkstyle kan bijvoorbeeld een controle uitvoeren op de constante namen (definitief, statisch of beide) in uw klassen. Als uw constante namen zich niet houden aan de regel dat u in hoofdletters staat met woorden gescheiden door een onderstrepingsteken, wordt het probleem gemarkeerd in het eindrapport.
// incorrect private final static String myConstant = "myConstant"; // correcte persoonlijke definitieve statische string MY_CONSTANT = "myConstant";
Ik zal u laten zien hoe u Checkstyle kunt integreren in ons Android Studio-project en een praktisch voorbeeld kunt demonstreren.
Ten eerste moeten we onze codeerregels opstellen. Binnen Checkstyle.xml, we maken enkele Checkstyle-configuratieregels die tegen onze code worden uitgevoerd.
In de bovenstaande code nemen we de regels of controles op die we willen dat Checkstyle valideert in onze broncode. Eén regel is AvoidStarImport die, zoals de naam zegt, controleert of uw broncode een importstatement zoals bevat java.util. *. (In plaats daarvan moet u expliciet het pakket opgeven dat moet worden geïmporteerd, bijvoorbeeld. java.util.Observable.)
Sommige regels hebben eigenschappen, die we kunnen instellen zoals we deden voor ParameterNumber-dit beperkt het aantal parameters van een methode of constructor. Standaard is de eigenschap max is 7, maar in plaats daarvan hebben we dit in 6 veranderd. Bekijk enkele van de andere controles op de Checkstyle-website.
Om deze controle uit te voeren, moeten we een Gradle-taak maken. Dus bezoek de quality.gradle bestand en maak een taak met de naam checkstyle:
Accentsconagua
plug-in toepassen: 'checkstyle' taak checkstyle (type: Checkstyle) omschrijving 'Controleer code standaard' groep 'verificatie' configFile bestand ('./ code_quality_tools / checkstyle.xml') source 'src' include '** / *. java' exclude '** / gen / **' classpath = files () ignoreFailures = falseMerk op dat we in de bovenstaande code eerst de Checkstyle Gradle-plug-in hebben toegepast. We hebben het een beschrijving gegeven en het toegevoegd aan een reeds voorgedefinieerde Gradle-groep, verificatie genoemd.
De belangrijkste eigenschappen van de Checkstyle Gradle-taak waar het ons om gaat zijn:
Ten slotte kunt u het Gradle-script uitvoeren door naar het venster Gradle-tool op Android Studio te gaan en het verificatie groep en klik vervolgens op Checkstyle om de taak uit te voeren.
Een andere manier is om de opdrachtregel te gebruiken:
gradle checkstyle
Nadat de taak is voltooid, wordt een rapport gegenereerd, dat beschikbaar is op app-module> build> rapporten> checkstyle. Je kunt openen checkstyle.html om het rapport te bekijken.
Een Checkstyle-plug-in is gratis beschikbaar voor Android Studio of IntelliJ IDEA. Het biedt real-time scannen van uw Java-bestanden.
PMD is een ander open-source code-analysetool dat uw broncode analyseert. Het vindt veelvoorkomende fouten zoals ongebruikte variabelen, lege vangblokken, onnodige objectcreatie enzovoort. PMD heeft veel regelsets waaruit u kunt kiezen. Een voorbeeld van een regel die deel uitmaakt van de set ontwerpregels is:
SimplifyBooleanExpressions: vermijd onnodige vergelijkingen in Booleaanse expressies die eenvoudige code compliceren. Een voorbeeld: public class Bar // kan vereenvoudigd worden tot // bar = isFoo (); private boolean bar = (isFoo () == true); public isFoo () return false;
PMD is geconfigureerd met de pmd.xml het dossier. Daarin zullen we enkele configuratieregels opnemen, zoals die voor Android, Naming en Design.
Aangepaste regelset voor Android-applicatie .* / R.java .* / Gen /.*
Zoals we deden voor Checkstyle, moeten we ook een PMD Gradle-taak maken om de cheque uit te voeren binnen de quality.gradle het dossier.
plug-in toepassen: 'pmd'-taak pmd (type: Pmd) beschrijving' Run PMD 'group' verification 'ruleSetFiles = bestanden ("./ code_quality_tools / pmd.xml") source' src 'include' ** / *. java ' sluit '** / gen / **' rapporten uit xml.enabled = false html.enabled = true ignoreFailures = falsePMD is ook beschikbaar als een Gradle-plug-in.
De belangrijkste eigenschappen van de taak die we hebben gemaakt zijn:
Ten slotte kunt u het Gradle-script uitvoeren door naar het venster Gradle-tool te gaan, de map van de verificatiegroep te openen en vervolgens op te klikken pmd om de taak uit te voeren. Of u kunt het uitvoeren via de opdrachtregel:
gradle pmd
Een rapport zal ook worden gegenereerd na de uitvoering van de taak die beschikbaar is op app-module> build> rapporten> pmd. Er is ook een PMD-plug-in beschikbaar voor IntelliJ of Android Studio die u kunt downloaden en integreren als u dat wilt.
FindBugs is een andere gratis tool voor statische analyse die je klas analyseert op zoek naar potentiële problemen door je bytecodes te vergelijken met een bekende lijst van bugpatronen. Sommige ervan zijn:
testcase maar heeft geen testmethoden geïmplementeerd. Dit patroon staat ook onder de correctheidscategorie. FindBugs is een open-sourceproject, dus je kunt de voortgang van de broncode op GitHub bekijken, bijdragen of monitoren.
In de FindBugs-exclude.xml bestand willen we voorkomen dat FindBugs sommige klassen (met behulp van reguliere expressies) in onze projecten scant, zoals automatisch gegenereerde bronklassen en automatisch gegenereerde manifestklassen. Als u Dagger gebruikt, willen we dat FindBugs de gegenereerde Dagger-klassen niet controleert. We kunnen FindBugs ook vertellen om bepaalde regels te negeren als we dat willen.
En tot slot zullen we de FindBugs taak in quality.gradle:
plugin toepassen: 'findbugs' task findbugs (type: FindBugs) beschrijving 'Run findbugs' group 'verification' classes = files ("$ project.buildDir / intermediates / classes") source 'src' classpath = files () effort 'max 'reportLevel = "high" excludeFilter-bestand (' ./ code_quality_tools / findbugs-exclude.xml ') rapporten xml.enabled = false html.enabled = true ignoreFailures = falseIn de eerste regel hierboven hebben we FindBugs toegepast als een Gradle-plug-in en vervolgens een taak gemaakt met de naam FindBugs. De belangrijkste eigenschappen van de FindBugs taak waar we ons echt mee bezighouden zijn:
klassen: de te analyseren klassen.inspanning: het niveau van de analyse-inspanning. De opgegeven waarde moet een van zijn min, standaard, of max. Houd er rekening mee dat hogere niveaus de nauwkeurigheid vergroten en meer bugs vinden ten koste van de gebruikstijd en het geheugengebruik.reportLevel: de prioriteitsdrempel voor het melden van fouten. Indien ingesteld op laag, worden alle fouten gerapporteerd. Indien ingesteld op medium (standaard), worden bugs met middelgrote en hoge prioriteit gerapporteerd. Indien ingesteld op hoog, worden alleen bugs met hoge prioriteit gerapporteerd.excludeFilter: de bestandsnaam van een filter met daarin fouten die moeten worden uitgesloten van rapportage, die we al hebben gemaakt. Vervolgens kunt u het Gradle-script uitvoeren door naar het venster Gradle-tool te gaan, de map van de verificatiegroep te openen en vervolgens op te klikken FindBugs om de taak uit te voeren. Of start het vanaf de opdrachtregel:
gradle findbugs
Er wordt ook een rapport gegenereerd wanneer de taak is voltooid. Dit is beschikbaar op app-module> build> rapporten> findbugs. De plug-in FindBugs is een andere gratis beschikbare plug-in voor downloaden en integratie met IntelliJ IDEA of Android Studio.
Lint is een ander hulpmiddel voor code-analyse, maar deze wordt standaard geleverd met Android Studio. Het controleert de bronbestanden van uw Android-project op mogelijke fouten en optimalisaties voor correctheid, beveiliging, prestaties, bruikbaarheid, toegankelijkheid en internationalisatie.
Om Lint te configureren, moet u de lintOptions blokkeren op uw moduleniveau build.gradle het dossier:
lintOptions abortOnError false quiet true lintConfig file ('./ code_quality_tools / lint.xml')De belangrijkste Lint-opties waar we ons zorgen over maken zijn:
abortOnError: of pluis de exit-code van het proces moet instellen als er fouten worden gevonden.stil: of rapportage van de voortgang van de analyse moet worden uitgeschakeld.lintConfig: het standaard configuratiebestand dat moet worden gebruikt.Jouw lint.xml bestand kan onderwerpen bevatten die u wilt Lint om te negeren of aan te passen, zoals het onderstaande voorbeeld:
U kunt Lint handmatig vanuit Android Studio uitvoeren door op de knop te klikken Analyseren menu, kiezen Inspecteer code ... (de inspectieruimte is het hele project) en klik vervolgens op de OK om verder te gaan.
U kunt Lint ook uitvoeren door naar het venster Gradle-tool te gaan en het te openen verificatie groep en klik vervolgens op pluis. Ten slotte kunt u het via de opdrachtregel uitvoeren.
Op Windows:
gradlew lint
Op Linux of Mac:
./ gradlew lint
Er wordt ook een rapport gegenereerd wanneer de taak is voltooid, die beschikbaar is op app-module> build> outputs> lint-results.html.
StrictMode is een ontwikkelaarstool die helpt voorkomen dat ontwikkelaars van je project een toevallige flash-I / O of netwerk-I / O op de hoofdthread uitvoeren, omdat dit kan leiden tot een trage of niet-reagerende app. Het helpt ook bij het voorkomen dat ANR-dialoogvensters (App reageert niet) worden weergegeven. Als de StrictMode-problemen zijn gecorrigeerd, wordt uw app beter responsief en geniet de gebruiker van een soepelere ervaring. StrictMode gebruikt twee sets beleidsregels om zijn regels af te dwingen:
SQLiteCursor objecten of andere afsluitbaar object dat is gemaakt. if (BuildConfig.DEBUG) StrictMode.setThreadPolicy (nieuwe StrictMode.ThreadPolicy.Builder () .detectDiskReads () .detectDiskWrites () .detectNetwork () // of .detectAll () voor alle detecteerbare problemen .penaltyLog () // Log gedetecteerd schendingen van het systeemlogboek ... build ()); StrictMode.setVmPolicy (nieuwe StrictMode.VmPolicy.Builder () .detectLeakedSqlLiteObjects () .detectLeakedClosableObjects () .penaltyLog () .penaltyDeath () // Crasht het hele proces bij overtreding ... build ());
De bovenstaande code kan zich in uw toepassing, activiteit of andere toepassingscomponenten bevinden onCreate () methode.
U kunt meer leren over StrictMode hier op Envato Tuts+.
Een voorbeeld van een Android-project dat al het bovenstaande implementeert, inclusief regelsets voor de tools voor een typisch Android-project, is te vinden in de GitHub-repo van dit bericht..
In deze zelfstudie hebt u geleerd hoe u hoogwaardige Android-code kunt garanderen met behulp van statische codeanalysetools: wat ze zijn, voordelen van het gebruik ervan en hoe u Checkstyle, FindBugs, Lint, PMD en StrictMode in uw toepassing kunt gebruiken. Ga je gang en probeer deze tools eens uit. Misschien ontdek je een aantal problemen in je code die je nooit had verwacht.
Bekijk in de tussentijd enkele van onze andere cursussen en zelfstudies over de ontwikkeling van Android-apps!
