Vad är adapterns designmönster och hur kan du använda det?

Vad är adapterns designmönster och hur kan du använda det?
Läsare som du hjälper till att stödja MUO. När du gör ett köp med hjälp av länkar på vår webbplats kan vi tjäna en affiliate-provision. Läs mer.

Med framväxten av tjänsteorienterad arkitektur (SOA) använder fler och fler organisationer tredjepartstjänster för sina företagssystem. Dessa företag måste hänga med i en snabbt föränderlig affärsmiljö, vilket kan innebära att de överger tjänsterna från en tjänsteleverantör för en annan.





I sådana fall kan ett företags befintliga arkitektur vara inkompatibel med en ny leverantörs. Istället för att slösa månader på att skriva om företagskoden för att göra den kompatibel med ny programvara, kan ett företag använda adapterns designmönster.



Vad är adapterns designmönster?

Adaptermönstret tillåter klasser som har inkompatibla gränssnitt att arbeta tillsammans. Den gör detta genom att konvertera gränssnittet för en befintlig klass (eller programvara) till ett som en klient (eller tjänst) förväntar sig. Det finns två typer av adaptrar: objektadaptrar och klassadaptrar.





Objektadaptern använder komposition för att linda in adaptern med adaptern, vilket effektivt producerar det gränssnitt som klienten förväntar sig. Så om klienten förväntar sig en sträng kommer adaptern att ta ett heltal (den adapterade) och ge den egenskaperna hos en sträng.

min dator är ansluten men laddas inte
Objektadapter

Klassdiagrammet ovan representerar objektadaptern. De adapter klass implementerar målgränssnitt , som effektivt får tillgång till alla gränssnittets metoder. Sedan anpassar den en anpassad och slår in det anpassad med målgränssnitt metoder.



Klassadaptern använder multipelt arv, där adapterklassen är underklassen till både adaptern och målklassen. Klassdiagrammet nedan representerar klassadaptern, som du är fri att använda i programmeringsspråk som stöder multipla arv.

hur man väcker windows 10
Klass adapter

Implementering av adapterdesignmönstret i Java

Denna applikation kommer att implementera objektadaptern. Denna exempelapplikation kommer att simulera en finansiell organisation som övergår från användning och bearbetning av betalkort till kreditkort. Denna organisation använde ursprungligen följande betalkortsgränssnitt:



 public interface ChargeCard { 
  public void monthlyBalance(); 
  public void lateFee(); 
  public void Annualfee(); 
}

En populär typ av betalkort som denna organisations system bearbetar är plommonkortet:

 public class PlumCard implements ChargeCard { 
  private int cardNo; 
  private String customerName; 
  private double balance; 
 
  // primary constructor 
  public PlumCard(int cardNo, String customerName, double balance) { 
    this.cardNo = cardNo; 
    this.customerName = customerName; 
    this.balance = balance; 
  } 
 
  // getters and setters 
  public int getCardNo() { 
    return cardNo; 
  } 
 
  public void setCardNo(int cardNo) { 
    this.cardNo = cardNo; 
  } 
 
  public String getCustomerName() { 
    return customerName; 
  } 
 
  public void setCustomerName(String customerName) { 
    this.customerName = customerName; 
  } 
 
  public double getBalance() { 
    return balance; 
  } 
 
  public void setBalance(double balance) { 
    this.balance = balance; 
  } 
    
  @Override 
  public void monthlyBalance() { 
    System.out.println("In January " + this.customerName + " spent " + this.balance); 
  } 
 
  @Override 
  public void lateFee() { 
    System.out.println(this.customerName + " monthly latefee is .00"); 
  } 
 
  @Override 
  public void Annualfee() { 
    System.out.println(this.customerName + " annual fee is 0.00"); 
  } 
}

Denna finansiella institution går över till kreditkort och fasar ut betalkorten, så några av deras kunder har nu kreditkort:



 public interface CreditCard { 
  public void monthlyMinPayment(); 
  public void interest(); 
  public void Annualfee(); 
}

Finansinstitutets företagssystem behandlar nu bara kreditkort, eftersom det planerar att sluta använda betalkort under det kommande året. Men de flesta av deras kunder använder fortfarande betalkort. Så ingenjörerna beslutade att det var bäst att implementera en adapter tills alla deras kunder övergick till ett kreditkort.

 public class ChargeCardAdapter implements CreditCard { 
  ChargeCard chargeCard; 
 
  public ChargeCardAdapter(ChargeCard chargeCard) { 
    this.chargeCard = chargeCard; 
  } 
 
  @Override 
  public void monthlyMinPayment() { 
    this.chargeCard.monthlyBalance(); 
  } 
 
  @Override 
  public void interest() { 
    this.chargeCard.lateFee(); 
  } 
 
  @Override 
  public void Annualfee() { 
    this.chargeCard.Annualfee(); 
  }  
}

Denna ChargeCardAdapter Java klass implementerar kreditkortet Java-gränssnitt . Den anpassar ChargeCard (den anpassade), vilket ger det egenskaperna hos ett kreditkort. Till exempel kommer systemet att behandla ränteavgiften för ett kreditkort, vilket är förseningsavgiften för en betalkortskund som inte har konverterat ännu.

Fördelar med att använda adaptermönstret

Den stora fördelen med att använda adaptermönstret är att det tillåter kunder att använda nya tjänster, bibliotek och funktioner utan att ändra sin kod. Detta främjar applikationens skalbarhet.

kan jag avbryta en venmo -betalning

En annan fördel är att detta mönster också är flexibelt. Adaptermönstret tillhandahåller två implementeringsmetoder: objektadaptrar och klassadaptrar.