Waarom kiezen voor Spring als uw Java Framework?

1. Overzicht

In dit artikel bespreken we de belangrijkste waardepropositie van Spring als een van de meest populaire Java-frameworks.

Wat nog belangrijker is, we zullen proberen de redenen te begrijpen waarom Spring ons voorkeurskader is. Details van Spring en zijn samenstellende onderdelen zijn uitgebreid behandeld in onze vorige tutorials. Daarom slaan we de inleidende "hoe" -gedeelten over en concentreren we ons voornamelijk op "waarom" -gedeelten.

2. Waarom een ​​framework gebruiken?

Voordat we met een discussie beginnen, in het bijzonder over Spring, moeten we eerst begrijpen waarom we überhaupt een raamwerk moeten gebruiken.

EEN programmeertaal voor algemene doeleinden, zoals Java, kan een breed scala aan toepassingen ondersteunen. Om nog maar te zwijgen van het feit dat er actief aan Java wordt gewerkt en elke dag wordt verbeterd.

Bovendien zijn er talloze open source en propriëtaire bibliotheken die Java in dit opzicht ondersteunen.

Waarom hebben we dan toch een raamwerk nodig? Eerlijk gezegd is het niet absoluut noodzakelijk om een ​​raamwerk te gebruiken om een ​​taak te volbrengen. Maar het is vaak raadzaam om er een te gebruiken om verschillende redenen:

  • Helpt ons focus op de kerntaak in plaats van op de boilerplate ermee geassocieerd
  • Brengt jarenlange wijsheid samen in de vorm van ontwerppatronen
  • Helpt ons om te voldoen aan de branchenormen en wettelijke normen
  • Verlaagt de totale eigendomskosten voor de applicatie

We hebben hier net de oppervlakte bekrast en we moeten zeggen dat de voordelen moeilijk te negeren zijn. Maar het kunnen niet allemaal positieve dingen zijn, dus wat is het addertje onder het gras:

  • Dwingt ons om schrijf een applicatie op een specifieke manier
  • Bindt aan een specifieke versie van taal en bibliotheken
  • Voegt toe aan de resource footprint van de applicatie

Eerlijk gezegd zijn er geen zilveren kogels in softwareontwikkeling en frameworks zijn daar zeker geen uitzondering op. Dus de keuze van welk raamwerk of geen raamwerk moet worden gedreven vanuit de context.

Hopelijk zijn we aan het einde van dit artikel in een betere positie om deze beslissing te nemen met betrekking tot Spring in Java.

3. Kort overzicht van Spring Ecosystem

Laten we, voordat we beginnen met onze kwalitatieve beoordeling van Spring Framework, eens nader bekijken hoe het Spring-ecosysteem eruitziet.

De lente is ergens in 2003 ontstaan in een tijd waarin Java Enterprise Edition snel evolueerde en het ontwikkelen van een bedrijfstoepassing opwindend maar toch vervelend was!

Spring begon als een Inversion of Control (IoC) -container voor Java. We relateren Spring er nog grotendeels aan en in feite vormt het de kern van het framework en andere projecten die er bovenop zijn ontwikkeld.

3.1. Spring Framework

Het veerraamwerk is onderverdeeld in modules, waardoor het heel gemakkelijk is om onderdelen te kiezen en te gebruiken in elke toepassing:

  • Kern: biedt kernfuncties zoals DI (Dependency Injection), Internationalization, Validation en AOP (Aspect Oriented Programming)
  • Gegevenstoegang: ondersteunt gegevenstoegang via JTA (Java Transaction API), JPA (Java Persistence API) en JDBC (Java Database Connectivity)
  • Web: ondersteunt zowel Servlet API (Spring MVC) als recent Reactive API (Spring WebFlux), en ondersteunt bovendien WebSockets, STOMP en WebClient
  • Integratie: ondersteunt integratie met Enterprise Java via JMS (Java Message Service), JMX (Java Management Extension) en RMI (Remote Method Invocation)
  • Testen: brede ondersteuning voor unit- en integratietests via mock-objecten, testopstellingen, contextbeheer en caching

3.2. Lente projecten

Maar wat Spring veel waardevoller maakt, is een sterk ecosysteem dat er in de loop der jaren omheen is gegroeid en dat actief blijft evolueren. Deze zijn gestructureerd als Spring-projecten die bovenop het Spring-raamwerk worden ontwikkeld.

Hoewel de lijst met voorjaarsprojecten lang is en steeds verandert, zijn er een paar die het vermelden waard zijn:

  • Opstarten: biedt ons een set zeer eigenzinnige maar uitbreidbare sjablonen om in een mum van tijd verschillende projecten op basis van Spring te maken. Het maakt het heel eenvoudig om stand-alone Spring-applicaties te maken met ingesloten Tomcat of een vergelijkbare container.
  • Cloud: biedt ondersteuning om eenvoudig enkele van de algemene gedistribueerde systeempatronen te ontwikkelen, zoals service-detectie, stroomonderbreker en API-gateway. Het helpt ons de moeite te verminderen om dergelijke standaardpatronen in lokale, externe of zelfs beheerde platforms te implementeren.
  • Beveiliging: biedt een robuust mechanisme om authenticatie en autorisatie voor projecten op basis van Spring op een zeer aanpasbare manier te ontwikkelen. Met minimale declaratieve ondersteuning krijgen we bescherming tegen veelvoorkomende aanvallen zoals sessiefixatie, click-jacking en cross-site verzoekvervalsing.
  • Mobiel: biedt mogelijkheden om het apparaat te detecteren en het applicatiegedrag dienovereenkomstig aan te passen. Ondersteunt bovendien apparaatbewust weergavebeheer voor een optimale gebruikerservaring, beheer van sitevoorkeuren en site-switcher.
  • Batch: biedt een lichtgewicht raamwerk voor het ontwikkelen van batchtoepassingen voor bedrijfssystemen zoals gegevensarchivering. Heeft intuïtieve ondersteuning voor plannen, herstarten, overslaan, statistieken verzamelen en loggen. Bovendien ondersteunt het opschalen voor taken met een hoog volume door middel van optimalisatie en partitionering.

Het behoeft geen betoog dat dit een vrij abstracte introductie is van wat Spring te bieden heeft. Maar het geeft ons voldoende grond met betrekking tot de organisatie en breedte van Spring om onze discussie verder te brengen.

4. Lente in actie

Het is gebruikelijk om een ​​hello-world-programma toe te voegen om nieuwe technologie te begrijpen.

Laten we eens kijken hoe De lente kan het een makkie maken om een ​​programma te schrijven dat meer doet dan alleen hallo-wereld. We zullen een applicatie maken die CRUD-bewerkingen als REST-API's voor een domeinentiteit zoals Employee, ondersteund door een in-memory database, blootstelt. Bovendien beschermen we onze mutatie-eindpunten met behulp van basisauth. Ten slotte kan geen enkele applicatie echt compleet zijn zonder goede, oude unit tests.

4.1. Projectopzet

We zullen ons Spring Boot-project opzetten met Spring Initializr, een handige online tool om projecten met de juiste afhankelijkheden op te starten. We zullen Web, JPA, H2 en Security toevoegen als projectafhankelijkheden om de Maven-configuratie correct te krijgen.

Meer informatie over bootstrapping is beschikbaar in een van onze vorige artikelen.

4.2. Domeinmodel en persistentie

Met zo weinig te doen, zijn we al klaar om ons domeinmodel en persistentie te definiëren.

Laten we eerst de Werknemer als een eenvoudige PPV-entiteit:

@Entity openbare klasse Medewerker {@Id @GeneratedValue (strategie = GenerationType.AUTO) privé Lange id; @NotNull private String firstName; @NotNull private String achternaam; // Standaard constructor, getters en setters}

Let op de automatisch gegenereerde id die we in onze entiteitsdefinitie hebben opgenomen.

Nu moeten we een JPA-repository voor onze entiteit definiëren. Dit is waar de lente het heel eenvoudig maakt:

openbare interface EmployeeRepository breidt CrudRepository {List findAll (); }

Het enige wat we hoeven te doen is een interface als deze te definiëren, en Spring JPA biedt ons een implementatie die is uitgewerkt met standaard- en aangepaste bewerkingen. Helemaal netjes! Meer informatie over het werken met Spring Data JPA vindt u in onze andere artikelen.

4.3. Controller

Nu moeten we een webcontroller definiëren om onze inkomende verzoeken te routeren en af ​​te handelen:

@RestController openbare klasse EmployeeController {@Autowired privé EmployeeRepository-repository; @GetMapping ("/ workers") openbare lijst getEmployees () {return repository.findAll (); } // Andere handlers voor CRUD-eindpunten}

Eigenlijk hoefden we alleen maar te doen annoteer de klasse en definieer de meta-informatie van de routering samen met elke handlermethode.

Werken met Spring REST-controllers wordt in ons vorige artikel uitvoerig behandeld.

4.4. Veiligheid

Dus we hebben nu alles gedefinieerd, maar hoe zit het met het beveiligen van bewerkingen zoals het aanmaken of verwijderen van medewerkers? We willen geen ongeautoriseerde toegang tot die eindpunten!

Spring Security schittert op dit gebied echt:

@EnableWebSecurity openbare klasse WebSecurityConfig breidt WebSecurityConfigurerAdapter uit {@Override protected void configure (HttpSecurity http) genereert Uitzondering {http .authorizeRequests () .antMatchers (HttpMethod.GET, "/ workers", "/ workers / **") .permit. anyRequest () .authenticated (). en () .httpBasic (); } // andere noodzakelijke bonen en definities}

Er zijn hier meer details die aandacht vereisen om te begrijpen, maar het belangrijkste punt om op te merken is de declaratieve manier waarop we alleen GET-bewerkingen onbeperkt hebben toegestaan.

4.5. Testen

Nu hebben we alles gedaan, maar wacht, hoe testen we dit?

Laten we eens kijken of Spring het gemakkelijk kan maken om unit-tests voor REST-controllers te schrijven:

@RunWith (SpringRunner.class) @SpringBootTest (webEnvironment = WebEnvironment.RANDOM_PORT) @AutoConfigureMockMvc openbare klasse EmployeeControllerTests {@Autowired privé MockMvc mvc; @Test @WithMockUser () public void givenNoEmployee_whenCreateEmployee_thenEmployeeCreated () genereert uitzondering {mvc.perform (post ("/ workers"). Content (new ObjectMapper (). WriteValueAsString (new Employee ("First", "Last")) .with ( csrf ())) .contentType (MediaType.APPLICATION_JSON) .accept (MediaType.APPLICATION_JSON)) .andExpect (MockMvcResultMatchers.status () .isCreated ()) .andExpect (jsonPath ("$. firstName", is ("First") )) .andExpect (jsonPath ("$. lastName", is ("Last"))); } // andere tests indien nodig}

Zoals we kunnen zien, Spring biedt ons de nodige infrastructuur om eenvoudige unit- en integratietests te schrijven die anders afhangen van de Spring-context die moet worden geïnitialiseerd en geconfigureerd.

4.6. De applicatie uitvoeren

Tot slot, hoe voeren we deze applicatie uit? Dit is een ander interessant aspect van Spring Boot. Hoewel we dit als een reguliere applicatie kunnen verpakken en traditioneel op een Servlet-container kunnen implementeren.

Maar waar is dit nou zo leuk! Spring Boot wordt geleverd met een ingebouwde Tomcat-server:

@SpringBootApplication openbare klasse Toepassing {openbare statische leegte hoofd (String [] args) {SpringApplication.run (Application.class, args); }}

Dit is een klasse die vooraf aangemaakt is als onderdeel van de bootstrap en die alle benodigde details heeft om deze applicatie te starten met de embedded server.

Bovendien is dit in hoge mate aanpasbaar.

5. Alternatieven voor de lente

Hoewel de keuze om een ​​raamwerk te gebruiken relatief eenvoudiger is, kan het kiezen tussen raamwerken vaak ontmoedigend zijn met de keuzes die we hebben. Maar daarvoor moeten we op zijn minst een globaal begrip hebben van welke alternatieven er zijn voor de functies die Spring te bieden heeft.

Zoals we eerder hebben besproken, Het Spring-framework biedt samen met zijn projecten een ruime keuze voor een enterprise-ontwikkelaar om uit te kiezen. Als we de hedendaagse Java-frameworks snel beoordelen, komen ze niet eens in de buurt van het ecosysteem dat Spring ons biedt.

Voor specifieke gebieden vormen ze echter een overtuigend argument om als alternatief te kiezen:

  • Guice: biedt een robuuste IoC-container voor Java-toepassingen
  • Spelen: Past heel treffend als een webraamwerk met reactieve ondersteuning
  • Slaapstand: een gevestigd raamwerk voor gegevenstoegang met JPA-ondersteuning

Behalve deze zijn er enkele recente toevoegingen die bredere ondersteuning bieden dan een specifiek domein, maar nog steeds niet alles dekken wat Spring te bieden heeft:

  • Micronaut: een op JVM gebaseerd framework dat is afgestemd op cloud-native microservices
  • Quarkus: een new age Java-stack die belooft een snellere opstarttijd en een kleinere footprint te bieden

Het is duidelijk dat het niet nodig of haalbaar is om de lijst volledig te herhalen, maar we krijgen hier wel het algemene idee.

6. Dus, waarom kiezen voor de lente?

Ten slotte hebben we alle benodigde context opgebouwd om onze centrale vraag aan te pakken: waarom lente? We begrijpen de manieren waarop een raamwerk ons ​​kan helpen bij het ontwikkelen van complexe bedrijfstoepassingen.

Bovendien begrijpen we de opties die we hebben voor specifieke problemen zoals web, gegevenstoegang, integratie in termen van framework, vooral voor Java.

Nu, waar schijnt de lente tussen al deze? Laten we onderzoeken.

6.1. Bruikbaarheid

Een van de belangrijkste aspecten van de populariteit van elk framework is hoe gemakkelijk het voor ontwikkelaars is om het te gebruiken. Spring door meerdere configuratie-opties en Convention over Configuration maakt het heel gemakkelijk voor ontwikkelaars om te starten en vervolgens precies te configureren wat ze nodig hebben.

Projecten zoals Spring Boot heeft het opstarten van een complex Spring-project bijna triviaal gemaakt. Om nog maar te zwijgen, het heeft uitstekende documentatie en tutorials om iedereen te helpen aan boord te komen.

6.2. Modulariteit

Een ander belangrijk aspect van de populariteit van Spring is het zeer modulaire karakter ervan. We hebben opties om het volledige Spring-framework of alleen de benodigde modules te gebruiken. Bovendien kunnen we voeg eventueel een of meer voorjaarsprojecten toe afhankelijk van de behoefte.

Bovendien hebben we de mogelijkheid om ook andere frameworks te gebruiken, zoals Hibernate of Struts!

6.3. Conformiteit

Hoewel Spring ondersteunt niet alle Jakarta EE-specificaties, het ondersteunt al zijn technologieën, waarbij de ondersteuning waar nodig vaak wordt verbeterd ten opzichte van de standaardspecificatie. Spring ondersteunt bijvoorbeeld op JPA gebaseerde repositories en maakt het daarom triviaal om van provider te wisselen.

Bovendien ondersteunt Spring branchespecificaties zoals Reactive Stream onder Spring Web Reactive en HATEOAS onder Spring HATEOAS.

6.4. Testbaarheid

De acceptatie van elk framework hangt grotendeels ook af van het feit dat het gemakkelijk is om de applicatie die erop is gebouwd te testen. Lente in de kern pleit voor en ondersteunt Test Driven Development (TDD).

De veerapplicatie bestaat meestal uit POJO's, wat het testen van eenheden natuurlijk relatief veel eenvoudiger maakt. Spring biedt echter wel Mock Objects voor scenario's zoals MVC, waar het testen van eenheden anders gecompliceerd wordt.

6.5 Looptijd

Spring heeft een lange geschiedenis van innovatie, adoptie en standaardisatie. Door de jaren heen is het geworden volwassen genoeg om een ​​standaardoplossing te worden voor de meest voorkomende problemen geconfronteerd bij de ontwikkeling van grootschalige bedrijfsapplicaties.

Wat nog spannender is, is hoe actief het wordt ontwikkeld en onderhouden. Ondersteuning voor nieuwe taalfuncties en bedrijfsintegratieoplossingen wordt elke dag ontwikkeld.

6.6. Maatschappelijke hulp

Last but not least, elk raamwerk of zelfs elke bibliotheek overleeft de branche door middel van innovatie en er is geen betere plek voor innovatie dan de gemeenschap. De lente is een open source geleid door Pivotal Software en ondersteund door een groot consortium van organisaties en individuele ontwikkelaars.

Dit heeft ertoe geleid dat het contextueel en vaak futuristisch blijft, zoals blijkt uit het aantal projecten onder zijn paraplu.

7. Redenen Niet om de lente te gebruiken

Er is een grote verscheidenheid aan toepassingen die kunnen profiteren van een ander niveau van voorjaarsgebruik, en dat verandert net zo snel als de lente groeit.

We moeten echter begrijpen dat Spring, net als elk ander framework, nuttig is bij het beheren van de complexiteit van applicatieontwikkeling. Het helpt ons om veelvoorkomende valkuilen te vermijden en houdt de applicatie onderhoudbaar naarmate deze in de loop van de tijd groeit.

Dit gaat ten koste van een extra voetafdruk en leercurve, hoe klein dat ook mag zijn. Als er echt een applicatie is die eenvoudig genoeg is en waarvan niet verwacht wordt dat deze complex wordt, kan het misschien beter zijn om helemaal geen framework te gebruiken!

8. Conclusie

In dit artikel hebben we de voordelen besproken van het gebruik van een framework bij applicatieontwikkeling. In het bijzonder hebben we het Spring Framework verder kort besproken.

Terwijl we het over het onderwerp hadden, hebben we ook gekeken naar enkele van de alternatieve frameworks die beschikbaar zijn voor Java.

Ten slotte hebben we de redenen besproken die ons kunnen dwingen om Spring te kiezen als het raamwerk bij uitstek voor Java.

We zouden dit artikel echter moeten eindigen met een advies. Hoe overtuigend het ook mag klinken, er is meestal geen eenduidige oplossing die voor iedereen geschikt is in softwareontwikkeling.

Daarom moeten we onze wijsheid toepassen bij het selecteren van de eenvoudigste oplossingen voor de specifieke problemen die we willen oplossen.