Perché scegliere la primavera come framework Java?

1. Panoramica

In questo articolo, esamineremo la principale proposta di valore di Spring come uno dei framework Java più popolari.

Ancora più importante, cercheremo di capire le ragioni per cui la primavera è il nostro quadro di riferimento. I dettagli della primavera e delle sue parti costitutive sono stati ampiamente trattati nei nostri tutorial precedenti. Quindi salteremo le parti introduttive del "come" e ci concentreremo principalmente sul "perché".

2. Perché utilizzare qualsiasi framework?

Prima di iniziare qualsiasi discussione in particolare su Spring, capiamo innanzitutto perché abbiamo bisogno di utilizzare qualsiasi framework in primo luogo.

Un linguaggio di programmazione generico come Java è in grado di supportare un'ampia varietà di applicazioni . Per non parlare del fatto che Java viene attivamente elaborato e migliorato ogni giorno.

Inoltre, ci sono innumerevoli librerie open source e proprietarie per supportare Java in questo senso.

Allora perché dopo tutto abbiamo bisogno di un framework? Onestamente, non è assolutamente necessario utilizzare un framework per eseguire un'attività. Tuttavia, è spesso consigliabile utilizzarne uno per diversi motivi:

  • Ci aiuta a concentrarci sul compito principale piuttosto che sul boilerplate ad esso associato
  • Riunisce anni di saggezza sotto forma di modelli di design
  • Ci aiuta ad aderire agli standard di settore e normativi
  • Riduce il costo totale di proprietà dell'applicazione

Abbiamo appena scalfito la superficie qui e dobbiamo dire che i vantaggi sono difficili da ignorare. Ma non può essere tutto positivo, quindi qual è il problema:

  • Ci obbliga a scrivere un'applicazione in un modo specifico
  • Si lega a una versione specifica del linguaggio e delle librerie
  • Si aggiunge all'impronta delle risorse dell'applicazione

Francamente, non ci sono punti salienti nello sviluppo del software e le strutture non fanno certo eccezione. Quindi la scelta di quale framework o nessuno dovrebbe essere guidata dal contesto.

Si spera che saremo in una posizione migliore per prendere questa decisione rispetto a Spring in Java entro la fine di questo articolo.

3. Breve panoramica dell'ecosistema primaverile

Prima di iniziare la nostra valutazione qualitativa di Spring Framework, diamo uno sguardo più da vicino a come si presenta l'ecosistema Spring.

La primavera è nata da qualche parte nel 2003, in un momento in cui Java Enterprise Edition si stava evolvendo rapidamente e lo sviluppo di un'applicazione aziendale era eccitante ma comunque noioso!

La primavera è nata come un contenitore IoC (Inversion of Control) per Java. Ci riferiamo ancora principalmente alla primavera e, di fatto, costituisce il nucleo del framework e di altri progetti che sono stati sviluppati su di esso.

3.1. Quadro di primavera

Il framework Spring è diviso in moduli che lo rendono davvero facile da scegliere e scegliere in parti da utilizzare in qualsiasi applicazione:

  • Core: fornisce funzionalità di base come DI (Dependency Injection), Internationalization, Validation e AOP (Aspect Oriented Programming)
  • Accesso ai dati: supporta l'accesso ai dati tramite JTA (Java Transaction API), JPA (Java Persistence API) e JDBC (Java Database Connectivity)
  • Web: supporta sia l'API Servlet (Spring MVC) che la recente API Reactive (Spring WebFlux) e inoltre supporta WebSocket, STOMP e WebClient
  • Integrazione: supporta l'integrazione con Enterprise Java tramite JMS (Java Message Service), JMX (Java Management Extension) e RMI (Remote Method Invocation)
  • Test: ampio supporto per test di unità e integrazione tramite oggetti mock, dispositivi di test, gestione del contesto e cache

3.2. Progetti di primavera

Ma ciò che rende la primavera molto più preziosa è un ecosistema forte che è cresciuto intorno ad essa nel corso degli anni e che continua ad evolversi attivamente . Questi sono strutturati come progetti Spring sviluppati sulla base del framework Spring.

Sebbene l'elenco dei progetti primaverili sia lungo e continui a cambiare, ce ne sono alcuni che vale la pena menzionare:

  • Boot: ci fornisce una serie di template altamente supponenti ma estensibili per creare vari progetti basati su Spring in pochissimo tempo. Rende davvero facile creare applicazioni Spring autonome con Tomcat incorporato o un contenitore simile.
  • Cloud: fornisce supporto per sviluppare facilmente alcuni dei modelli di sistema distribuito comuni come il rilevamento del servizio, l'interruttore di circuito e il gateway API. Ci aiuta a ridurre gli sforzi per distribuire tali modelli standard in piattaforme locali, remote o persino gestite.
  • Sicurezza: fornisce un robusto meccanismo per sviluppare l'autenticazione e l'autorizzazione per i progetti basati su Spring in modo altamente personalizzabile. Con un supporto dichiarativo minimo, otteniamo protezione contro attacchi comuni come la correzione della sessione, il click-jacking e la contraffazione di richieste tra siti.
  • Mobile: fornisce funzionalità per rilevare il dispositivo e adattare di conseguenza il comportamento dell'applicazione. Inoltre, supporta la gestione della vista in grado di riconoscere il dispositivo per un'esperienza utente ottimale, la gestione delle preferenze del sito e il selettore di siti.
  • Batch: fornisce un framework leggero per lo sviluppo di applicazioni batch per sistemi aziendali come l'archiviazione dei dati. Ha un supporto intuitivo per la pianificazione, il riavvio, il salto, la raccolta di metriche e la registrazione. Inoltre, supporta la scalabilità per i lavori ad alto volume attraverso l'ottimizzazione e il partizionamento.

Inutile dire che questa è un'introduzione piuttosto astratta a ciò che la primavera ha da offrire. Ma ci fornisce abbastanza terreno rispetto all'organizzazione e all'ampiezza di Spring per portare avanti la nostra discussione.

4. Primavera in azione

È consuetudine aggiungere un programma hello-world per comprendere qualsiasi nuova tecnologia.

Vediamo come la primavera può rendere un gioco da ragazzi scrivere un programma che fa più di un semplice ciao-mondo . Creeremo un'applicazione che esporrà le operazioni CRUD come API REST per un'entità di dominio come Employee supportata da un database in memoria. Inoltre, proteggeremo i nostri endpoint di mutazione utilizzando l'autenticazione di base. Infine, nessuna applicazione può essere davvero completa senza buoni e vecchi unit test.

4.1. Configurazione del progetto

Configureremo il nostro progetto Spring Boot utilizzando Spring Initializr, che è un comodo strumento online per avviare progetti con le giuste dipendenze. Aggiungeremo Web, JPA, H2 e Security come dipendenze del progetto per ottenere correttamente la configurazione di Maven.

Maggiori dettagli sul bootstrap sono disponibili in uno dei nostri articoli precedenti.

4.2. Modello di dominio e persistenza

With so little to be done, we are already ready to define our domain model and persistence.

Let's first define the Employee as a simple JPA entity:

@Entity public class Employee { @Id @GeneratedValue(strategy = GenerationType.AUTO) private Long id; @NotNull private String firstName; @NotNull private String lastName; // Standard constructor, getters and setters }

Note the auto-generated id we've included in our entity definition.

Now we have to define a JPA repository for our entity. This is where Spring makes it really simple:

public interface EmployeeRepository extends CrudRepository { List findAll(); }

All we have to do is define an interface like this, and Spring JPA will provide us with an implementation fleshed out with default and custom operations. Quite neat! Find more details on working with Spring Data JPA in our other articles.

4.3. Controller

Now we have to define a web controller to route and handle our incoming requests:

@RestController public class EmployeeController { @Autowired private EmployeeRepository repository; @GetMapping("/employees") public List getEmployees() { return repository.findAll(); } // Other CRUD endpoints handlers }

Really, all we had to do was annotate the class and define routing meta information along with each handler method.

Working with Spring REST controllers is covered in great details in our previous article.

4.4. Security

So we have defined everything now, but what about securing operations like create or delete employees? We don't want unauthenticated access to those endpoints!

Spring Security really shines in this area:

@EnableWebSecurity public class WebSecurityConfig extends WebSecurityConfigurerAdapter { @Override protected void configure(HttpSecurity http) throws Exception { http .authorizeRequests() .antMatchers(HttpMethod.GET, "/employees", "/employees/**") .permitAll() .anyRequest() .authenticated() .and() .httpBasic(); } // other necessary beans and definitions }

There are more details here which require attention to understand but the most important point to note is the declarative manner in which we have only allowed GET operations unrestricted.

4.5. Testing

Now we' have done everything, but wait, how do we test this?

Let's see if Spring can make it easy to write unit tests for REST controllers:

@RunWith(SpringRunner.class) @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT) @AutoConfigureMockMvc public class EmployeeControllerTests { @Autowired private MockMvc mvc; @Test @WithMockUser() public void givenNoEmployee_whenCreateEmployee_thenEmployeeCreated() throws Exception { mvc.perform(post("/employees").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"))); } // other tests as necessary }

As we can see, Spring provides us with the necessary infrastructure to write simple unit and integration tests which otherwise depend on the Spring context to be initialized and configured.

4.6. Running the Application

Finally, how do we run this application? This is another interesting aspect of Spring Boot. Although we can package this as a regular application and deploy traditionally on a Servlet container.

But where is fun this that! Spring Boot comes with an embedded Tomcat server:

@SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } }

This is a class which comes pre-created as part of the bootstrap and has all the necessary details to start this application using the embedded server.

Moreover, this is highly customizable.

5. Alternatives to Spring

While choosing to use a framework is relatively easier, choosing between frameworks can often be daunting with the choices we have. But for that, we must have at least a rough understanding of what alternatives are there for the features that Spring has to offer.

As we discussed previously, the Spring framework together with its projects offer a wide choice for an enterprise developer to pick from. If we do a quick assessment of contemporary Java frameworks, they don't even come close to the ecosystem that Spring provides us.

However, for specific areas, they do form a compelling argument to pick as alternatives:

  • Guice: Offers a robust IoC container for Java applications
  • Play: Quite aptly fits in as a Web framework with reactive support
  • Hibernate: An established framework for data access with JPA support

Other than these there are some recent additions that offer wider support than a specific domain but still do not cover everything that Spring has to offer:

  • Micronaut: A JVM-based framework tailored towards cloud-native microservices
  • Quarkus: A new age Java stack which promises to deliver faster boot time and a smaller footprint

Obviously, it's neither necessary nor feasible to iterate over the list completely but we do get the broad idea here.

6. So, Why Choose Spring?

Finally, we've built all the required context to address our central question, why Spring? We understand the ways a framework can help us in developing complex enterprise applications.

Moreover, we do understand the options we've got for specific concerns like web, data access, integration in terms of framework, especially for Java.

Now, where does Spring shine among all these? Let's explore.

6.1. Usability

One of the key aspects of any framework's popularity is how easy it is for developers to use it. Spring through multiple configuration options and Convention over Configuration makes it really easy for developers to start and then configure exactly what they need.

Projects like Spring Boot have made bootstrapping a complex Spring project almost trivial. Not to mention, it has excellent documentation and tutorials to help anyone get on-boarded.

6.2. Modularity

Another key aspect of Spring's popularity is its highly modular nature. We've options to use the entire Spring framework or just the modules necessary. Moreover, we can optionally include one or more Spring projects depending upon the need.

What's more, we've got the option to use other frameworks like Hibernate or Struts as well!

6.3. Conformance

Although Spring does not support all of Jakarta EE specifications, it supports all of its technologies, often improving the support over the standard specification where necessary. For instance, Spring supports JPA based repositories and hence makes it trivial to switch providers.

Moreover, Spring supports industry specifications like Reactive Stream under Spring Web Reactive and HATEOAS under Spring HATEOAS.

6.4. Testability

Adoption of any framework largely also depends on the fact that how easy it is to test the application built on top of it. Spring at the core advocates and supports Test Driven Development (TDD).

Spring application is mostly composed of POJOs which naturally makes unit testing relatively much simpler. However, Spring does provide Mock Objects for scenarios like MVC where unit testing gets complicated otherwise.

6.5 Maturity

Spring has a long history of innovation, adoption, and standardization. Over the years, it's become mature enough to become a default solution for most common problems faced in the development of large scale enterprise applications.

What's even more exciting is how actively it's being developed and maintained. Support for new language features and enterprise integration solutions are being developed every day.

6.6. Community Support

Last but not least, any framework or even library survive the industry through innovation and there's no better place for innovation than the community. Spring is an open source led by Pivotal Software and backed by a large consortium of organizations and individual developers.

This has meant that it remains contextual and often futuristic, as evident by the number of projects under its umbrella.

7. Reasons Not to Use Spring

There is a wide variety of application which can benefit from a different level of Spring usage, and that is changing as fast as Spring is growing.

However, we must understand that Spring like any other framework is helpful in managing the complexity of application development. It helps us to avoid common pitfalls and keeps the application maintainable as it grows over time.

This comes at the cost of an additional resource footprint and learning curve, however small that may be. If there is really an application which is simple enough and not expected to grow complex, perhaps it may benefit more to not use any framework at all!

8. Conclusion

In this article, we discussed the benefits of using a framework in application development. We further discussed briefly Spring Framework in particular.

While on the subject, we also looked into some of the alternate frameworks available for Java.

Infine, abbiamo discusso i motivi che possono spingerci a scegliere Spring come framework di scelta per Java.

Tuttavia, dovremmo concludere questo articolo con una nota di consiglio. Per quanto convincente possa sembrare, di solito non esiste un'unica soluzione valida per tutti nello sviluppo del software.

Quindi, dobbiamo applicare la nostra saggezza nella selezione della più semplice delle soluzioni per i problemi specifici che miriamo a risolvere.