Google Guice versus JSR-299 CDI / Weld

Weld, de JSR-299 Contexts and Dependency Injection referentie-implementatie, beschouwt zichzelf als een soort opvolger van Spring en Guice.

CDI werd beïnvloed door een aantal bestaande Java-frameworks, waaronder Seam, Guice en Spring. CDI heeft echter zijn eigen, zeer uitgesproken karakter: meer typeveilig dan Seam, stateful en minder XML-centrisch dan Spring, meer geschikt voor web- en enterprise-applicaties dan Guice. Maar zonder inspiratie van de genoemde kaders en veel samenwerking en hard werken door de JSR-299 Expert Group (EG) hadden dit geen van deze kunnen zijn.

http://docs.jboss.org/ las/referentie/laatste/en-US/html/1.html

Wat maakt Weld beter geschikt voor zakelijke toepassingen in vergelijking met Guice? Zijn er voor- of nadelen ten opzichte van Guice? Wat vindt u van Guice AOP in vergelijking met Weld-interceptors? Hoe zit het met de prestaties?

Mijn keuze

Uiteindelijk heb ik besloten om Guice te gebruiken omdat ik hou van het schone programmeermodel dat naast @Inject standaard bijna geen annotaties bevat. Het is veel gemakkelijker om externe bibliotheken te gebruiken met Guice dan met CDI. AOP is ook vrij eenvoudig met Guice.

Antwoord 1, autoriteit 100%

Laat me, voordat ik probeer je vraag te beantwoorden, eerst een belangrijk stukje informatie toevoegen: JSR 330(@Inject) is gestandaardiseerd door Guice- en Spring-projecten (aankondiging van mei 2009) en wordt hergebruikt in JSR 299. Dit omvat elementaire DI-mechanismen in termen van het aangeven van een injectiepunt.

Nu terug naar de vraag – met de disclaimer dat ik veel meer ervaring heb met Spring dan met Guice.

Bedrijfsmogelijkheden in Weld

• Alternatieve configuratiemechanismenhebben een zeer strak ontwerp in JSR-299 en laten configuratiemechanismen toe buiten de Java-code (beans.xml).
• Evenementenzijn een zeer krachtig ding en past mooi bij JMS. Ik heb zojuist een Evenementenbus voor Guicegevonden, maar ik kan niet zeggen hoe dat zich verhoudt.
• Draagbare extensieszijn een SPI die kan worden gebruikt om te integreren met bestaande technologie of om legacy-code op een schone manier in te pakken.

Voordelen / Nadelen

Opmerking: ik zal proberen hier later een paar items toe te voegen, maar dit antwoord is al langer dan ik had verwacht, sorry.

• Las/CDI

  • Standaardisatie: als iets gestandaardiseerd is en er is een goede implementatie, zullen veel mensen het gebruiken. Voorbeeld: Ingebouwde scopesin Weld bieden een paar meer scopes dan Guiceof Lente. Deze kunnen allemaal worden uitgebreid, maar applicatieframeworks zullen eerder vertrouwen op standaardscopes als ze door een grote gemeenschap worden gebruikt.
  • Containerondersteuning: dit is vergelijkbaar met het vorige item, maar een belangrijk argument voor adoptie. Grote open source applicatieservers, zoals Glassfish en JBoss 6 bieden CDI-ondersteuning (zie hier).

• Gids/Lente

  • Echte applicatie: de meeste bestaande applicaties zullen al gebruik maken van Guice/Spring. Spring/Guice heeft altijd voortgebouwd op standaarden en nieuwe mogelijkheden geboden waar geen standaarden bestonden of niet konden worden gebruikt. Als u de respectieve best-practices volgt, zal het raamwerk u helpen uw toepassing op standaarden gebaseerd en schoon te maken.

AOP en Interceptors

Dit is een zeer veelbesproken onderwerp en ik kan niet de voorkeur geven aan het een boven het ander. Beide mechanismen zijn zeer krachtig, maar vereisen op zijn minst een minimum aan kennis van de architectuur van de applicatie. Kijk ook eens naar Decorateursen de eerder genoemde Evenementen. Het is het beste om de juiste tool te gebruiken, maar vergeet niet dat als een ontwikkelaar met een van deze mechanismen moet werken, het een goede zaak is als hij/zij het concept begrijpt.

Prestaties

Helaas heb ik hier nog niet naar kunnen kijken, maar er zijn een paar regels die ik probeer te volgen, vooral als ik een framework gebruik dat je veel functionaliteit geeft zonder dat je het merkt:

• Geef indien mogelijk de voorkeur aan een enkele bedradingsstap boven meerdere zoekopdrachten tijdens runtime.
• Doe indien mogelijk alle bedrading bij de initialisatie van de applicatie.
• Elke onderscheppingsstap of AOP-proxy voegt een paar methodeaanroepen toe aan de stapel.

Antwoord 2, autoriteit 38%

CDI (Weld) is nog niet op grote schaal gebruikt, dus een vergelijking is moeilijk te maken. Een paar punten:

• CDI is ontworpen met integratie met EJB3, JSF en andere JavaEE-standaarden in gedachten. CDI heeft de zogenaamde draagbare extensies waarmee bibliotheken van derden kunnen worden geïntegreerd met de levenscyclus en het interne functioneren van een CDI-implementatie
• CDI is ontworpen met alle mogelijke hoeken in gedachten, dus het is waarschijnlijk dat het alles dekt wat je nodig hebt. Spring, Guice en Seam evolueerden naar een dergelijke staat, terwijl CDI de ervaring van deze drie gebruikt.
• naar mijn mening zullen CDI-onderscheppers niet aan alle eisen kunnen voldoen waaraan Spring AOP heeft voldaan. Misschien geldt hetzelfde voor Guice AOP. Je kunt geen interceptor definiëren met de AspectJ-syntaxis.
• het ontbreken van xml-definities is zowel een voordeel als een nadeel en sommige mensen (terecht in sommige gevallen) geven de voorkeur aan xml-configuratie.
• het uitgebreide gebruik van kwalificatie-annotaties zal (naar mijn mening) grote rommel veroorzaken als het niet zorgvuldig wordt gebruikt.

Antwoord 3, autoriteit 19%

CDI voor Guice-gebruikersis een mooie vergelijking.

Antwoord 4, autoriteit 15%

Het belangrijkste kenmerk dat CDI heeft tegen Guice, is dat het een standaardonderdeel is van Java EE 6.

Het belang hiervan kan niet worden onderschat, omdat het betekent dat CDI de DI-standaard is die u moet gebruiken bij het coderen van webapplicaties.

Een tijdje terug heb ik gekeken naar de technologieën om te kunnen bepalen hoe we een standaard kerndistributie konden hebben – goed voorbereid – waar we naar believen extra modules konden toevoegen die bestaande functionaliteit konden overschrijven zonder de kernmodules te hoeven veranderen . D.w.z. voeg een extra pot toe en de functionaliteit wordt automatisch geactiveerd.

Het bleek dat de beste manier voor ons om dit te doen voor een codebasis die wordt gebruikt in zowel desktop- als webapplicaties, was om JSR-330-annotaties voor onze code te gebruiken en vervolgens CDI of Guice te gebruiken (SVN, coming real binnenkort nu in 3.0) als de motor.

Na een paar projecten heb ik gevonden dat ik de Guice-configuratie het beste leuk vind in plaats van de ondoorzichtige magie die in Lasd gebeurt. Bovendien ontdekte ik dat de manier om te doen wat we willen zoals hierboven beschreven met las, ik de klas in de extra pot moet markeren als @alternatief, en vermeld dan in Beans. XML dat ik wil dat de alternatieve klasse afgedwongen is (en dat is niet robuust tegen refactoring).

Maar alles in totaal, JSR-330 stelt ons in staat iets te doen dat eerder erg vervelend en fragiel was (omdat newzo extreem strak bindt), en dat is een geweldige overwinning. Ik kan het sterk aanbevelen om in te kijken als je zo nodig hebt.

5, Autoriteit 6%

Ik heb Guier gebruikt in een AWS Lambda-serverloze toepassing. AWS beveelt aan Guice of Dolk te gebruiken in de lente in een Lambda-functie. Zie aws lambda beste praktijken

De primaire reden is dat guier en dolk kleinere frameworks zijn en een snellere starttijd hebben, die essentieel is in Lambda.

Hoewel de OP de lente niet heeft genoemd, zijn zowel veer- als CDI / las bedoeld voor bedrijfsniveau-toepassingen, die vaak aanvullende functies vereisen dat deze kaders voorzien. Vandaar dat kleinere toepassingen, die alleen betrekking hebben op DI, Guice of Dolk is optimaal.