NullPointerException er en de mest almindelige årsager til fejl i Java-programmer. I de enkleste tilfælde kan compileren advare dig direkte, hvis den støder på kode som denne:
Object o = null;
String s = o.toString();
Med forgreninger, løkker og afsendelse af undtagelser kræves en ret avanceret flowanalyse for at finde ud af, om en variabel, der derefereres, er tildelt en NULL/ikke-NULL-værdi på nogle af eller alle stierne gennem programmet.
På grund af den indbyggede kompleksitet er det bedst at udføre flowanalyse i små bidder. Analyse af én metode ad gangen kan gøres med god ydeevne fra værktøjet, hvorimod analyse af et helt system ligger uden for funktionsområdet for Java-compileren i Eclipse. Fordelen er, at analysen foregår hurtigt og kan gøres trinvist, så compileren straks kan afsende advarsler, mens du skriver. Ulempen er, at analysen ikke kan se, hvilke værdier (NULL eller ikke-NULL) der flyder mellem metoder (som parametre og returværdier).
Her kommer NULL-annotationer ind i billedet. Ved at angive en metodeparameter som @NonNull kan du informere compileren om, at du ikke ønsker en NULL-værdi på denne position.
String capitalize(@NonNull String in) {
return in.toUpperCase(); // no null check required
}
void caller(String s) {
if (s != null)
System.out.println(capitalize(s)); // preceding null check is required
}
Det indebærer to ting ifølge kontraktbaseret design:
capitalize har fordel af garantien for, at argumentet in ikke kan være NULL, og at dereferering uden en NULL-kontrol er i orden her. Situationen er den samme for metoders returværdier:
@NonNull String getString(String maybeString) {
if (maybeString != null)
return maybeString; // the above null check is required
else
return "<n/a>";
}
void caller(String s) {
System.out.println(getString(s).toUpperCase()); // no null check required
}
Java-compileren i Eclipse kan konfigureres til at bruge tre forskellige annotationstyper til sin udvidede NULL-analyse (som er deaktiveret som standard):
@NonNull: NULL er ikke en gyldig værdi @Nullable: NULL-værdier er tilladt og skal forventes @NonNullByDefault: typer i metodesignaturer, der mangler en NULL-annotation, opfattes som ikke-NULL (@NonNull). Annotationerne @NonNull og @Nullable understøttes disse steder:
@NonNullByDefault understøttes for
package-info.java-fil) - påvirker alle typer i pakken
Bemærk, at selv de faktiske, kvalificerede navne på disse annotationer kan konfigureres, men standardværdien er, at dem, der er anført ovenfor, anvendes (fra pakken org.eclipse.jdt.annotation).
En JAR-fil med standardannotationerne for NULL leveres med Eclipse i eclipse/plugins/org.eclipse.jdt.annotation_*.jar. Denne JAR-fil skal være i byggestien på kompileringstidspunktet, men behøver ikke være der ved runtime (så du behøver ikke distribuere den til brugerne af din kompilerede kode).
Der er to hurtige rettelser til ikke-fortolkede referencer til @NonNull, @Nullable eller @NonNullByDefault, der tilføjer JAR-filen til byggestien:


Det skulle nu fremgå, at NULL-annotationer tilføjer flere oplysninger til dit Java-program (som derefter kan bruges af compileren til at give bedre advarsler). Men hvad er det præcis, disse annotationer skal angive? Fra et pragmatisk synspunkt er der mindst tre niveauer, hvor vi gerne vil bruge NULL-annotationer:
Med hensyn til (1) kan du begynde at bruge NULL-annotationer med det samme uden at læse videre, men du skal ikke forvente mere end et lille tip nu og da. De andre niveauer kræver mere forklaring.
Ved første øjekast betyder brug af NULL-annotationer til API-specifikationer ifølge kontraktbaseret design blot, at alle API-metoders signatur skal være fuldstændigt annoteret, sådan at hver parameter og hver metodereturtype (bortset fra
primitive typer såsom int) markeres som enten @NonNull eller @Nullable. Eftersom det ville betyde, at der skal indsættes utrolig mange NULL-annotationer, er det godt at vide, at i veldesignet kode (især API-metoder) forekommer @NonNull betydeligt oftere end @Nullable. Antallet af annotationer kan derfor reduceres, ved at @NonNull angives som default ved hjælp af annotationen @NonNullByDefault på pakkeniveau.
Bemærk den vigtige forskel mellem @Nullable og udeladelse af en NULL-annotation: Annotationen angiver eksplicit, at NULL er i orden og skal forventes. Derimod betyder ingen annotation blot, at vi ikke ved, hvad hensigten er. Det er den gamle situation, hvor der enten udføres NULL-kontrol af begge parter (kalder og det kaldte), eller hvor begge parter fejlagtigt antager, at den anden part udfører kontrollen. Det er her, undtagelser af typen NullPointerExceptions stammer fra. Uden en annotation vil compileren ikke give særlige råd, men med annotationen @Nullable vil alle ikke-kontrollerede dereferencer blive markeret.
Med disse basiselementer kan vi direkte tilknytte alle parameterannotationer til forhåndsbetingelser og fortolke returannotationer som efterfølgende betingelser for metoden.
I objektorienteret programmering skal kontraktbaseret design tage en dimension mere i betragtning: oprettelse af undertyper og tilsidesættelse (i det følgende bruges begrebet "tilsidesættelse" i betydningen af annotationen @Override i Java 6: metoder, der tilsidesætter eller implementerer en anden metode fra en supertype). En klient, der kalder en metode som denne:
@NonNull String checkedString(@Nullable String in)
skal kunne antage, at alle implementeringer af denne metode opfylder kontrakten. Så når der stødes på metodeerklæringen i en grænseflade kaldet I1, kan vi udelukke, at en Cn-klasse, som implementerer I1, leverer en inkompatibel implementering. Nærmere bestemt er det ikke tilladt for en Cn-forekomst at forsøge at tilsidesætte
denne metode med en implementering, der erklærer parameteren som @NonNull. Hvis vi ville tillade dette, kunne et klientmodul, som programmeres mod I1, lovligt overføre NULL som argumentet, men implementeringen ville antage en værdi, der ikke er NULL. Ikke-kontrolleret dereference inden for metoden ville blive tilladt, men ville give fejl ved runtime. Parameterspecifikationen @Nullable tvinger således alle tilsidesættelser til at tillade NULL som en forventet, tilladt værdi.
Modsat gælder, at returspecifikationen @NonNull tvinger alle tilsidesættelser til at sikre, at der aldrig returneres NULL.
Compileren skal derfor kontrollere, at der ikke er nogen tilsidesættelser, der tilføjer en @NonNull-parameterannotation (eller en @Nullable-returannotation), som ikke findes i supertypen.
Interessant nok er de modsatte omdefinitioner tilladt: Tilføjelse af en @Nullable-parameterannotation eller en @NonNull-returannotation (de kan betragtes som "forbedringer" af metoden, da den accepterer flere værdier og giver mere specifikke returværdier).
Ovenstående betragtninger indebærer en udfordring, når annoteret kode skrives som en undertype af en "forældet" (dvs. ikke-annoteret) type (som måske kommer fra et tredjepartsbibliotek og derfor ikke kan ændres). Hvis du nærlæste det sidste afsnit, bemærkede du måske, at vi ikke kan tillade, at en "forældet" metode tilsidesættes af en metode med en @NonNull-parameter (eftersom klienter, der bruger supertypen, ikke kan se @NonNull-forpligtelsen).
I den situation er du tvunget til at udelade NULL-annotationer (der er planer om at understøtte efterfølgende tilføjelse af annotationer til biblioteker, men der er endnu ingen bekræftelse af, om og i givet fald hvornår en sådan funktion bliver tilgængelig).
Situationen bliver indviklet, hvis en undertype af en "forældet" type findes i en pakke, som @NonNullByDefault er angivet for. Så ville en type med en ikke-annoteret supertype skulle markere alle parametre i tilsidesættende metoder som @Nullable, og udeladelse af parameterannotationer er ikke tilladt, fordi det ville blive fortolket som en @NonNull-parameter, hvilket er forbudt på den pågældende position. Derfor understøtter Java-compileren i Eclipse annullering af en standardværdi for NULL: Annotering af en metode eller type med @NonNullByDefault(false) betyder, at en standardværdi annulleres for dette element, og ikke-annoterede parametre fortolkes igen som ikke-angivet. Nu er oprettelse af undertyper gyldigt igen, uden at der skal tilføjes uønskede @Nullable-annotationer:
class LegacyClass {
String enhance (String in) { // clients are not forced to pass nonnull.
return in.toUpperCase();
}
}
@NonNullByDefault
class MyClass extends LegacyClass {
// ... methods with @NonNull default ...
@Override
@NonNullByDefault(false)
String enhance(String in) { // would not be valid if @NonNullByDefault were effective here
return super.enhance(in);
}
}
Brug af NULL-annotationer ifølge kontraktbaseret design som beskrevet ovenfor hjælper med at forbedre kvaliteten af Java-kode på flere måder: På grænsefladen mellem metoder fastlægges, hvilke parametre/returneringer der tolererer en NULL-værdi, og hvilke der ikke gør. Derved afspejles designbeslutninger, som er yderst relevante for udviklerne, på en måde, som også kan kontrolleres af compileren.
På basis af denne grænsefladespecifikation kan flowanalysen mellem procedurer desuden registrere de tilgængelige oplysninger og levere langt mere præcise fejl og advarsler. Uden annotationer har værdier til og fra en metode en ukendt NULL-angivelse, og NULL-analysen kan ikke give oplysninger om brugen af dem. Med NULL-annotationer på API-niveau er de fleste værdiers NULL-specifikation kendt, og langt færre undtagelser af typen NullPointerExceptions overses af compileren. Du skal dog være opmærksom på, at der stadig er nogle huller, hvor ikke-angivne værdier indgår i analysen, og det derfor ikke kan siges med sikkerhed, om der kan opstå undtagelser af typen NullPointerExceptions ved runtime.
Understøttelsen af NULL-annotationer er designet på en sådan måde, at den kan udvides i fremtiden, så compileren vil være i stand til at garantere, at et certificeret program aldrig vil afsende en undtagelse af typen NullPointerExceptions ved runtime (med de sædvanlige forbehold vedrørende dele såsom refleksion, der ikke kan kontrolleres). En sådan fremtidig udvidelse er endnu ikke bekræftet, men den grundlæggende ide er blot en anden fortolkning af det, vi allerede har.
Ved at fortolke NULL-annotationer som en del af typesystemet fordobler vi antallet af typer i et givet program: For en given klasse Cn betragtes klassen selv ikke længere som en gyldig type. Kun @NonNull Cn" og
"@Nullable Cn" er brugbare typer. Det betyder ideelt set, at vi for hver værdi i et program vil vide, om den kan være NULL (og skal kontrolleres inden dereferering) eller ej. Hvis vi ser bort fra den tredje mulighed (ikke-annoterede typer), kan compileren markere alle problematiske anvendelser uden undtagelse.
Den nuværende implementering har to store begrænsninger med hensyn til dette mål:
Til trods for de aktuelle begrænsninger har visionen om fuldt specificerede og fuldstændigt kontrollerede programmer allerede i dag haft indflydelse på den aktuelle analyse og de fejl/advarsler, der rapporteres af compileren. Vi kommer ind på detaljerne ved at beskrive de regler, compileren kontrollerer, og de meddelelser, den afsender, når en regel er overtrådt.
De regler, som compileren tjekker, findes under følgende overskrifter på den tilsvarende indstillingsside:
Vi behandler enhver situation, hvor en NULL-annotation fremsætter en påstand, der overtrædes af den faktiske implementering, som en overtrædelse af specifikationen. I en typisk situation angives en værdi (lokal, argument, metodereturnering) som @NonNull, og implementeringen leverer en værdi, der kan være NULL. Her betragtes et udtryk som Nullable, hvis det enten er statisk kendt, at det evalueres til værdien NULL, eller hvis det er erklæret med annotationen @Nullable.
Denne gruppe indeholder også reglerne for tilsidesættelse af metoder som beskrevet ovenfor. Her fremsætter en supermetode en påstand (f.eks. at NULL er et gyldigt argument), og en tilsidesættelse forsøge at omgå påstanden (ved at antage, at NULL ikke er et gyldigt argument). Som nævnt er det en overtrædelse af specifikationen at specialisere et argument fra ikke-annoteret til @NonNull, fordi det opretter en kontrakt, der skal forpligte klienten (til ikke at overføre NULL), men en klient, som bruger supertypen, ser ikke engang denne kontrakt og ved derfor ikke, hvad der forventes.
Her findes en komplet liste med situationer, der betragtes som overtrædelser af specifikationen. Det er vigtigt at forstå, at fejl i denne gruppe aldrig bør ignoreres, da hele NULL-analysen ellers udføres under falske forudsætninger. Helt præcist gælder, at når compileren ser en værdi med annotationen @NonNull, tager den for givet, at NULL ikke vil forekomme ved runtime. Det er reglerne vedrørende overtrædelser af specifikationen, der sikrer, at denne antagelse holder. Det anbefales derfor kraftigt at lade denne type problemer være konfigureret som fejl.
Denne gruppe regler holder også øje med, at NULL-specifikationer overholdes. Her gælder det imidlertid værdier, der ikke er erklæret som @Nullable (eller selve NULL-værdien), men værdier for hvilke flowanalysen internt i proceduren
udleder, at der kan forekomme NULL i en eller anden udførelsessti.
Situationen er baseret på den kendsgerning, at compileren for ikke-annoterede lokale variabler vil bruge sin flowanalyse til at udlede, om NULL er muligt. Idet det antages, at analysen er nøjagtig, vil et fundet problem af denne type blive opfattet på niveau med direkte overtrædelser af en NULL-specifikation. Det anbefales derfor også kraftigt at lade dette problem være konfigureret som fejl og ikke ignorere disse meddelelser.
Oprettelse af en særskilt gruppe til disse problemer har to formål: At dokumentere, at et givet problem er opdaget ved hjælp af flowanalysen, og at tage højde for den kendsgerning, at flowanalysen kunne være fejlbehæftet (på grund af en programfejl i implementeringen). Med hensyn til en bekræftet programfejl i implementeringen kunne det i særlige situationer være i orden at undertrykke en fejlmeddelelse af denne type.
Som følge af begrænsningen ved en hvilken som helst statisk analyse kan flowanalysen måske ikke se, at en vis kombination af udførelsesstier og værdier ikke er mulig. Her bruges variabelkorrelering som et eksempel på dette:
String flatten(String[] inputs1, String[] inputs2) {
StringBuffer sb1 = null, sb2 = null;
int len = Math.min(inputs1.length, inputs2.length);
for (int i=0; i<len; i++) {
if (sb1 == null) {
sb1 = new StringBuffer();
sb2 = new StringBuffer();
}
sb1.append(inputs1[i]);
sb2.append(inputs2[i]); // warning here
}
if (sb1 != null) return sb1.append(sb2).toString();
return "";
}
Compileren vil rapportere en mulig adgang til en NULL-pointer, når sb2.append(..) kaldes.
En person, der læser koden, kan se, at der ikke er noget egentligt problem, fordi sb1 og sb2 korreleres på en sådan måde, at begge variabler er NULL, eller at begge variabler ikke er NULL. På den pågældende linje ved vi, at sb1 ikke er NULL, og at sb2 derfor heller ikke er NULL. Vi vil ikke gå i detaljer med, hvorfor en sådan korrelationsanalyse ligger uden for funktionsområdet for Java-compileren i Eclipse, men man skal huske, at compilerens analyse ikke har samme funktioner som en komplet bevisførelsesfunktion og derfor pessimistisk rapporterer nogle problemer, som en mere udbygget analyse muligvis kunne udpege som falsk alarm.
Hvis du vil have fordel af flowanalysen, tilrådes det at give compileren lidt hjælp, så den kan "se" dine konklusioner. Hjælpen kan være så simpel som at opdele if (sb1 == null) i to adskilte if-sætninger, en for hver lokal variabel. Det er en meget lille indsats til gengæld for den fordel, du opnår, ved at compileren kan se præcis, hvad der foregår, og kontrollere koden i overensstemmelse med det. Der er mere om dette emne nedenfor.
Denne gruppe problemer er baseret på følgende: I et program, der bruger generiske typer i Java 5, kan kald til biblioteker fra før Java 5 fremvise ubehandlede (raw) typer, dvs. anvendelse af en generisk type, der ikke er angivet konkrete typeargumenter for. For at få sådanne værdier til at passe ind i et program ved hjælp af generiske typer kan compileren tilføje en implicit konvertering ved at antage, at der blev angivet typeargumenter på den måde, som forventes af klientdelen af koden. Compileren vil afsende en advarsel om brugen af en sådan konvertering og fortsætte sin typekontrol under antagelse af, at biblioteket gør det rigtige. På præcis samme måde kan en ikke-annoteret returtype for en biblioteksmetode betragtes som en "ubehandlet" eller "forældet" type. Igen kan en implicit konvertering optimistisk antage, at den forventede specifikation er til stede. Der afsendes igen en advarsel, og analysen fortsætter under antagelse af, at biblioteket gør det rigtige.
Ud fra en teoretisk betragtning indikerer behovet for sådanne implicitte konverteringer også en overtrædelse af specifikationen. I dette tilfælde kan det imidlertid være tredjepartskode, der overtræder den specifikation, som vores kode forventer. Eller måske opfylder noget tredjepartskode faktisk kontrakten, men har ikke erklæret det (fordi den ikke bruger NULL-annotationer). I disse situationer vil vi måske ikke kunne løse problemet helt af organisatoriske årsager.
@SuppressWarnings("null")
@NonNull Foo foo = Library.getFoo(); // implicit conversion
foo.bar();
Ovenstående kodestykke antager, at Library.getFoo() returnerer Foo, uden at der er angivet en NULL-annotation. Vi kan integrere returværdien i vores annoterede
program ved at tildele den til en lokal @NonNull-variabel, som udløser en advarsel om en ikke-kontrolleret konvertering. Ved at tilføje en tilsvarende SuppressWarnings("null")-angivelse til erklæringen anerkender vi den indbyggede risiko og påtager os ansvaret for at have verificeret, at biblioteket faktisk opfører sig som ønsket.
Hvis flowanalysen ikke kan se, at en værdi faktisk er ikke-NULL, er den simpleste fremgangsmåde altid at tilføje en ny lokal variabel annoteret med @NonNull. Hvis du er sikker på, at den værdi, der tildeles til denne lokale variabel, aldrig er NULL ved runtime, kan du derefter bruge en hjælpemetode som denne:
static @NonNull <T> T assertNonNull(@Nullable T value, @Nullable String msg) {
if (value == null) throw new AssertionError(msg);
return value;
}
@NonNull MyType foo() {
if (isInitialized()) {
MyType couldBeNull = getObjectOrNull();
@NonNull MyType theValue = assertNonNull(couldBeNull,
"value should not be null because application " +
"is fully initialized at this point.");
return theValue;
}
return new MyTypeImpl();
}
Bemærk, at du ved at bruge metoden assertNonNull() ovenfor påtager dig ansvaret for, at denne antagelse altid holder ved runtime. Hvis det ikke er det, du vil, kan annoterede lokale variabler stadig hjælpe med at indsnævre, hvor og hvorfor analysen identificerer muligheden for en NULL-værdi et bestemt sted.
På udgivelsestidspunktet for JDT version 3.8.0 foregår indsamling af råd vedrørende indførelse af NULL-annotationer stadig. Oplysningerne vedligeholdes derfor i øjeblikket i Eclipse wiki.