Pourquoi choisir Spring comme framework Java?

1. Vue d'ensemble

Dans cet article, nous allons passer en revue la principale proposition de valeur de Spring en tant que l'un des frameworks Java les plus populaires.

Plus important encore, nous essaierons de comprendre les raisons pour lesquelles Spring est notre cadre de choix. Les détails de Spring et de ses composants ont été largement couverts dans nos précédents tutoriels. Par conséquent, nous allons sauter les parties d'introduction «comment» et nous concentrerons principalement sur les «pourquoi».

2. Pourquoi utiliser n'importe quel framework?

Avant de commencer une discussion en particulier sur Spring, comprenons d'abord pourquoi nous devons utiliser un cadre quelconque en premier lieu.

Un langage de programmation à usage général comme Java est capable de prendre en charge une grande variété d'applications . Sans oublier que Java est activement travaillé et s'améliore chaque jour.

De plus, il existe d'innombrables bibliothèques open source et propriétaires pour prendre en charge Java à cet égard.

Alors pourquoi avons-nous besoin d'un cadre après tout? Honnêtement, il n'est pas absolument nécessaire d'utiliser un cadre pour accomplir une tâche. Mais, il est souvent conseillé d'en utiliser un pour plusieurs raisons:

  • Nous aide à nous concentrer sur la tâche principale plutôt que sur le passe-partout qui lui est associé
  • Réunit des années de sagesse sous la forme de modèles de conception
  • Nous aide à respecter les normes industrielles et réglementaires
  • Réduit le coût total de possession de l'application

Nous venons de gratter la surface ici et nous devons dire que les avantages sont difficiles à ignorer. Mais tout ne peut pas être positif, alors quel est le problème:

  • Nous oblige à rédiger une application de manière spécifique
  • Se lie à une version spécifique du langage et des bibliothèques
  • Ajoute à l'empreinte de ressources de l'application

Franchement, il n'y a pas de solution miracle dans le développement de logiciels et les frameworks ne font certainement pas exception à cela. Ainsi, le choix de quel cadre ou aucun cadre doit être déterminé par le contexte.

Espérons que nous serons mieux placés pour prendre cette décision en ce qui concerne Spring in Java d'ici la fin de cet article.

3. Bref aperçu de l'écosystème printanier

Avant de commencer notre évaluation qualitative de Spring Framework, examinons de plus près à quoi ressemble l'écosystème Spring.

Spring a vu le jour quelque part en 2003 à un moment où Java Enterprise Edition évoluait rapidement et le développement d'une application d'entreprise était passionnant mais néanmoins fastidieux!

Spring a commencé comme un conteneur d'inversion de contrôle (IoC) pour Java. Nous y rattachons toujours principalement Spring et en fait, il forme le noyau du framework et d'autres projets qui ont été développés en plus.

3.1. Cadre de printemps

Spring Framework est divisé en modules, ce qui facilite la sélection et le choix des parties à utiliser dans n'importe quelle application:

  • Noyau: fournit des fonctionnalités de base telles que DI (injection de dépendances), internationalisation, validation et AOP (programmation orientée aspect)
  • Accès aux données: prend en charge l'accès aux données via JTA (Java Transaction API), JPA (Java Persistence API) et JDBC (Java Database Connectivity)
  • Web: prend en charge à la fois l'API Servlet (Spring MVC) et de l'API réactive récemment (Spring WebFlux), et prend en charge également WebSockets, STOMP et WebClient
  • Intégration: prend en charge l'intégration à Enterprise Java via JMS (Java Message Service), JMX (Java Management Extension) et RMI (Remote Method Invocation)
  • Test: prise en charge étendue des tests unitaires et d'intégration via des objets simulés, des montages de test, la gestion du contexte et la mise en cache

3.2. Projets de printemps

Mais ce qui rend le printemps beaucoup plus précieux, c'est un écosystème solide qui s'est développé autour de lui au fil des ans et qui continue d'évoluer activement . Ceux-ci sont structurés comme des projets Spring qui sont développés au-dessus du framework Spring.

Bien que la liste des projets de printemps soit longue et qu'elle ne cesse de changer, quelques-uns méritent d'être mentionnés:

  • Boot: nous fournit un ensemble de modèles hautement avisés mais extensibles pour créer divers projets basés sur Spring en un rien de temps. Il est très facile de créer des applications Spring autonomes avec Tomcat intégré ou un conteneur similaire.
  • Cloud: fournit une assistance pour développer facilement certains des modèles de systèmes distribués courants tels que la découverte de services, le disjoncteur et la passerelle API. Cela nous aide à réduire l'effort de déploiement de tels modèles standard sur des plates-formes locales, distantes ou même gérées.
  • Sécurité: fournit un mécanisme robuste pour développer l'authentification et l'autorisation pour les projets basés sur Spring d'une manière hautement personnalisable. Avec un support déclaratif minimal, nous bénéficions d'une protection contre les attaques courantes telles que la fixation de session, le clic-jacking et la falsification de requêtes intersites.
  • Mobile: fournit des capacités pour détecter l'appareil et adapter le comportement de l'application en conséquence. En outre, prend en charge la gestion des vues prenant en charge les appareils pour une expérience utilisateur optimale, la gestion des préférences de site et le sélecteur de site.
  • Batch: fournit un cadre léger pour le développement d'applications par lots pour les systèmes d'entreprise tels que l'archivage des données. Prise en charge intuitive pour la planification, le redémarrage, le saut, la collecte de métriques et la journalisation. En outre, prend en charge la mise à l'échelle pour les travaux à volume élevé grâce à l'optimisation et au partitionnement.

Inutile de dire que c'est une introduction assez abstraite à ce que Spring a à offrir. Mais cela nous fournit suffisamment de terrain en ce qui concerne l'organisation et l'ampleur de Spring pour faire avancer notre discussion.

4. Le printemps en action

Il est de coutume d'ajouter un programme hello-world pour comprendre toute nouvelle technologie.

Voyons comment Spring peut en faire un jeu d'enfant pour écrire un programme qui fait plus que simplement bonjour le monde . Nous allons créer une application qui exposera les opérations CRUD en tant qu'API REST pour une entité de domaine telle que Employee soutenue par une base de données en mémoire. De plus, nous protégerons nos points de terminaison de mutation à l'aide de l'authentification de base. Enfin, aucune application ne peut vraiment être complète sans de bons et anciens tests unitaires.

4.1. Mise en place du projet

Nous allons configurer notre projet Spring Boot à l'aide de Spring Initializr, qui est un outil en ligne pratique pour démarrer des projets avec les bonnes dépendances. Nous ajouterons Web, JPA, H2 et Security en tant que dépendances de projet pour que la configuration de Maven soit correctement configurée.

Plus de détails sur le bootstrapping sont disponibles dans l'un de nos articles précédents.

4.2. Modèle de domaine et persistance

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.

Enfin, nous avons discuté des raisons qui peuvent nous contraindre à choisir Spring comme framework de choix pour Java.

Nous devrions cependant terminer cet article par une note de conseil. Aussi convaincant que cela puisse paraître, il n'existe généralement pas de solution unique et universelle dans le développement de logiciels.

Par conséquent, nous devons appliquer notre sagesse en sélectionnant la solution la plus simple pour les problèmes spécifiques que nous visons à résoudre.