Code Smell 304: Ang Null Pointer Exception - Paano Pumunta sa NULL References na Nagkakaroon ng Runtime Crashes

Ipinapakita ko ang tungkol sa mga problema ng NULL, ngunit araw-araw ang mga news ay nag-iisip sa akin: ang NULL ay mahirap at bumalik.

TL;DR: Pumunta sa mga NULL references na nagiging sanhi ng runtime crashes sa pamamagitan ng paggamit ng parehong validation at null-safe patterns

TL;DR: Pumunta sa mga NULL references na nagiging sanhi ng runtime crashes sa pamamagitan ng paggamit ng parehong validation at null-safe patterns

ang problema

• Tungkol sa Crash
• Mga pangunahing incidents at disruptions
• Unpredictable ang behavior
• Tungkol sa Debugging
• ang frustration ng user
• Instabilidad ng sistema
• Malaki ang reliability

saAng Google Cloudang case:

• Bad error handling: Ang code crashed sa halip ng gracefully handling null data
• Walang mga feature flags: Ang bagong code ay hindi palagi-palagi na inilabas sa mga seguridad controls
• Instant Global Replication: Bad data ay lumalabas sa buong mundo ngayong tulad ng sa Crowdstrike Incident
• Walang randomized backoff: Recovery na nangangahulugan ng infrastructure overload
• Inadequate testing: Ang error scenario ay hindi na tested sa panahon ng pag-implementasyon

Mga Solusyon

1. Huwag ng mga zero
2. Gamitin ang null checks kung ang nulls ay higit sa iyong kontrol ( halimbawa, isang external API)
3. I-initialize ang default values
4. Paggamit ng mga custody clauses
5. Paggamit ng Null Object
6. Huwag gamitin ang optional

Ipinanganak ang mga ito ️

https://hackernoon.com/code-refactoring-tips-no-015-remove-null

ang konteksto

Noong Hunyo 12, 2025, aPagkakaiba ng StopNagsimula ang mga ito sa Google Cloud Platform.

Ang mga ito ay nakakaapekto sa duties ng mga serbisyo ng Google Cloud at Google Workspace sa buong mundo mula sa halos 10:49 AM hanggang 1:49 PM PDT (3 oras sa kabuuan), na may ilang mga serbisyo na nangangailangan ng higit pa upang mai-recover ang lahat.

Ang pag-uugali ay nangangahulugan sa isang cascading error sa Google's API management system:

• ang trigger:

Noong Mayo 29, 2025, inilapat ng Google ang isang bagong code sa "Service Control" (ang kanilang sistema ng pag-management ng API) na idinagdag ng karagdagang mga check ng politika ng quota.

Ang code na ito ay may isang kritikal na defect. Ito ay hindi nagkakahalagaMga errorWala siyang proteksiyon saAng mga flag.

• Ang mga Failure:

Noong Hunyo 12, isang pagbabago ng politika na naglalaman ng blank/ang zeroPagkatapos ng pagsubok ng Service Control upang pagproseso ang mga empty fields, natagpuan ang isang null pointer sa unprotected code path, kung saan ang binary crashed sa isang infinite loop.

• Ang global impact ay:

Dahil ang pag-management ng quota ay global, ang mga corrupt na data na ito ay replicated sa buong mundo sa loob ng ilang segundo, nangangahulugang ang Service Control sa pag-crash sa lahat ng rehiyon.

Ang Null pointer exception ay dumating kapag nagtatrabaho sa pag-access ng mga methods o properties sa mga objekto na hindi kasalukuyang.

Ito ay nangyayari kapag ang mga variable ay naglalaman ng null references sa halip ng valid na instances ng object.

Ang problemang ito ay magiging karaniwan sa produksyon na mga environment kung saan ang mga exception ay maaaring tumagal ang iyong application at frustrate ang mga gumagamit.

Ang mga wika tulad ng Java, C#, at JavaScript ay karamihan sa mga problema na ito, kahit na ang mga modernong mga tampok at pattern ng wika ay maaaring makatulong sa iyo upang maiwasan ang mga crashes na ito sa lahat.

Ang Nulls ay isang pangunahing problema sa industriya ng software para sa mga dekada, ngunit ang mga engineer ng software ay patuloy nangangahulugan ang mga ito maliban sa mga admonitions ng kanilang tagapagtatag.

Sample code

Malapit na ang

public class ServiceControlPolicy {
  private SpannerDatabase spannerDB;
  private QuotaManager quotaManager;
    
  public void applyPolicyChange(PolicyChange change) {
      // NULL POINTER: change can be null
      Policy policy = spannerDB.getPolicy(change.getPolicyId());
      // NULL POINTER: policy can be null from the database
      String quotaField = policy.getQuotaField();
      // NULL POINTER: quotaField can be null (blank field)
      quotaManager.updateQuota(quotaField, change.getValue());
  }
    
  public void exerciseQuotaChecks(String region) {
      // NULL POINTER: policies list can be null
      List<Policy> policies = spannerDB.getPoliciesForRegion(region);
      for (Policy policy : policies) {
          // NULL POINTER: individual policy can be null
          String quotaValue = policy.getQuotaField();
          // NULL POINTER: quotaValue can be null before trim()
          quotaManager.checkQuota(quotaValue.trim());
      }
  }
    
  public boolean validatePolicyData(Policy policy) {
      // NULL POINTER: policy parameter can be null
      String quotaField = policy.getQuotaField();
      // NULL POINTER: quotaField can be null before length()
      return quotaField.length() > 0 && 
             !quotaField.equals("null");
  }
    
  public void replicateGlobally(PolicyChange change) {
      List<String> regions = getGlobalRegions();
      for (String region : regions) {
          // NULL POINTER: change.getPolicy() can return null
          spannerDB.insertPolicy(region, change.getPolicy());
      }
  }
}

ang right

public class ServiceControlPolicy {
  private SpannerDatabase spannerDB;
  private QuotaManager quotaManager;
    
  public void applyPolicyChange(PolicyChange change) {
      if (change == null) {
          // Assuming it comes from an external API
          // Beyond your control
          change = new NullPolicyChange();
      }
      
      Policy policy = findPolicyOrNull(change.policyId());
      String quotaField = policy.quotaField();
      if (!quotaField.isEmpty()) {
          quotaManager.updateQuota(quotaField, change.value());
      }
  }
    
  public void exerciseQuotaChecks(String region) {
      if (region == null || region.isEmpty()) {
          // Assuming it comes from an external API
          // Beyond your control
          return;
      }
      
      List<Policy> policies = policiesOrEmpty(region);
      
      for (Policy policy : policies) {
          String quotaValue = policy.quotaField();
          if (!quotaValue.isEmpty()) {
              quotaManager.checkQuota(quotaValue.trim());
          }
      }
  }
    
  public boolean validatePolicyData(Policy policy) {
      if (policy == null) {
          // Assuming it comes from an external API
          // Beyond your control
          // From now on, you wrap it
          policy = new NullPolicy();
      }
      
      String quotaField = policy.quotaField();
      return quotaField.length() > 0;
  }
    
  public void replicateGlobally(PolicyChange change) {
      if (change == null) {
          // Assuming it comes from an external API
          // Beyond your control
          // From now on, you wrap it
          change = new NullPolicyChange();
      }
        
      Policy policy = change.policy();
      if (policy == null) {
          // Assuming it comes from an external API
          // Beyond your control
          // From now on, you wrap it
          policy = new NullPolicy();
      }
        
      List<String> regions = globalRegions();
      for (String region : regions) {
          spannerDB.insertPolicy(region, policy);
      }
  }
    
  private Policy findPolicyOrNull(String policyId) {
      Policy policy = spannerDB.policy(policyId);
      return policy != null ? policy : new NullPolicy();
  }
    
  private List<Policy> policiesOrEmpty(String region) {
      List<Policy> policies = spannerDB.policiesForRegion(region);
      if (policies == null) {
          // This is a good NullObject
          return Collections.emptyList();
      }
      
      return policies.stream()
              .map(p -> p != null ? p : new NullPolicy())
              .collect(Collectors.toList());
  }
}

class NullPolicy extends Policy {
  @Override
  public String quotaField() { return ""; }
    
  @Override
  public String policyId() { return "unknown-policy"; }
    
  @Override
  public Map<String, String> metadata() { 
      return Collections.emptyMap(); 
  }
}

class NullPolicyChange extends PolicyChange {
  @Override
  public String policyId() { return ""; }
    
  @Override
  public String value() { return ""; }
    
  @Override
  public Policy policy() { return new NullPolicy(); }
}

Mga Deteksiyon

• [x] Ang mga halimbawa ay

Maaari mong i-detect potential null pointer exceptions sa pamamagitan ng pag-review ng code para sa direct method calls sa mga objekto nang walang null checks.

Ang mga linters ay maaaring i-examine ang return values mula sa mga paraan na maaaring i-returnang zero, paghahanap para sa uninitialized object fields, at gumagamit ng static analysis tools na flag potensyal null dereferences.

Ang mga modernong mga ideya ay karaniwang nag-aalok ng mga problema na ito sa pamamagitan ng mga warning.

Mga araw ️

• ang zero

ang level

• [x] Ang mga sumusunod

Bakit importante ang pagbabago ️

sa mgaang real worldAng mga bagay ay mayroon o hindi.

Kapag bumalik na ako sa UP, i'll start building a new me.Mga Correspondencesa pagitan ng reality at code.

I-break ang bijection na ito sa pamamagitan ng pagganap ng null references ay lumikha ng phantom na mga objekto na ginagamit sa iyong code ngunit hindi sa real world, na nangangahulugan sa mga crashes kapag nagtatrabaho sa pag-interact sa mga inexistent na entities.

Kung nag-aalok mo ang pangalan ng iyong license plate "NULL", makakuha ka ngmaraming parking ticket

Ikaw ang Generation

Ang mga generator ng AI ay karaniwang lumikha ng code na may zero pointer vulnerabilities dahil nag-focus sa happy path scenarios.

Ang mga ito ay karaniwang lumikha ng mga call ng methode nang hindi nila tinanggap ang mga kaso ng edge kung saan ang mga objekto ay maaaring magingang zero, lalo na sa mga kompleksong hierarchy ng object o kapag nagtatrabaho sa mga eksternal na source ng data.

Mga Deteksiyon

Ang mga tool ng AI ay maaaring i-detect at i-fix ang mga problema ng null pointer kapag ibinigay mo ang mga katangian tungkol sa defensive programming practices.

Tapos na ang klase. 🙂 🙂

Tandaan: Ang mga assistant ng AI ay gumagawa ng maraming mga error

Suggested Prompt: I-remove ang lahat ng Null References

Suggested Prompt: I-remove ang lahat ng Null References

ang chat

ang chat

si Claude

si Claude

ang perplexity

ang perplexity

Mga Pilot

Mga Pilot

Mga Gemini

Mga Gemini

Mga pahinang

Mga pahinang

Ang meta ay

Meta AI

ang guro

ang guro

ang kwento

ang kwento

Mga Konklusyon

Null pointer exceptions represent one of the most common runtime errors in programming.

Maaari mong i-remove ang karamihan ng mga crash na ito sa pamamagitan ng pag-implementasyon ng parehong null checks, gamit ang Null Object design pattern, at paggamit ng defensive programming practices.

Ang maliit na overhead ng code ng pag-validation ay magkakaroon ng malaking pagbabago sa application stability at user experience.

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-iii-t7h3zkv

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xliii

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxxix

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxvi

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xlii

Higit pang impormasyon

Disclaimer

Code Smells ay ang akingopinyon.

I call it my billion-dollar mistake. Ito ay ang invention ng null reference noong 1965.

I call it my billion-dollar mistake. Ito ay ang invention ng null reference noong 1965.

Si Tony ay

Ang artikulong ito ay bahagi ng CodeSmell Series.