මග හැරීම! = ශූන්‍ය ප්‍රකාශ

object != nullවළක්වා ගැනීමට මම බොහෝ දේ භාවිතා කරමි NullPointerException.

මේ සඳහා හොඳ විකල්පයක් තිබේද?

උදාහරණයක් ලෙස මම බොහෝ විට භාවිතා කරන්නේ:

if (someobject != null) {
    someobject.doCalc();
}

ඉහත ස්නිපටයේ NullPointerExceptionඇති someobjectවස්තුව සඳහා මෙය පරික්ෂා කරයි .

පිළිගත් පිළිතුර යල්පැන ඇති බව සලකන්න, වඩාත් මෑත ප්‍රවේශයක් සඳහා https://stackoverflow.com/a/2386013/12943 බලන්න .

මෙය මට කනිෂ් to සිට අතරමැදි සංවර්ධකයින් යම් අවස්ථාවක දී මුහුණ දෙන සාධාරණ පොදු ගැටළුවක් සේ පෙනේ: ඔවුන් එක්කෝ ඔවුන් සහභාගී වන කොන්ත්‍රාත්තු නොදැන හෝ විශ්වාස නොකරති. මීට අමතරව, තමන්ගේම කේතයක් ලිවීමේදී, ඔවුන් යමක් සඳහන් කිරීම සඳහා නැවත ශුන්‍යයන් මත යැපීමට නැඹුරු වන අතර එමඟින් ඇමතුම්කරුට ශුන්‍යයන් පරීක්ෂා කිරීමට අවශ්‍ය වේ.

මෙය වෙනත් ආකාරයකින් කිවහොත්, ශුන්‍ය පරීක්‍ෂණයක් සිදු වන අවස්ථා දෙකක් තිබේ:

1. කොන්ත්රාත්තුව අනුව වලංගු ප්රතිචාරයක් ශුන්‍ය වන විට; හා

2. එය වලංගු ප්‍රතිචාරයක් නොවන තැන.

(2) පහසුය. එක්කෝ assertප්‍රකාශ භාවිතා කරන්න (ප්‍රකාශ) හෝ අසාර්ථක වීමට ඉඩ දෙන්න (නිදසුනක් ලෙස, NullPointerException ). ප්‍රකාශයන් 1.4 හි එකතු කරන ලද ජාවා විශේෂාංගයකි. වාක්‍ය ඛණ්ඩය:

assert <condition>

හෝ

assert <condition> : <object>

කොහේද <condition>බූලියන් ප්‍රකාශනයක් වන අතර <object>එය toString()ක්‍රමයේ ප්‍රතිදානය දෝෂයට ඇතුළත් කරනු ඇත.

ක assertප්රකාශය ඉතා අවුලට Error( AssertionError) තත්ත්වය සත්යයක් නො වේ නම්. පෙරනිමියෙන්, ජාවා ප්‍රකාශයන් නොසලකා හරියි. විකල්පය -eaජේවීඑම් වෙත යොමු කිරීමෙන් ඔබට ප්‍රකාශයන් සක්‍රීය කළ හැකිය . ඔබට තනි පන්ති සහ පැකේජ සඳහා ප්‍රකාශ සක්‍රිය හා අක්‍රීය කළ හැකිය. මෙයින් අදහස් කරන්නේ, සංවර්ධනය කිරීමේදී සහ පරීක්‍ෂා කිරීමේදී ඔබට ප්‍රකාශයන් සමඟ කේතය වලංගු කළ හැකි අතර නිෂ්පාදන පරිසරයක් තුළ ඒවා අක්‍රීය කළ හැකි වුවද, මගේ පරීක්ෂණයෙන් ප්‍රකාශ කර ඇති කාර්ය සාධන බලපෑමක් නොමැති බව පෙන්නුම් කරයි.

මෙම අවස්ථාවෙහිදී ප්‍රකාශයන් භාවිතා නොකිරීම හරි, මන්ද කේතය අසාර්ථක වනු ඇත, ඔබ ප්‍රකාශ භාවිතා කරන්නේ නම් එය සිදුවනු ඇත. එකම වෙනස නම්, ප්‍රකාශයන් සමඟ එය ඉක්මණින්, වඩාත් අර්ථවත් ආකාරයකින් හා සමහර විට අමතර තොරතුරු සමඟ සිදුවිය හැකි අතර, එය ඔබ අපේක්ෂා නොකළේ නම් එය සිදු වූයේ මන්දැයි සොයා ගැනීමට ඔබට උපකාරී වනු ඇත.

(1) ටිකක් අමාරුයි. ඔබ අමතන කේතය පාලනය කිරීමට ඔබට හැකියාවක් නොමැති නම් ඔබ හිර වී ඇත. ශුන්‍යය වලංගු ප්‍රතිචාරයක් නම්, ඔබ එය පරීක්ෂා කළ යුතුය.

එය ඔබ පාලනය කරන කේතය නම්, කෙසේ වෙතත් (සහ බොහෝ විට මෙය එසේ වේ), එය වෙනස් කතාවකි. ප්‍රතිචාරයක් ලෙස ශුන්‍ය භාවිතා කිරීමෙන් වළකින්න. එකතු කිරීම් ආපසු ලබා දෙන ක්‍රම සමඟ, එය පහසු ය: සෑම විටම ශුන්‍ය වෙනුවට හිස් එකතු කිරීම් (හෝ අරා) ආපසු එවන්න.

එකතු නොකිරීම සමඟ එය වඩාත් අපහසු විය හැකිය. මෙය උදාහරණයක් ලෙස සලකන්න: ඔබට මෙම අතුරුමුහුණත් තිබේ නම්:

public interface Action {
  void doSomething();
}

public interface Parser {
  Action findAction(String userInput);
}

එහිදී Parser අමු පරිශීලක ආදානය ගෙන යමක් කිරීමට සොයා ගනී, සමහර විට ඔබ යම් දෙයක් සඳහා විධාන රේඛා අතුරු මුහුණතක් ක්‍රියාත්මක කරන්නේ නම්. සුදුසු ක්‍රියාමාර්ගයක් නොමැති නම් එය නැවත ලබා දෙන කොන්ත්‍රාත්තුව දැන් ඔබට කළ හැකිය. එය ඔබ කතා කරන ශූන්‍ය පරීක්ෂාවට මග පාදයි.

විකල්ප විසඳුමක් නම් කිසි විටෙකත් ශුන්‍ය නොවන අතර ඒ වෙනුවට ශුන්‍ය වස්තු රටාව භාවිතා කරන්න :

public class MyParser implements Parser {
  private static Action DO_NOTHING = new Action() {
    public void doSomething() { /* do nothing */ }
  };

  public Action findAction(String userInput) {
    // ...
    if ( /* we can't find any actions */ ) {
      return DO_NOTHING;
    }
  }
}

සසඳන්න:

Parser parser = ParserFactory.getParser();
if (parser == null) {
  // now what?
  // this would be an example of where null isn't (or shouldn't be) a valid response
}
Action action = parser.findAction(someInput);
if (action == null) {
  // do nothing
} else {
  action.doSomething();
}

වෙත

ParserFactory.getParser().findAction(someInput).doSomething();

එය වඩා සංක්ෂිප්ත කේතයකට මඟ පෙන්වන නිසා එය වඩා හොඳ නිර්මාණයකි.

අර්ථවත් දෝෂ පණිවිඩයක් සහිත ව්‍යතිරේකයක් විසි කිරීම findAction () ක්‍රමයට සම්පූර්ණයෙන්ම සුදුසු යැයි එයින් කියැවේ - විශේෂයෙන් ඔබ පරිශීලක ආදානය මත විශ්වාසය තබන මේ අවස්ථාවේ දී. පැහැදිලි කිරීමක් නොමැතිව සරල NullPointerException සමඟ පුපුරා යාම සඳහා ඇමතුම් ක්‍රමයට වඩා ව්‍යතිරේකයක් විසි කිරීම FindAction ක්‍රමයට වඩා හොඳය.

try {
    ParserFactory.getParser().findAction(someInput).doSomething();
} catch(ActionNotFoundException anfe) {
    userConsole.err(anfe.getMessage());
}

කිසිවක් නොකරන්න වෙනුවට උත්සාහ කිරීමේ / අල්ලා ගැනීමේ යාන්ත්‍රණය ඉතා අවලස්සන යැයි ඔබ සිතන්නේ නම්, ඔබේ පෙරනිමි ක්‍රියාව පරිශීලකයාට ප්‍රතිපෝෂණය ලබා දිය යුතුය.

public Action findAction(final String userInput) {
    /* Code to return requested Action if found */
    return new Action() {
        public void doSomething() {
            userConsole.err("Action not found: " + userInput);
        }
    }
}

ඔබ ජෙට් බ්‍රේන්ස් ඉන්ටෙලිජ් අයිඩීඒ , සූර්යග්‍රහණය වැනි ජාවා IDE එකක් භාවිතා කරන්නේ නම් (හෝ භාවිතා කිරීමට සැලසුම් කරන්නේ නම්) හෝ Netbeans හෝ findbugs වැනි මෙවලමක් එවිට මෙම ප්රශ්නය විසඳීම සඳහා විවරණයන් ඉදිරිපත් භාවිතා කළ හැකිය.

කොටින්ම, ඔබට තිබේ @Nullable සහ @NotNull.

ඔබට මේ ආකාරයට ක්‍රම සහ පරාමිතීන් භාවිතා කළ හැකිය:

@NotNull public static String helloWorld() {
    return "Hello World";
}

හෝ

@Nullable public static String helloWorld() {
    return "Hello World";
}

දෙවන උදාහරණය සම්පාදනය නොකරනු ඇත (IntelliJ IDEA හි).

ඔබ පළමු helloWorld()ශ්‍රිතය වෙනත් කේත කැබැල්ලක භාවිතා කරන විට :

public static void main(String[] args)
{
    String result = helloWorld();
    if(result != null) {
        System.out.println(result);
    }
}

දැන් IntelliJ IDEA සම්පාදකයා ඔබට කියනු ඇත්තේ චෙක්පත නිෂ් less ල බවය helloWorld() ශ්‍රිතය නැවත නොපැමිණෙන nullබැවිනි.

පරාමිතිය භාවිතා කිරීම

void someMethod(@NotNull someParameter) { }

ඔබ එවැනි දෙයක් ලියන්නේ නම්:

someMethod(null);

මෙය සම්පාදනය නොකරයි.

භාවිතා කරන අවසාන උදාහරණය @Nullable

@Nullable iWantToDestroyEverything() { return null; }

මෙය කිරීම

iWantToDestroyEverything().something();

මෙය සිදු නොවන බවට ඔබට සහතික විය හැකිය. :)

සම්පාදකයාට සාමාන්‍යයෙන් කරනවාට වඩා යමක් පරීක්ෂා කිරීමට ඉඩ දීම සහ ඔබේ කොන්ත්‍රාත්තු ශක්තිමත් වීමට බලාත්මක කිරීම හොඳ ක්‍රමයකි. අවාසනාවට, එය සියලු සම්පාදකයින්ගේ සහාය නොලැබේ.

IntelliJ IDEA 10.5 සහ ඊට පසුව ඔවුන් වෙනත් ඕනෑම @Nullable @NotNullක්‍රියාත්මක කිරීමක් සඳහා සහය එක් කළහ .

බ්ලොග් සටහන බලන්න වඩාත් නම්‍යශීලී සහ වින්‍යාසගත කළ හැකි @ අහෝසි කළ හැකි / @ නොට්ල් විවරණ .

ශුන්‍ය අගයන්ට ඉඩ නොදෙන්නේ නම්

ඔබේ ක්‍රමය බාහිරව හැඳින්වුවහොත්, මේ වගේ දෙයක් සමඟ ආරම්භ කරන්න:

public void method(Object object) {
  if (object == null) {
    throw new IllegalArgumentException("...");
  }

එවිට, එම ක්‍රමයේ ඉතිරි කොටසෙහි, objectඑය ශුන්‍ය නොවන බව ඔබ දැන ගනු ඇත.

එය අභ්‍යන්තර ක්‍රමයක් නම් (API එකක කොටසක් නොවේ), එය අහෝසි කළ නොහැකි බව ලේඛනගත කරන්න, එය එයයි.

උදාහරණයක්:

public String getFirst3Chars(String text) {
  return text.subString(0, 3);
}

කෙසේ වෙතත්, ඔබේ ක්‍රමය මඟින් අගය ඉක්මවා ගියහොත් සහ ඊළඟ ක්‍රමය එය සම්මත කළහොත් එය ගැටළු සහගත විය හැකිය. එවැනි අවස්ථාවකදී ඉහත තර්කය පරීක්ෂා කිරීමට ඔබට අවශ්‍ය විය හැකිය.

ශුන්‍ය වීමට අවසර තිබේ නම්

මෙය සැබවින්ම රඳා පවතී. මම බොහෝ විට මෙවැනි දෙයක් කරන බව සොයා ගන්නේ නම්:

if (object == null) {
  // something
} else {
  // something else
}

ඒ නිසා මම අතු බෙදී සම්පූර්ණයෙන්ම වෙනස් දේවල් දෙකක් කරනවා. අවලස්සන කේත ස්නිපටයක් නොමැත, මන්ද මට දත්ත අනුව වෙනස් දේවල් දෙකක් කළ යුතු බැවිනි. උදාහරණයක් ලෙස, මම ආදානය මත වැඩ කළ යුතුද, නැතහොත් හොඳ පෙරනිමි අගයක් ගණනය කළ යුතුද?

මෝඩකම භාවිතා කිරීම ඇත්තෙන්ම දුර්ලභ ය if (object != null && ....

ඔබ සාමාන්‍යයෙන් මෝඩකම භාවිතා කරන ස්ථානය පිළිබඳ උදාහරණ පෙන්වන්නේ නම් ඔබට උදාහරණ ලබා දීම පහසු වනු ඇත.

ඇවැත්නි, අපට නිර්දේශ කිරීමට විවිධ ක්‍රම 57 ක් ඇති විට තවත් පිළිතුරක් එක් කිරීමට මම බොහෝ දුරට අකමැතියි NullObject pattern, නමුත් මෙම ප්‍රශ්නය ගැන උනන්දුවක් දක්වන සමහර අය ජාවා 7 සඳහා “ශුන්‍ය-ආරක්ෂිත” එකතු කිරීම සඳහා මේසයේ යෝජනාවක් ඇති බව දැන ගැනීමට කැමති යැයි මම සිතමි. හැසිරවීම " if-සමාන-ශුන්‍ය නොවන තර්කනය සඳහා විධිමත් වාක්‍ය ඛණ්ඩයකි.

ඇලෙක්ස් මිලර් දුන් උදාහරණය මෙයයි:

public String getPostcode(Person person) {  
  return person?.getAddress()?.getPostcode();  
}  

මෙම ?.මාර්ගයෙන් පමණක් ද-යොමු වම් හඳුනාගැනීමේ එය ශූන්ය නොවේ නම්, වෙනත් ආකාරයකින් ලෙස අදහස් ප්රකාශ කිරීමේ ඉතිරි ඇගයීමට null. ජාවා පොස්සේ සාමාජික ඩික් වෝල් සහ ඩෙවොක්ස් හි ඡන්දදායකයින් වැනි සමහර අය මෙම යෝජනාවට සැබවින්ම ඇලුම් කරති. එහෙත් විරුද්ධත්වයක් ද ඇත null.

යාවත්කාලීන කිරීම: එක් නිල යෝජනාව ජාවා 7 දී ශූන්ය-ආරක්ෂිත ක්රියාකරු යටතේ ඉදිරිපත් කර ඇති බවත් සඳහා ව්යාපෘති කාසිය. වාක්‍ය ඛණ්ඩය ඉහත උදාහරණයට වඩා ටිකක් වෙනස් ය, නමුත් එය එකම අදහසකි.

යාවත්කාලීන කිරීම: ශුන්‍ය-ආරක්ෂිත ක්‍රියාකරු යෝජනාව එය ව්‍යාපෘති කාසියට ඇතුළත් කර නැත. එබැවින්, ඔබට මෙම වාක්‍ය ඛණ්ඩය ජාවා 7 හි නොපෙනේ.

නිර්වචනය නොකළ අගයන්ට අවසර නොමැති නම්:

විභව ශුන්‍ය අවලංගු කිරීම් ගැන ඔබට අනතුරු ඇඟවීම සඳහා ඔබේ IDE වින්‍යාසගත කළ හැකිය. උදා: සූර්යග්‍රහණයේ, මනාප> ජාවා> සම්පාදක> දෝෂ / අනතුරු ඇඟවීම් / ශුන්‍ය විශ්ලේෂණය බලන්න .

නිර්වචනය නොකළ අගයන්ට අවසර තිබේ නම්:

නිර්වචනය නොකළ අගයන් අර්ථවත් වන නව API එකක් අර්ථ දැක්වීමට ඔබට අවශ්‍ය නම් , විකල්ප රටාව භාවිතා කරන්න (ක්‍රියාකාරී භාෂාවලින් හුරුපුරුදු විය හැකිය). එයට පහත වාසි ඇත:

• ආදානයක් හෝ ප්‍රතිදානයක් තිබේද නැද්ද යන්න ඒපීඅයි හි පැහැදිලිව සඳහන් කර ඇත.
• "නිර්වචනය නොකළ" නඩුව හැසිරවීමට සම්පාදකයා ඔබට බල කරයි.
• විකල්පය මොනාඩ් වේ , එබැවින් වාචික ශුන්‍ය පරීක්‍ෂණයක් අවශ්‍ය නොවේ, අගය ආරක්ෂිතව භාවිතා කිරීම සඳහා සිතියම / foreach / getOrElse හෝ ඒ හා සමාන සංයෝජකයක් භාවිතා කරන්න (උදාහරණය) .

ජාවා 8 හි සාදන ලද Optionalපන්තියක් ඇත (නිර්දේශිත); පෙර වෙළුම් සඳහා, උදාහරණයක් පුස්තකාල විකල්ප, ඇත පේර ගේ Optionalහෝ FunctionalJava ගේ Option. නමුත් බොහෝ ක්‍රියාකාරී ශෛලියේ රටා මෙන්, ජාවා හි විකල්පය භාවිතා කිරීම (8 පවා) බොහෝ බොයිලර් තහඩුවලට හේතු වේ, එමඟින් ඔබට අඩු වාචික ජේවීඑම් භාෂාවක් භාවිතා කිරීම අඩු කළ හැකිය, උදා: ස්කලා හෝ එක්ස්ටෙන්ඩ්.

ඔබට ශුන්‍ය ආපසු ලබා දිය හැකි API සමඟ ගනුදෙනු කිරීමට සිදුවුවහොත් , ඔබට ජාවා හි බොහෝ දේ කළ නොහැක. එක්ස්ටෙන්ඩ් සහ ග්‍රෝවි සතුව එල්විස් ක්‍රියාකරු ?: සහ ශුන්‍ය-ආරක්ෂිත විරූපණ ක්‍රියාකරු ඇත ?. , නමුත් මෙය ශුන්‍ය යොමු කිරීමකදී ශුන්‍ය වන බව සලකන්න, එබැවින් එය ශුන්‍ය ලෙස නිසි ලෙස හැසිරවීම “කල් දමයි”.

මෙම තත්වය සඳහා පමණි -

සමානාත්මතා ක්‍රමයක් ක්‍රියාත්මක කිරීමට පෙර විචල්‍යයක් ශුන්‍ය දැයි පරීක්ෂා නොකිරීම (නූලක් පහත උදාහරණය සංසන්දනය කරන්න):

if ( foo.equals("bar") ) {
 // ...
}

නොපවතින NullPointerExceptionනම් fooප්‍රති result ල ලැබෙනු ඇත .

ඔබ මේ ආකාරයට සංසන්දනය කළහොත් ඔබට එය වළක්වා ගත හැකිය String:

if ( "bar".equals(foo) ) {
 // ...
}

ජාවා 8 සමඟ නව java.util.Optionalපංතිය පැමිණෙන්නේ සමහර ගැටලු විසඳිය හැකි බැවිනි. කෙනෙකුට අවම වශයෙන් එය කේතයේ කියවීමේ හැකියාව වැඩි දියුණු කරන බව පැවසිය හැකි අතර, පොදු ඒපීඅයි වලදී ඒපීඅයි හි කොන්ත්‍රාත්තුව සේවාදායක සංවර්ධකයාට වඩාත් පැහැදිලි කරයි.

ඔවුන් එසේ ක්‍රියා කරයි:

දී ඇති වර්ගයක් සඳහා විකල්ප වස්තුවක් ( Fruit) ක්‍රමයක ආපසු වර්ගය ලෙස නිර්මාණය වේ. එය හිස් හෝ Fruitවස්තුවක් අඩංගු විය හැකිය:

public static Optional<Fruit> find(String name, List<Fruit> fruits) {
   for (Fruit fruit : fruits) {
      if (fruit.getName().equals(name)) {
         return Optional.of(fruit);
      }
   }
   return Optional.empty();
}

දැන් ලබා දී ඇති පළතුරු උදාහරණයක් සඳහා Fruit( fruits) ලැයිස්තුවක් සොයන මෙම කේතය දෙස බලන්න :

Optional<Fruit> found = find("lemon", fruits);
if (found.isPresent()) {
   Fruit fruit = found.get();
   String name = fruit.getName();
}

map()විකල්ප වස්තුවක් මත ගණනය කිරීමක් සිදු කිරීමට ඔබට ක්‍රියාකරු භාවිතා කළ හැකිය . orElse()නැතිවූ අගයන් සඳහා පසුබෑමක් සැපයීමට ඔබට ඉඩ දෙයි.

String nameOrNull = find("lemon", fruits)
    .map(f -> f.getName())
    .orElse("empty-name");

ඇත්ත වශයෙන්ම, ශුන්‍ය / හිස් අගය සඳහා චෙක්පත තවමත් අවශ්‍ය වේ, නමුත් අවම වශයෙන් සංවර්ධකයා දැනුවත්ව වටිනාකම හිස් විය හැකි අතර පරීක්ෂා කිරීමට අමතක වීමේ අවදානම සීමිතය.

මුල සිට සාදන ලද API Optionalඑකක ප්‍රතිලාභ අගයක් හිස් වූ විට භාවිතා කරමින් සරල වස්තුවක් ආපසු ලබා දිය හැකි විට null(සම්මුතිය), සේවාදායක කේතය සරල වස්තු ප්‍රතිලාභ අගයන් පිළිබඳ ශුන්‍ය චෙක්පත් අතහැර දැමිය හැකිය ...

ඇත්ත වශයෙන්ම Optionalක්‍රම තර්කයක් ලෙසද භාවිතා කළ හැකිය, සමහර විට අධි බර පැටවීමේ ක්‍රම 5 හෝ 10 ට වඩා විකල්ප තර්ක දැක්වීමට වඩා හොඳ ක්‍රමයක් විය හැකිය.

OptionalorElseපෙරනිමි අගයක් භාවිතා කිරීමට ඉඩ දෙන, සහ ලැම්බඩා ප්‍රකාශනifPresent සමඟ ක්‍රියා කරන වෙනත් පහසු ක්‍රම ඉදිරිපත් කරයි .

NullPointerException(සහ පොදුවේ ශුන්‍ය දර්ශකය) ගැටළු සහගත මෙන්ම (අර්ධ වශයෙන්) ගෙන එන ලද මෙම ලිපිය (මෙම පිළිතුර ලිවීම සඳහා මගේ ප්‍රධාන මූලාශ්‍රය) කියවීමට මම ඔබට ආරාධනා කරමි Optional: ජාවා විකල්ප වස්තු .

ඔබ පරීක්ෂා කරන්නේ කුමන ආකාරයේ වස්තූන් මත පදනම්ව, ඔබට අපාචේ කොමන්ස් හි සමහර පන්ති භාවිතා කළ හැකිය: අපාචේ කොමන්ස් ලැන්ග් සහ අපාචේ කොමන්ස් එකතුව

උදාහරණයක්:

String foo;
...
if( StringUtils.isBlank( foo ) ) {
   ///do something
}

හෝ (ඔබ පරීක්ෂා කළ යුතු දේ අනුව):

String foo;
...
if( StringUtils.isEmpty( foo ) ) {
   ///do something
}

StringUtils පන්තිය බොහෝ දෙනාගෙන් එකක් පමණි; ශුන්‍ය ආරක්ෂිත හැසිරවීමක් කරන කොමන්ස් හි හොඳ පන්ති කිහිපයක් තිබේ.

ඔබ අපාචේ පුස්තකාලය (කොමන්ස්-ලැන්ග් -2.4.ජාර්) ඇතුළත් කරන විට ජාවා හි ශුන්‍ය වලංගුකරණය භාවිතා කළ හැකි ආකාරය පිළිබඳ උදාහරණයක් මෙහි දැක්වේ.

public DOCUMENT read(String xml, ValidationEventHandler validationEventHandler) {
    Validate.notNull(validationEventHandler,"ValidationHandler not Injected");
    return read(new StringReader(xml), true, validationEventHandler);
}

ඔබ වසන්තය භාවිතා කරන්නේ නම්, වසන්තය එහි පැකේජයේ එකම ක්‍රියාකාරීත්වයක් ඇත, පුස්තකාලය බලන්න (වසන්තය -2.4.6.ජාර්)

වසන්තයේ සිට මෙම ස්ථිතික පංතිය භාවිතා කරන්නේ කෙසේද යන්න පිළිබඳ උදාහරණය (org.springframework.util.Assert)

Assert.notNull(validationEventHandler,"ValidationHandler not Injected");

• වස්තුවක් ශුන්‍ය නොවිය යුතු යැයි ඔබ සලකන්නේ නම් (හෝ එය දෝෂයකි) ප්‍රකාශයක් භාවිතා කරන්න.
• ඔබේ ක්‍රමය ශුන්‍ය පරාමිතීන් පිළිගන්නේ නැත්නම් එය ජාවාඩොක් තුළ පවසන්න.

ඔබ වස්තුව සඳහා පරික්ෂා කළ යුතුය! = ශුන්‍ය ඔබට වස්තුව ශුන්‍ය විය හැකි නඩුව හැසිරවීමට අවශ්‍ය නම් පමණි ...

ශුන්‍ය / නොනවතින පරාමිතීන් සඳහා ජාවා 7 හි නව විවරණ එකතු කිරීමට යෝජනාවක් ඇත: http://tech.puredanger.com/java7/#jsr308

මම "වේගයෙන් අසමත්" කේතයේ රසිකයෙක්මි. ඔබෙන්ම මෙසේ අසන්න - පරාමිතිය අහෝසි වූ විට ඔබ ප්‍රයෝජනවත් යමක් කරනවාද? ඔබේ කේතය එම අවස්ථාවේ දී කළ යුතු දේ පිළිබඳව ඔබට පැහැදිලි පිළිතුරක් නොමැති නම් ... එනම් එය කිසි විටෙකත් ශුන්‍ය නොවිය යුතුය, පසුව එය නොසලකා හැර NullPointerException විසි කිරීමට ඉඩ දෙන්න. ඇමතුම් කේතය නීතිවිරෝධී ආරෝපණ එක්සෙප්ෂන් එකක් මෙන් එන්පීඊ පිළිබඳ හැඟීමක් ඇති කරයි, නමුත් ඔබේ කේතය වෙනත් අනපේක්ෂිත අවිනිශ්චිතතාවයක් ක්‍රියාත්මක කිරීමට උත්සාහ කරනවාට වඩා එන්පීඊ එකක් විසි කළ හොත් වැරැද්ද කුමක්දැයි තේරුම් ගැනීමට සංවර්ධකයාට පහසු වනු ඇත. තර්කනය - එහි ප්‍රති results ලය වන්නේ යෙදුම කෙසේ හෝ අසමත් වීමයි.

ගූගල් එකතු කිරීමේ රාමුව මඟින් ශුන්‍ය චෙක්පතක් ලබා ගැනීම සඳහා හොඳ සහ අලංකාර ක්‍රමයක් ඉදිරිපත් කරයි.

පුස්තකාල පන්තියක මෙවැනි ක්‍රමයක් තිබේ:

static <T> T checkNotNull(T e) {
   if (e == null) {
      throw new NullPointerException();
   }
   return e;
}

භාවිතය (සමඟ import static):

...
void foo(int a, Person p) {
   if (checkNotNull(p).getAge() > a) {
      ...
   }
   else {
      ...
   }
}
...

හෝ ඔබේ උදාහරණයේ:

checkNotNull(someobject).doCalc();

සමහර විට, සමමිතික මෙහෙයුමක් නිර්වචනය කරන එහි පරාමිතීන් මත ක්‍රියාත්මක වන ක්‍රම ඔබට ඇත:

a.f(b); <-> b.f(a);

B කිසි විටෙකත් ශුන්‍ය විය නොහැකි බව ඔබ දන්නේ නම්, ඔබට එය මාරු කළ හැකිය. සමානාත්මතාවය සඳහා එය වඩාත් ප්‍රයෝජනවත් වේ: foo.equals("bar");වඩා හොඳ කරන්න වෙනුවට "bar".equals(foo);.

එහි භාවිතයන් ඇති ශුන්‍ය වස්තු රටාව වෙනුවට - ශුන්‍ය වස්තුව දෝෂයක් වන අවස්ථා සලකා බැලිය හැකිය.

ව්යතිරේකය විසි කරන විට, තොග හෝඩුවාව පරීක්ෂා කර දෝෂය හරහා වැඩ කරන්න.

ශූන්‍යය 'ගැටලුවක්' නොවේ. එය සම්පූර්ණ ආකෘති නිර්මාණ මෙවලම් කට්ටලයක අනිවාර්ය අංගයකි . මෘදුකාංගය ලෝකයේ සංකීර්ණත්වය ආදර්ශනය කිරීම අරමුණු කර ගෙන එහි බර දරයි. ජාවා සහ ඒ හා සමාන 'දත්ත නැත' හෝ 'නොදන්නා' යන්න ශුන්‍යයෙන් දැක්වේ . එබැවින් මෙම අරමුණු සඳහා ශුන්‍ය භාවිතා කිරීම සුදුසුය. මම 'ශුන්‍ය වස්තුව' රටාවට කැමති නැත; මම හිතන්නේ එය ' භාරකරුවන් ආරක්ෂා කරන්නේ කවුද ' යන ප්‍රශ්නය මතු කරයි.
මගේ පෙම්වතියගේ නම කුමක්දැයි ඔබ මගෙන් ඇසුවොත්, මම ඔබට පෙම්වතියක් නොමැති බව ඔබට කියමි. ජාවා භාෂාවෙන් මම ආපසු එන්නෙමි. විකල්පයක් වනුයේ කිසියම් ගැටලුවක් දැක්වීමට අර්ථවත් ව්‍යතිරේකයක් විසි කිරීමයි (හෝ නොකළ යුතුය

1. 'නොදන්නා ප්‍රශ්නයක්' සඳහා 'නොදන්නා පිළිතුරක්' දෙන්න.(ව්‍යාපාරික දෘෂ්ටි කෝණයෙන් මෙය නිවැරදි තැනක ශුන්‍යව සිටින්න) භාවිතයට පෙර ක්‍රමවේදයක් තුළ එක් වරක් ශුන්‍යය සඳහා තර්ක පරීක්ෂා කිරීම ඇමතුමකට පෙර බහු ඇමතුම්කරුවන් පරීක්ෂා කිරීමෙන් නිදහස් කරයි.

   public Photo getPhotoOfThePerson(Person person) {
       if (person == null)
           return null;
       // Grabbing some resources or intensive calculation
       // using person object anyhow.
   }

   මගේ ඡායාරූප පුස්තකාලයෙන් නොපවතින පෙම්වතියකගේ ඡායාරූපයක් ලබා ගැනීමට පෙර සාමාන්‍ය තාර්කික ප්‍රවාහයකට මග පාදයි.

   getPhotoOfThePerson(me.getGirlfriend())

   එය නව ජාවා ඒපීඅයි සමඟ ගැලපේ (බලාපොරොත්තුවෙන්)

   getPhotoByName(me.getGirlfriend()?.getName())

   සමහර පුද්ගලයකු සඳහා ඩීබී තුළ ගබඩා කර ඇති ඡායාරූප සොයා නොගැනීම සාමාන්‍ය ව්‍යාපාර ප්‍රවාහයක් වන අතර, මම වෙනත් අවස්ථා සඳහා පහත වැනි යුගල භාවිතා කළෙමි

   public static MyEnum parseMyEnum(String value); // throws IllegalArgumentException
   public static MyEnum parseMyEnumOrNull(String value);

   ටයිප් කිරීමට පිළිකුල් නොකරන්න <alt> + <shift> + <j> (සූර්යග්‍රහණයේ javadoc ජනනය කරන්න) සහ ඔබට පොදු API සඳහා අමතර වචන තුනක් ලියන්න. ලියකියවිලි කියවන්නේ නැති අයට හැර අන් සියල්ලන්ටම මෙය ප්‍රමාණවත් වනු ඇත.

   /**
    * @return photo or null
    */

   හෝ

   /**
    * @return photo, never null
    */

2. මෙය තරමක් න්‍යායාත්මක සිද්ධියක් වන අතර බොහෝ අවස්ථාවන්හිදී ඔබ ජාවා ශුන්‍ය ආරක්ෂිත API වලට වැඩි කැමැත්තක් දැක්විය යුතුය (එය තවත් වසර 10 කින් නිකුත් වේ නම්), නමුත් NullPointerExceptionඑය උප කාණ්ඩයකි Exception. මේ අනුව, එය Throwableසාධාරණ යෙදුමකට ( ජාවඩොක් ) අල්ලා ගැනීමට අවශ්‍ය විය හැකි කොන්දේසි පෙන්නුම් කරයි . ව්‍යතිරේකයන්ගේ පළමු වඩාත්ම වාසිය භාවිතා කිරීම සහ දෝෂ හැසිරවීමේ කේතය 'සාමාන්‍ය' කේතයෙන් වෙන් කිරීම ( ජාවාහි නිර්මාතෘවරුන්ට අනුව ) අල්ලා ගැනීම සුදුසුය NullPointerException.

   public Photo getGirlfriendPhoto() {
       try {
           return appContext.getPhotoDataSource().getPhotoByName(me.getGirlfriend().getName());
       } catch (NullPointerException e) {
           return null;
       }
   }

   ප්‍රශ්න මතු විය හැකිය:

   ප්‍රශ්නය - getPhotoDataSource()නැවත ශුන්‍ය වුවහොත් කුමක් කළ යුතුද?
   පිළිතුර - එය ව්‍යාපාර තර්කනය මත ය. මම ඡායාරූප ඇල්බමයක් සොයා ගැනීමට අපොහොසත් වුවහොත් මම ඔබට ඡායාරූප කිසිවක් පෙන්වන්නේ නැත. AppContext ආරම්භ කර නොමැති නම් කුමක් කළ යුතුද? මෙම ක්‍රමයේ ව්‍යාපාර තර්කනය මේ සමඟ එකඟ වේ. එකම තර්කනය වඩාත් දැඩි විය යුතු නම්, ව්‍යතිරේකයක් විසි කිරීම එය ව්‍යාපාර තර්කනයේ කොටසක් වන අතර ශුන්‍යය සඳහා පැහැදිලි චෙක්පතක් භාවිතා කළ යුතුය (නඩුව 3). එම වඩා හොඳ මෙහි නව ජාවා NULL-ආරක්ෂිත API පණ අදිමින් වුවත් තෝරා දේ ගම්ය දේ ආරම්භනය කිරීමට ගම්ය වන්නේ නැත නියම කිරීමට අසමත් වේගයෙන් කිරීමට ක්රමලේඛකයාට වැරදි සම්බන්ධයෙන්.

   ප්‍රශ්නය - අතිරික්ත කේතය ක්‍රියාත්මක කළ හැකි අතර අනවශ්‍ය සම්පත් උදුරා ගත හැකිය.
   පිළිතුර - getPhotoByName()දත්ත සමුදා සම්බන්ධතාවයක් විවෘත PreparedStatementකිරීමට, පුද්ගලයාගේ නම SQL පරාමිතියක් ලෙස නිර්මාණය කිරීමට සහ භාවිතා කිරීමට උත්සාහ කරන්නේ නම් එය සිදුවිය හැකිය . නොදන්නා ප්‍රශ්නයක් සඳහා ප්‍රවේශය නොදන්නා පිළිතුරක් ලබා දෙයි (නඩුව 1) මෙහි ක්‍රියාත්මක වේ. සම්පත් උදුරා ගැනීමට පෙර ක්‍රමය පරාමිතීන් පරික්ෂා කර අවශ්‍ය නම් 'නොදන්නා' ප්‍රති result ල ලබා දිය යුතුය.

   ප්‍රශ්නය - උත්සාහය වසා දැමීම විවෘත කිරීම හේතුවෙන් මෙම ප්‍රවේශයට කාර්ය සාධන ද penalty ුවමක් ඇත.
   පිළිතුර - මෘදුකාංගය මුලින්ම තේරුම් ගැනීමට සහ වෙනස් කිරීමට පහසු විය යුතුය. මෙයින් පසුව පමණක් කෙනෙකුට කාර්ය සාධනය ගැන සිතිය හැකි අතර අවශ්‍ය නම් පමණි! අවශ්‍ය තැන! ( ප්‍රභවය ) සහ තවත් බොහෝ අය).

   පීඑස්. "නිත්‍ය" කේත මූලධර්මයෙන් වෙනම දෝෂ හැසිරවීමේ කේතය යම් ස්ථානයක භාවිතා කිරීම සාධාරණ බැවින් මෙම ප්‍රවේශය සාධාරණ වනු ඇත . ඊළඟ උදාහරණය සලකා බලන්න:

   public SomeValue calculateSomeValueUsingSophisticatedLogic(Predicate predicate) {
       try {
           Result1 result1 = performSomeCalculation(predicate);
           Result2 result2 = performSomeOtherCalculation(result1.getSomeProperty());
           Result3 result3 = performThirdCalculation(result2.getSomeProperty());
           Result4 result4 = performLastCalculation(result3.getSomeProperty());
           return result4.getSomeProperty();
       } catch (NullPointerException e) {
           return null;
       }
   }
   
   public SomeValue calculateSomeValueUsingSophisticatedLogic(Predicate predicate) {
       SomeValue result = null;
       if (predicate != null) {
           Result1 result1 = performSomeCalculation(predicate);
           if (result1 != null && result1.getSomeProperty() != null) {
               Result2 result2 = performSomeOtherCalculation(result1.getSomeProperty());
               if (result2 != null && result2.getSomeProperty() != null) {
                   Result3 result3 = performThirdCalculation(result2.getSomeProperty());
                   if (result3 != null && result3.getSomeProperty() != null) {
                       Result4 result4 = performLastCalculation(result3.getSomeProperty());
                       if (result4 != null) {
                           result = result4.getSomeProperty();
                       }
                   }
               }
           }
       }
       return result;
   }

   පීපීඑස්. වේගයෙන් පහත් කොට සලකන අයට (සහ ලියකියවිලි කියවීමට එතරම් වේගවත් නොවේ) මම කියන්න කැමතියි මගේ ජීවිතයේ කිසි විටෙකත් ශුන්‍ය දර්ශක ව්‍යතිරේකයක් (එන්පීඊ) මා අල්ලාගෙන නැත. නමුත් මෙම හැකියාව හිතාමතාම ජාවා නිර්මාණකරුවන් විසින් නිර්මාණය කරන ලද්දේ NPE හි උප පංතියක් වන Exceptionබැවිනි. අපි ජාවා ඉතිහාසයේ පූර්වාදර්ශයක් ඇති වූ විට ThreadDeathයනු Errorඒක ඇත්තටම අයදුම්පතක් දෝෂයක් වේ, නමුත් එය එල්ල කිරීමට අදහස් කරන ලදී නොවේ පමණක් නිසා නිසා නොවේ! NPE Errorට වඩා කොපමණ ප්‍රමාණයක් ගැලපේද ThreadDeath! නමුත් එය එසේ නොවේ.

3. 'දත්ත නැත' යන්න පරීක්ෂා කරන්න ව්‍යාපාර තර්කනය එයින් ඇඟවෙන්නේ නම් පමණි.

   public void updatePersonPhoneNumber(Long personId, String phoneNumber) {
       if (personId == null)
           return;
       DataSource dataSource = appContext.getStuffDataSource();
       Person person = dataSource.getPersonById(personId);
       if (person != null) {
           person.setPhoneNumber(phoneNumber);
           dataSource.updatePerson(person);
       } else {
           Person = new Person(personId);
           person.setPhoneNumber(phoneNumber);
           dataSource.insertPerson(person);
       }
   }

   හා

   public void updatePersonPhoneNumber(Long personId, String phoneNumber) {
       if (personId == null)
           return;
       DataSource dataSource = appContext.getStuffDataSource();
       Person person = dataSource.getPersonById(personId);
       if (person == null)
           throw new SomeReasonableUserException("What are you thinking about ???");
       person.setPhoneNumber(phoneNumber);
       dataSource.updatePerson(person);
   }

   AppContext හෝ dataSource ආරම්භ කර නොමැති නම් පාලනය කළ නොහැකි ධාවන කාලය NullPointerException වත්මන් නූල් විනාශ කරන අතර එය Thread.defaultUncaughtExceptionHandler විසින් සකසනු ඇත (ඔබේ ප්‍රියතම ලොගර් හෝ වෙනත් දැනුම්දීම් යාන්ත්‍රණය නිර්වචනය කර භාවිතා කිරීමට). සකසා නොමැති නම්, ThreadGroup # uncaughtException මඟින් පද්ධතියේ දෝෂයට ස්ටැක්ට්‍රේස් මුද්‍රණය වේ. අයදුම්පත් දෝෂ ල log ු-සටහන් අධීක්‍ෂණය කළ යුතු අතර, ජිරා ගැටළුව විවෘත කළ යුතුය. ක්‍රමලේඛකයා ආරම්භක දේවල් වල කොතැනක හෝ දෝෂ නිවැරදි කළ යුතුය.

ජාවා 7 හි නව java.util.Objectsඋපයෝගිතා පන්තියක් ඇති අතර ඒ සඳහා requireNonNull()ක්‍රමවේදයක් ඇත. මේ සියල්ල කරන්නේ NullPointerExceptionඑහි තර්කය ශුන්‍ය නම් එය විසි කිරීම පමණි , නමුත් එය කේතය ටිකක් පිරිසිදු කරයි. උදාහරණයක්:

Objects.requireNonNull(someObject);
someObject.doCalc();

ඉදිකිරීම්කරුවෙකුගේ පැවරුමකට පෙර පරීක්ෂා කිරීම සඳහා මෙම ක්‍රමය වඩාත් ප්‍රයෝජනවත් වේ , එහිදී සෑම භාවිතයක්ම කේත පේළි තුනක් ඉතිරි කර ගත හැකිය:

Parent(Child child) {
   if (child == null) {
      throw new NullPointerException("child");
   }
   this.child = child;
}

බවට පත්වේ

Parent(Child child) {
   this.child = Objects.requireNonNull(child, "child");
}

අවසානයේදී, මෙම ගැටළුව මුළුමනින්ම විසඳීමට ඇති එකම ක්‍රමය වෙනස් ක්‍රමලේඛන භාෂාවක් භාවිතා කිරීමයි:

• පරමාර්ථ-සී හි, ඔබට ක්‍රමවේදයක් ක්‍රියාත්මක කිරීමට සමාන දෙයක් කළ හැකි අතර nil, කිසිවක් සිදු නොවනු ඇත. මෙය බොහෝ ශූන්‍ය චෙක්පත් අනවශ්‍ය කරයි, නමුත් එය දෝෂ හඳුනා ගැනීමට අපහසු වේ.
• දී සතුටක් විය හැකි-ශූන්ය අනුවාදය සහ නො-ශූන්ය අනුවාදය:, ජාවා-ව්යුත්පන්න භාෂාව, සියලු වර්ගයේ අනුවාද දෙකක් ඇත. ඔබට ආයාචනා කළ හැක්කේ ශුන්‍ය නොවන වර්ග මත පමණි. ශුන්‍යය සඳහා පැහැදිලි පරීක්ෂාවකින් විභව-ශුන්‍ය වර්ග ශුන්‍ය නොවන වර්ග බවට පරිවර්තනය කළ හැකිය. ශුන්‍ය චෙක්පත් අවශ්‍ය වන්නේ කොතැනද සහ ඒවා නොමැති තැන දැන ගැනීම මෙමඟින් පහසු කරයි.

ජාවාහි පොදු "ගැටලුව" ඇත්ත වශයෙන්ම.

පළමුව, මේ පිළිබඳ මගේ සිතුවිලි:

NULL වලංගු වටිනාකමක් නොමැති තැන NULL සම්මත වූ විට යමක් "අනුභව කිරීම" නරක යැයි මම සලකමි. ඔබ යම් ආකාරයක දෝෂයකින් ක්‍රමයෙන් ඉවත් නොවන්නේ නම් එයින් අදහස් වන්නේ ඔබේ ක්‍රමයේ කිසිවක් වැරදී නැති බවත් එය සත්‍ය නොවන බවත්ය. එවිට ඔබ බොහෝ විට මෙම අවස්ථාවෙහිදී ශුන්‍යව ආපසු එනු ඇති අතර, ලැබීමේ ක්‍රමයේදී ඔබ නැවත ශුන්‍යය සඳහා පරීක්ෂා කර බැලූ විට එය කිසි විටෙකත් අවසන් නොවන අතර ඔබ අවසන් වන්නේ "if! = Null" යනාදියෙනි.

එබැවින්, IMHO, null යනු තවදුරටත් ක්‍රියාත්මක කිරීම වළක්වන තීරණාත්මක දෝෂයක් විය යුතුය (එනම්, ශුන්‍යය වලංගු අගයක් නොවන තැන).

මම මෙම ගැටළුව විසඳන ආකාරය මෙයයි:

පළමුව, මම මෙම සම්මුතිය අනුගමනය කරමි:

1. සියලුම පොදු ක්‍රම / ඒපීඅයි සෑම විටම එහි තර්ක ශුන්‍ය සඳහා පරික්ෂා කරයි
2. පාලිත ක්‍රම වන බැවින් සියලුම පුද්ගලික ක්‍රම ශුන්‍යය සඳහා පරික්ෂා නොකරයි (එය ඉහත හසුරුවනු නොලැබුවහොත් ශුන්‍ය ලක්ෂ්‍ය ව්‍යතිරේකය සමඟ මිය යාමට ඉඩ දෙන්න)
3. ශුන්‍යය පරික්ෂා නොකරන අනෙක් ක්‍රම වන්නේ උපයෝගිතා ක්‍රම වේ. ඒවා පොදු ය, නමුත් ඔබ යම් හේතුවක් නිසා ඔවුන් අමතන්නේ නම්, ඔබ සම්මත කරන පරාමිතීන් මොනවාදැයි ඔබ දන්නවා. මෙය හරියට ජලය ලබා නොදී කේතලයේ ජලය තම්බා ගැනීමට උත්සාහ කිරීමක් වැනිය ...

අවසාන වශයෙන්, කේතයේ දී, පොදු ක්‍රමයේ පළමු පේළිය මේ ආකාරයට යයි:

ValidationUtils.getNullValidator().addParam(plans, "plans").addParam(persons, "persons").validate();

AddParam () ස්වයංක්‍රීයව නැවත පැමිණෙන බව සලකන්න, එවිට ඔබට පරීක්ෂා කිරීමට තවත් පරාමිතීන් එකතු කළ හැකිය.

කිසියම් පරාමිතියක් ශුන්‍ය නම් ක්‍රමය validate()පරීක්ෂා කරනු ValidationExceptionලැබේ (පරීක්ෂා කර හෝ පරීක්ෂා නොකිරීම වඩා නිර්මාණ / රස ගැටළුවක් වේ, නමුත් මගේ ValidationExceptionපරික්ෂා කර ඇත).

void validate() throws ValidationException;

උදාහරණයක් ලෙස "සැලසුම්" අහෝසි නම් පණිවිඩයේ පහත සඳහන් පෙළ අඩංගු වේ:

" නීති විරෝධී තර්කය අගය NULL පරාමිතිය සඳහා මුහුණ වේ [සැලසුම්] "

ඔබට පෙනෙන පරිදි, පරිශීලක පණිවිඩය සඳහා addParam () ක්‍රමයේ (නූල්) දෙවන අගය අවශ්‍ය වේ, මන්ද යත් පරාවර්තනය සහිතව වුවද සම්මත සම්මත විචල්‍ය නාමයක් ඔබට පහසුවෙන් හඳුනාගත නොහැකි බැවිනි (කෙසේ වෙතත් මෙම තනතුරට යටත් නොවේ ...).

ඔව්, මෙම රේඛාවෙන් ඔබ්බට අපට තවදුරටත් ශුන්‍ය අගයක් හමු නොවන බව අපි දනිමු. එබැවින් අපි එම වස්තූන් සඳහා ආරක්ෂිතව ක්‍රමවේදයන් ඉල්ලා සිටිමු.

මේ ආකාරයෙන්, කේතය පිරිසිදු, පහසුවෙන් නඩත්තු කළ හැකි සහ කියවිය හැකි ය.

එම ප්‍රශ්නය ඇසීමෙන් පෙන්නුම් කරන්නේ ඔබ දෝෂ හැසිරවීමේ උපාය මාර්ග කෙරෙහි උනන්දුවක් දක්වන බවයි. ඔබගේ කණ්ඩායමේ ගෘහ නිර්මාණ ශිල්පියා විසින් වැරදි ක්‍රියා කරන්නේ කෙසේදැයි තීරණය කළ යුතුය. මෙය කිරීමට ක්‍රම කිහිපයක් තිබේ:

1. ව්‍යතිරේකයන්ට ඉරිතැලීමට ඉඩ දෙන්න - ඒවා 'ප්‍රධාන පුඩුවේ' හෝ වෙනත් කළමනාකරණ පුරුද්දකදී අල්ලා ගන්න.

   • දෝෂ තත්වයන් පරීක්ෂා කර ඒවා නිසි ලෙස හසුරුවන්න

ඇස්පෙක්ට් ඔරියන්ටඩ් ක්‍රමලේඛනය දෙසද බලන්න - if( o == null ) handleNull()ඔබේ බයිට් කේතයට ඇතුළු කිරීමට ඔවුන්ට ක්‍රම තිබේ .

භාවිතා කිරීමට අමතරව assertඔබට පහත සඳහන් දෑ භාවිතා කළ හැකිය:

if (someobject == null) {
    // Handle null here then move on.
}

මෙය මීට වඩා තරමක් හොඳයි:

if (someobject != null) {
    .....
    .....



    .....
}

කිසි විටෙකත් ශුන්‍ය භාවිතා නොකරන්න. එයට ඉඩ නොදෙන්න.

මගේ පංති වලදී, බොහෝ ක්ෂේත්‍ර සහ දේශීය විචල්‍යයන් ශුන්‍ය නොවන පෙරනිමි අගයන් ඇති අතර, මෙය බලාත්මක වන බවට වග බලා ගැනීම සඳහා මම කේතයේ සෑම තැනකම කොන්ත්‍රාත් ප්‍රකාශ (සෑම විටම ප්‍රකාශ කරමි) එකතු කරමි (එය වඩාත් සංක්ෂිප්ත හා එයට ඉඩ දෙනවාට වඩා ප්‍රකාශිත බැවින් NPE ලෙස පැමිණ පසුව පේළි අංකය නිරාකරණය කිරීම ආදිය).

මම මෙම පුරුද්ද අනුගමනය කළ පසු, ගැටලු විසඳා ඇති බව මම දුටුවෙමි. සංවර්ධන ක්‍රියාවලියේදී ඔබ බොහෝ කලකට පෙර අහම්බෙන් දේවල් අල්ලාගෙන ඔබට දුර්වල ස්ථානයක් ඇති බව වටහා ගනී .. සහ වඩා වැදගත් ලෙස .. එය විවිධ මොඩියුලයන්ගේ උත්සුකයන් වටහා ගැනීමට උපකාරී වේ, විවිධ මොඩියුලයන් එකිනෙකා 'විශ්වාස කළ හැකිය', සහ තවදුරටත් පැටව් ගසන්නේ නැත if = null elseඉදිකිරීම් සමඟ කේතය !

මෙය ආරක්ෂක ක්‍රමලේඛනය වන අතර දිගු කාලීනව වඩා පිරිසිදු කේතයක් ඇති කරයි. සෑම විටම දත්ත සනීපාරක්ෂාව කරන්න, උදා: දෘඩ ප්‍රමිතීන් බලාත්මක කිරීමෙන් මෙහි ගැටළු පහව යයි.

class C {
    private final MyType mustBeSet;
    public C(MyType mything) {
       mustBeSet=Contract.notNull(mything);
    }
   private String name = "<unknown>";
   public void setName(String s) {
      name = Contract.notNull(s);
   }
}


class Contract {
    public static <T> T notNull(T t) { if (t == null) { throw new ContractException("argument must be non-null"); return t; }
}

කොන්ත්‍රාත්තු යනු සෑම විටම ක්‍රියාත්මක වන, නිෂ්පාදනයේදී පවා ක්‍රියාත්මක වන කුඩා ඒකක පරීක්ෂණ හා සමාන වන අතර, දේවල් අසාර්ථක වූ විට, අහඹු NPE එකකට වඩා ඔබට කෙසේ හෝ හඳුනාගත යුත්තේ මන්දැයි ඔබ දන්නවා.

ගූගල් හි ඉතා ප්‍රයෝජනවත් මූලික පුස්තකාලයක් වන ගුවා, ශුන්‍යයන් වළක්වා ගැනීම සඳහා හොඳ සහ ප්‍රයෝජනවත් API එකක් ඇත. UseAndAvoidingNullExplained ඉතා ප්‍රයෝජනවත් බව මට පෙනේ .

විකියේ විස්තර කර ඇති පරිදි:

Optional<T>යනු ශුන්‍ය නොවන ටී යොමුව ශුන්‍ය නොවන අගයක් සමඟ ප්‍රතිස්ථාපනය කිරීමේ ක්‍රමයකි. විකල්පයක් තුළ ශුන්‍ය නොවන ටී යොමු කිරීමක් අඩංගු විය හැකිය (එම අවස්ථාවේදී අපි යොමු කිරීම "පවතින" යැයි කියමු), හෝ එහි කිසිවක් අඩංගු නොවිය හැකිය (එවැනි අවස්ථාවකදී අපි "නොපැමිණීම" යැයි කියමු). එය කිසි විටෙකත් "ශුන්‍යය අඩංගු" යැයි නොකියයි.

භාවිතය:

Optional<Integer> possible = Optional.of(5);
possible.isPresent(); // returns true
possible.get(); // returns 5

සෑම ජාවා සංවර්ධකයෙකුටම මෙය ඉතා පොදු ගැටළුවකි. එබැවින් අවුල් සහගත කේතයකින් තොරව මෙම ගැටළු විසඳීම සඳහා ජාවා 8 හි නිල සහාය ඇත.

ජාවා 8 හඳුන්වා දී java.util.Optional<T>ඇත. එය ශුන්‍ය නොවන අගයක් හෝ නොතිබිය හැකි බහාලුමකි. සමහර අවස්ථාවන්හි වටිනාකම අහෝසි විය හැකි වස්තුවක් හැසිරවීමට ජාවා 8 ආරක්ෂිත ක්‍රමයක් ලබා දී ඇත. එය දේවානුභාවයෙන් හස්කල් සහ ස්කාලාගේ අදහස් වලින් .

කෙටියෙන් කිවහොත්, විකල්ප පන්තියට වටිනාකමක් ඇති හෝ නොමැති අවස්ථාවන්හි පැහැදිලිව කටයුතු කිරීමේ ක්‍රම ඇතුළත් වේ. කෙසේ වෙතත්, ශුන්‍ය යොමු කිරීම් හා සසඳන විට ඇති වාසිය නම්, විකල්ප <T> පන්තිය මඟින් අගය නොමැති විට නඩුව ගැන සිතා බැලීමට බල කරයි. ප්‍රති consequ ලයක් ලෙස, ඔබට අනපේක්ෂිත ශුන්‍ය දර්ශක ව්‍යතිරේකයන් වළක්වා ගත හැකිය.

ඉහත උදාහරණයේ දී අප සතුව ගෘහ සේවා කර්මාන්ත ශාලාවක් ඇති අතර එය නිවසේ ඇති විවිධ උපකරණ සඳහා හසුරුව නැවත ලබා දෙයි. නමුත් මෙම සේවාවන් ලබා ගත හැකිය / නොතිබිය හැකිය; එයින් අදහස් වන්නේ එය NullPointerException වලට හේතු විය හැකි බවයි. ifකිසියම් සේවාවක් භාවිතා කිරීමට පෙර ශුන්‍ය කොන්දේසියක් එකතු කරනවා වෙනුවට , එය විකල්ප <සේවා> වෙත ඔතා ගනිමු.

විකල්පයට ඔතා <T>

කර්මාන්ත ශාලාවකින් සේවාවක් පිළිබඳ සඳහනක් ලබා ගැනීමේ ක්‍රමයක් සලකා බලමු. සේවා යොමු කිරීම වෙනුවට, එය විකල්ප සමඟ ඔතා. ආපසු ලබා දුන් සේවාව ලබා ගත නොහැකි / ක්‍රියාකාරී නොවිය හැකි බව ආරක්ෂිතව භාවිතා කිරීමට API පරිශීලකයාට එය ඉඩ දෙයි

public Optional<Service> getRefrigertorControl() {
      Service s = new  RefrigeratorService();
       //...
      return Optional.ofNullable(s);
   }

ඔබ දකින Optional.ofNullable()පරිදි යොමු කිරීම ඔතා ගැනීමට පහසු ක්‍රමයක් සපයයි. විකල්ප සමුද්දේශ ලබා ගැනීමට තවත් ක්රම තිබෙනවා, එක්කෝ Optional.empty()සහOptional.of() . එකක් හිස් වස්තුවක් නැවත ලබා ගැනීම වෙනුවට නැවත ලබා දීම සඳහා වන අතර අනෙක පිළිවෙලින් ශුන්‍ය නොවන වස්තුවක් එතීම සඳහා ය.

එසේ නම්, සම්පූර්ණ පරීක්‍ෂණයකින් වැළකී සිටීමට එය හරියටම උපකාර කරන්නේ කෙසේද?

ඔබ විමර්ශන වස්තුවක් ඔතා ගත් පසු, එන්පීඊ නොමැතිව ඔතා ඇති යොමුවකට ක්‍රම කැඳවීමට විකල්ප බොහෝ ප්‍රයෝජනවත් ක්‍රම සපයයි.

Optional ref = homeServices.getRefrigertorControl();
ref.ifPresent(HomeServices::switchItOn);

Optional.ifPresent විසින් ලබා දී ඇති පාරිභෝගිකයාට එය ශුන්‍ය නොවන අගයක් නම් යොමු කිරීමක් ඉල්ලා සිටී. එසේ නොමැති නම්, එය කිසිවක් නොකරයි.

@FunctionalInterface
public interface Consumer<T>

තනි ආදාන තර්කයක් පිළිගෙන කිසිදු ප්‍රති .ලයක් ලබා නොදෙන මෙහෙයුමක් නියෝජනය කරයි. අනෙකුත් බොහෝ ක්‍රියාකාරී අතුරුමුහුණත් මෙන් නොව, පාරිභෝගිකයා අතුරු ආබාධ හරහා ක්‍රියාත්මක වනු ඇතැයි අපේක්ෂා කෙරේ. එය එතරම් පිරිසිදු හා තේරුම් ගැනීමට පහසුය. ඉහත කේත උදාහරණයේ,HomeService.switchOn(Service) විකල්ප රඳවා ගැනීමේ යොමුව ශුන්‍ය නොවේ නම් ආයාචනා කරනු ලැබේ.

ශුන්‍ය තත්වය පරීක්ෂා කිරීම සඳහා අපි බොහෝ විට ත්‍රිමාණ ක්‍රියාකරු භාවිතා කර විකල්ප අගයක් හෝ පෙරනිමි අගයක් ලබා දෙන්නෙමු. විකල්පය ශුන්‍යය පරික්ෂා නොකර එකම තත්වයක් හැසිරවීමට තවත් ක්‍රමයක් සපයයි. විකල්පය ශුන්‍ය අගයක් ඇත්නම් Optional.orElse (defaultObj) defaultObj ලබා දෙයි. මෙය අපගේ නියැදි කේතයේ භාවිතා කරමු:

public static Optional<HomeServices> get() {
    service = Optional.of(service.orElse(new HomeServices()));
    return service;
}

දැන් HomeServices.get () එකම දේ කරයි, නමුත් වඩා හොඳ ආකාරයකින්. සේවාව දැනටමත් ආරම්භ කර නොමැතිදැයි එය පරීක්ෂා කරයි. එය එසේ නම් එය නැවත ලබා දෙන්න හෝ නව නව සේවාවක් සාදන්න. විකල්ප <T>. හෝ පෙරනිමි අගයක් ලබා දීමට වෙනත් (ටී) උපකාරී වේ.

අවසාන වශයෙන්, මෙන්න අපගේ NPE මෙන්ම ශුන්‍ය චෙක්-රහිත කේතය:

import java.util.Optional;
public class HomeServices {
    private static final int NOW = 0;
    private static Optional<HomeServices> service;

public static Optional<HomeServices> get() {
    service = Optional.of(service.orElse(new HomeServices()));
    return service;
}

public Optional<Service> getRefrigertorControl() {
    Service s = new  RefrigeratorService();
    //...
    return Optional.ofNullable(s);
}

public static void main(String[] args) {
    /* Get Home Services handle */
    Optional<HomeServices> homeServices = HomeServices.get();
    if(homeServices != null) {
        Optional<Service> refrigertorControl = homeServices.get().getRefrigertorControl();
        refrigertorControl.ifPresent(HomeServices::switchItOn);
    }
}

public static void switchItOn(Service s){
         //...
    }
}

සම්පූර්ණ තනතුර NPE මෙන්ම ශුන්‍ය චෙක්-රහිත කේතය… ඇත්තද? .

මම නැට් ප්‍රයිස්ගේ ලිපි වලට කැමතියි. මෙන්න සබැඳි:

• පොලිමෝර්ෆික් ඩිස්පැච් සමඟ ශුන්‍ය වීම වළක්වා ගැනීම
• "කියන්න, අහන්න එපා" ශෛලිය සමඟ ශූන්‍යයෙන් වැළකී සිටීම

ලිපි වල ජාවා සමහර විට ටයිප් කිරීම සඳහා Git නිධියකට සබැඳියක් ද ඇත, එය මට සිත්ගන්නා සුළුය, නමුත් එය පමණක් පරීක්ෂා කිරීමේ කේත පිපිරීම අඩු කළ හැකි යැයි මම නොසිතමි. අන්තර්ජාලයේ යම් පර්යේෂණයක් කිරීමෙන් පසුව, මම සිතන්නේ ! = ශුන්‍ය කේත පිපිරීම ප්‍රධාන වශයෙන් ප්‍රවේශමෙන් සැලසුම් කිරීමෙන් අඩු කළ හැකිය.

මම උත්සාහ කර ඇති NullObjectPatternනමුත් මට සෑම විටම යන්න හොඳම ක්‍රමය නොවේ. සමහර විට "ක්‍රියාවක් නැත" යන්න සුදුසු නොවේ.

NullPointerExceptionයනු ධාවන හැර යනු එය සංවර්ධකයින් වරද හා ප්රමාණවත් අත්දැකීම් සමග එය ඔබ පවසනවා හරියටම දෝෂය බව.

දැන් පිළිතුරට:

ඔබගේ සියලු ගුණාංග සහ එහි ප්‍රවේශයන් හැකි තරම් පුද්ගලික කිරීමට උත්සාහ කරන්න හෝ ඒවා සේවාදායකයින්ට නිරාවරණය කිරීමෙන් වළකින්න. ඔබට ඇත්ත වශයෙන්ම ඉදිකිරීම්කරු තුළ තර්ක අගයන් තිබිය හැකිය, නමුත් විෂය පථය අඩු කිරීමෙන් ඔබ සේවාදායක පන්තියට අවලංගු අගයක් පසු කිරීමට ඉඩ නොදේ. ඔබට අගයන් වෙනස් කිරීමට අවශ්‍ය නම්, ඔබට සැමවිටම නව එකක් නිර්මාණය කළ හැකිය object. ඔබ ඉදිකිරීම්කරුගේ අගයන් පමණක් පරීක්ෂා කරන්න එක් වරක් කරන අතර ඉතිරි ක්‍රම වලදී අගයන් ශුන්‍ය නොවන බවට ඔබට සහතික විය හැකිය.

ඇත්ත වශයෙන්ම, මෙම යෝජනාව තේරුම් ගැනීමට සහ අදාළ කර ගැනීමට වඩා හොඳ ක්‍රමය අත්දැකීම් වේ.

බයිට්!

ජාවා 8 හෝ නව සඳහා හොඳම විකල්පය වන්නේ Optionalපන්තිය භාවිතා කිරීමයි .

Optional stringToUse = Optional.of("optional is there");
stringToUse.ifPresent(System.out::println);

විය හැකි ශුන්‍ය අගයන් සහිත දිගු දාම සඳහා මෙය විශේෂයෙන් පහසුය. උදාහරණයක්:

Optional<Integer> i = Optional.ofNullable(wsObject.getFoo())
    .map(f -> f.getBar())
    .map(b -> b.getBaz())
    .map(b -> b.getInt());

ව්‍යතිරේකය ශුන්‍යයට විසි කරන්නේ කෙසේද යන්න පිළිබඳ උදාහරණය:

Optional optionalCarNull = Optional.ofNullable(someNull);
optionalCarNull.orElseThrow(IllegalStateException::new);

ජාවා 7 හඳුන්වා දුන්නේය Objects.requireNonNull අහෝසි නොවන දෙයක් සඳහා යමක් පරික්ෂා කළ යුතු විට එය ප්‍රයෝජනවත් වේ. උදාහරණයක්:

String lowerVal = Objects.requireNonNull(someVar, "input cannot be null or empty").toLowerCase();

මම ඊට වඩා පොදුවේ පිළිතුරු දෙන්නම්!

අපි සාමාන්‍යයෙන් මෙම ගැටලුවට මුහුණ දෙන්නේ ක්‍රමවේදයන් අප බලාපොරොත්තු නොවූ ආකාරයෙන් පරාමිතීන් ලබා ගත් විටය (නරක ක්‍රම ඇමතුම ක්‍රමලේඛකයාගේ වරදකි). උදාහරණයක් ලෙස: ඔබ වස්තුවක් ලබා ගැනීමට අපේක්ෂා කරයි, ඒ වෙනුවට ඔබට ශුන්‍යයක් ලැබේ. ඔබ අවම වශයෙන් එක් අක්ෂරයක් සහිත නූලක් ලබා ගැනීමට අපේක්ෂා කරයි, ඒ වෙනුවට ඔබට හිස් නූලක් ලැබේ ...

එබැවින් අතර වෙනසක් නැත:

if(object == null){
   //you called my method badly!

}

හෝ

if(str.length() == 0){
   //you called my method badly again!
}

ඔවුන් දෙදෙනාම අපට වෙනත් කාර්යයන් කිරීමට පෙර වලංගු පරාමිතීන් ලැබී ඇති බවට සහතික කර ගැනීමට අවශ්‍යය.

වෙනත් පිළිතුරු වල සඳහන් කර ඇති පරිදි, ඉහත ගැටළු වළක්වා ගැනීම සඳහා ඔබට කොන්ත්‍රාත් රටාව අනුව සැලසුම අනුගමනය කළ හැකිය . කරුණාකර http://en.wikipedia.org/wiki/Design_by_contract බලන්න .

ජාවා මෙම රටාව ක්රියාත්මක කිරීම සඳහා, ඔබ වැනි මූලික ජාවා විවරණයන් ඉදිරිපත් භාවිතා කළ හැකිය javax.annotation.NotNull හෝ වැනි භාවිතය වඩාත් සූක්ෂම පුස්තකාල හයිබනේට් Validator .

නියැදියක් පමණි:

getCustomerAccounts(@NotEmpty String customerId,@Size(min = 1) String accountType)

ආදාන පරාමිතීන් පරික්ෂා කිරීමකින් තොරව දැන් ඔබට ඔබේ ක්‍රමයේ මූලික ක්‍රියාකාරිත්වය ආරක්ෂිතව සංවර්ධනය කළ හැකිය, ඔවුන් ඔබේ ක්‍රම අනපේක්ෂිත පරාමිතීන්ගෙන් ආරක්ෂා කරයි.

ඔබට තවත් පියවරක් ඉදිරියට ගොස් ඔබගේ යෙදුම තුළ වලංගු පූජෝ පමණක් සෑදිය හැකි බවට වග බලා ගන්න. (ශිශිර වලංගු කිරීමේ වෙබ් අඩවියෙන් සාම්පලය)

public class Car {

   @NotNull
   private String manufacturer;

   @NotNull
   @Size(min = 2, max = 14)
   private String licensePlate;

   @Min(2)
   private int seatCount;

   // ...
}

සෑම තත්වයකදීම ශුන්‍ය වස්තු භාවිතා කිරීමට යෝජනා කරන පිළිතුරු මම නොසලකා හරිමි. මෙම රටාව මඟින් කොන්ත්රාත්තුව බිඳ දැමිය හැකි අතර ඒවා විසඳීම වෙනුවට ගැඹුරින් හා ගැඹුරින් වළලනු ඇත, නුසුදුසු ලෙස භාවිතා කිරීම ගැන සඳහන් නොකිරීම අනාගත නඩත්තුව අවශ්ය වන බොයිලර් ප්ලේට් කේතයේ තවත් ගොඩවල් නිර්මාණය කරයි.

යථාර්ථය නම්, කිසියම් ක්‍රමයකින් ආපසු ලබා දුන් දෙයක් අහෝසි කළ හැකි නම් සහ ඇමතුම් කේතය ඒ පිළිබඳව තීරණයක් ගත යුතු නම්, කලින් ඇමතුමක් තිබිය යුතුය.

මතක තබා ගන්න, එම ශුන්‍ය වස්තු රටාව සැලකිලිමත් නොවී භාවිතා කරන්නේ නම් මතකයේ බඩගිනි වනු ඇත. මේ සඳහා - NullObject හි උදාහරණය අයිතිකරුවන් අතර බෙදා ගත යුතු අතර, මේ සෑම එකක් සඳහාම අද්විතීය අවස්ථාවක් නොවිය යුතුය.

ගණිතමය ආයතන වැනි, පරිමාණයන් නොවන ප්‍රාථමික වර්ග නිරූපණයක් ලෙස මෙම රටාව භාවිතා කිරීමට මම නිර්දේශ නොකරමි: දෛශික, න්‍යාස, සංකීර්ණ සංඛ්‍යා සහ රාජ්‍ය රඳවා තබා ගැනීමට අදහස් කරන POD (සරල පැරණි දත්ත) වස්තු. ජාවා සාදන ලද වර්ගවල. අවසාන අවස්ථාවේ දී ඔබ අත්තනෝමතික ප්‍රති .ල සමඟ ඇමතුම් ලබා ගැනීමේ ක්‍රමවේදයන් අවසන් කරනු ඇත. උදාහරණයක් ලෙස NullPerson.getName () ක්‍රමයක් නැවත පැමිණිය යුත්තේ කුමක් ද?

විකාර ප්‍රති .ල වළක්වා ගැනීම සඳහා එවැනි අවස්ථා සලකා බැලීම වටී.

1. විචල්‍යයන් කිසි විටෙකත් ශුන්‍ය කිරීමට ආරම්භ නොකරන්න.
2. (1) නොහැකි නම්, සියලු එකතු කිරීම් සහ අරා හිස් එකතු කිරීම් / අරා වෙත ආරම්භ කරන්න.

මෙය ඔබේම කේතයකින් කිරීමෙන් ඔබට වළක්වා ගත හැකිය! = ශූන්‍ය චෙක්පත්.

බොහෝ විට ශුන්‍ය චෙක්පත් එකතු කිරීම් හෝ අරා මත ලූප ආරක්ෂා කරන බවක් පෙනේ, එබැවින් ඒවා හිස්ව ආරම්භ කරන්න, ඔබට කිසිදු ශුන්‍ය චෙක්පතක් අවශ්‍ය නොවේ.

// Bad
ArrayList<String> lemmings;
String[] names;

void checkLemmings() {
    if (lemmings != null) for(lemming: lemmings) {
        // do something
    }
}



// Good
ArrayList<String> lemmings = new ArrayList<String>();
String[] names = {};

void checkLemmings() {
    for(lemming: lemmings) {
        // do something
    }
}

මෙහි ඉතා කුඩා පොදු කාර්යයක් ඇත, නමුත් එය පිරිසිදු කේතයක් සහ අඩු NullPointerException සඳහා වටී.

බොහෝ සංවර්ධකයින් සඳහා සිදු වූ වඩාත් පොදු දෝෂය මෙයයි.

මෙය හැසිරවීමට අපට ක්‍රම ගණනාවක් තිබේ.

ප්‍රවේශය 1:

org.apache.commons.lang.Validate //using apache framework

notNull (වස්තු වස්තුව, සංගීත පණිවිඩය)

ප්‍රවේශය 2:

if(someObject!=null){ // simply checking against null
}

ප්‍රවේශය 3:

@isNull @Nullable  // using annotation based validation

ප්‍රවේශය 4:

// by writing static method and calling it across whereever we needed to check the validation

static <T> T isNull(someObject e){  
   if(e == null){
      throw new NullPointerException();
   }
   return e;
}

public static <T> T ifNull(T toCheck, T ifNull) {
    if (toCheck == null) {
           return ifNull;
    }
    return toCheck;
}