-Interface op basis programmering - Interface-based programming


Interface-gebaseerde programmering , ook wel interface gebaseerde architectuur , is een architecturaal patroon uitvoering modulair programmeren op component niveau een objectgeoriënteerde programmeertaal taal die niet over een modulesysteem. Een voorbeeld van een dergelijke taal Java , die (zoals 2015), heeft een modulesysteem niet op het niveau van componenten. Java een pakket systeem, maar Java softwarecomponenten bestaan typisch uit meerdere pakketten Java - en in elk geval kan grensvlak programmering voordelen verschaffen boven uitsluitend met behulp van Java-pakketten, zelfs als een component slechts uit één pakket Java.

Interface-gebaseerde programmering omschrijft het toepassingsgebied als een verzameling van componenten, waarin Application Programming Interface (API) gesprekken tussen componenten uitsluitend kunnen worden aangebracht door middel abstract interfaces niet betonklassen. Instanties van klassen in het algemeen worden verkregen via andere interfaces met technieken als Factory patroon .

Het wordt beweerd dat de verhoging modulariteit van de applicatie en daarmee de onderhoudbaarheid . Toch is enige voorzichtigheid geboden - alleen splitsen een verzoek tot willekeurig componenten communiceren via interfaces niet als zodanig minimaliseren de koppeling of hoge cohesie , twee andere attributen die gewoonlijk als sleutel voor onderhoudbaarheid worden beschouwd.

An-interface-gebaseerde architectuur kan worden gebruikt wanneer derden - of zelfs afzonderlijke teams binnen dezelfde organisatie - de ontwikkeling van extra onderdelen of plugins voor een vast systeem. De browser van de Eclipse IDE is een voorbeeld van interface gebaseerde programmering. Eclipse plug-leveranciers hebben alleen maar om componenten die de door de ouder leverancier van de toepassing, de Eclipse Foundation-interface te voldoen ontwikkelen. Sterker nog, in Eclipse, zelfs de originele onderdelen, zoals de Java Development Tools zijn zelf plugins. Dit is enigszins als een mobiele telefoon fabrikant specificeren van een mobiele laderinterface (pennenopstelling, verwacht gelijkstroom voltage, etc.) en zowel de fabrikant als derden maken van hun eigen mobiele telefoon opladers die voldoen aan deze standaard interface specificatie.

Software evolutie in-interface op basis programmering

Het gebruik van interfaces, zodat ongelijksoortige teams samen te werken roept de vraag op hoe veranderingen aan de interface gebeuren in-interface op basis programmering. Het probleem is dat wanneer een interface wordt gewijzigd, bijvoorbeeld door het toevoegen van een nieuwe methode, zal oude code geschreven naar de interface implementeren niet meer compileren - en bij dynamisch geladen of gebonden plugins, ofwel niet worden geladen link of crash tijdens de uitvoering. Er zijn twee fundamentele benaderingen voor het omgaan met dit probleem:

  1. een nieuwe interface kan worden ontwikkeld met extra functionaliteit, wat kan erven van de oude interface
  2. een softwareversies beleid zoals semantische versiebeheer 2.0 kunnen worden meegedeeld aan uitvoerders-interface, om forward-onverenigbaar, of zelfs achteruit-incompatibele mogelijk te maken, veranderingen in de toekomst "major" versies van het platform

Beide benaderingen zijn gebruikt in het Java-platform.

Design by contract

De uitgever van de interfaces belooft het algemeen dat zij de interface in nieuwe "kleine" versies van de software zal niet veranderen, en de uitvoerder, door het implementeren van de interface, houdt in dat zij ten minste de delen van de interface hebben geïmplementeerd zonder enige afwijking. Een interface kan daarom worden gezien als een "contractuele overeenkomst" - tussen een leverancier en een consument van de interface. Als deze overeenkomst meer formeel is gedocumenteerd als een software-specificatie, dit is een voorbeeld van een ontwerp van contract . Echter, design by contract per se schrijft niet voor het gebruik van interfaces voor alle componenten.

Zie ook

  • Microservices
  • actormodel
  • CORBA , een oudere componenten gebaseerd systeem voor objectgeoriënteerde software die nu zelden gebruikt om diverse redenen

Referenties