Warum sollten Sie Spring als Ihr Java Framework wählen?

1. Übersicht

In diesem Artikel gehen wir auf das Hauptwertversprechen von Spring als eines der beliebtesten Java-Frameworks ein.

Noch wichtiger ist, dass wir versuchen, die Gründe dafür zu verstehen, dass der Frühling unser bevorzugter Rahmen ist. Details zu Spring und seinen Bestandteilen wurden in unseren vorherigen Tutorials ausführlich behandelt. Daher überspringen wir die einleitenden "Wie" -Teile und konzentrieren uns hauptsächlich auf "Warum".

2. Warum ein Framework verwenden?

Bevor wir eine Diskussion speziell über den Frühling beginnen, wollen wir zunächst verstehen, warum wir überhaupt ein Framework verwenden müssen.

Eine Allzweckprogrammiersprache wie Java kann eine Vielzahl von Anwendungen unterstützen . Ganz zu schweigen davon, dass Java jeden Tag aktiv bearbeitet und verbessert wird.

Darüber hinaus gibt es unzählige Open Source- und proprietäre Bibliotheken, die Java in dieser Hinsicht unterstützen.

Warum brauchen wir also einen Rahmen? Ehrlich gesagt ist es nicht unbedingt erforderlich, ein Framework zu verwenden, um eine Aufgabe zu erfüllen. Es ist jedoch oft aus mehreren Gründen ratsam, eine zu verwenden:

  • Hilft uns, uns auf die Kernaufgabe und nicht auf die damit verbundene Kesselplatte zu konzentrieren
  • Bringt jahrelange Weisheit in Form von Designmustern zusammen
  • Hilft uns, die Branchen- und Regulierungsstandards einzuhalten
  • Reduziert die Gesamtbetriebskosten für die Anwendung

Wir haben hier gerade die Oberfläche zerkratzt und müssen sagen, dass die Vorteile schwer zu ignorieren sind. Aber es kann nicht alles positiv sein, also was ist der Haken:

  • Zwingt uns , eine Bewerbung auf eine bestimmte Art und Weise zu schreiben
  • Bindet an eine bestimmte Version von Sprache und Bibliotheken
  • Fügt dem Ressourcen-Footprint der Anwendung hinzu

Ehrlich gesagt gibt es in der Softwareentwicklung keine Silberkugeln, und Frameworks sind sicherlich keine Ausnahme. Die Wahl des Frameworks oder des Frameworks sollte also vom Kontext abhängen.

Hoffentlich sind wir am Ende dieses Artikels besser in der Lage, diese Entscheidung in Bezug auf Spring in Java zu treffen.

3. Kurzer Überblick über das Frühlingsökosystem

Bevor wir mit unserer qualitativen Bewertung von Spring Framework beginnen, schauen wir uns genauer an, wie das Spring-Ökosystem aussieht.

Der Frühling entstand irgendwo im Jahr 2003 zu einer Zeit, als sich die Java Enterprise Edition schnell entwickelte und die Entwicklung einer Unternehmensanwendung aufregend, aber dennoch mühsam war!

Spring begann als IoC-Container (Inversion of Control) für Java. Wir beziehen Spring immer noch hauptsächlich darauf und tatsächlich bildet es den Kern des Frameworks und anderer Projekte, die darüber hinaus entwickelt wurden.

3.1. Frühlingsrahmen

Das Spring Framework ist in Module unterteilt, die es wirklich einfach machen, Teile auszuwählen, die in jeder Anwendung verwendet werden sollen:

  • Kern: Bietet Kernfunktionen wie DI (Dependency Injection), Internationalisierung, Validierung und AOP (Aspect Oriented Programming).
  • Datenzugriff: Unterstützt den Datenzugriff über JTA (Java Transaction API), JPA (Java Persistence API) und JDBC (Java Database Connectivity).
  • Web: Unterstützt sowohl die Servlet-API (Spring MVC) als auch die kürzlich verwendete Reactive API (Spring WebFlux) und unterstützt zusätzlich WebSockets, STOMP und WebClient
  • Integration: Unterstützt die Integration in Enterprise Java über JMS (Java Message Service), JMX (Java Management Extension) und RMI (Remote Method Invocation).
  • Testen: Umfassende Unterstützung für Unit- und Integrationstests durch Mock Objects, Test Fixtures, Context Management und Caching

3.2. Frühlingsprojekte

Was den Frühling jedoch viel wertvoller macht, ist ein starkes Ökosystem, das im Laufe der Jahre um ihn herum gewachsen ist und sich aktiv weiterentwickelt . Diese sind als Spring-Projekte strukturiert, die auf dem Spring-Framework aufbauen.

Obwohl die Liste der Frühlingsprojekte lang ist und sich ständig ändert, gibt es einige erwähnenswerte:

  • Boot: Bietet uns eine Reihe von hochmeinenden, aber erweiterbaren Vorlagen zum Erstellen verschiedener Projekte auf Spring-Basis in kürzester Zeit. Es macht es wirklich einfach, eigenständige Spring-Anwendungen mit eingebettetem Tomcat oder einem ähnlichen Container zu erstellen.
  • Cloud: Bietet Unterstützung für die einfache Entwicklung einiger gängiger verteilter Systemmuster wie Service Discovery, Leistungsschalter und API-Gateway. Dies hilft uns, den Aufwand für die Bereitstellung solcher Boilerplate-Muster auf lokalen, Remote- oder sogar verwalteten Plattformen zu verringern.
  • Sicherheit: Bietet einen robusten Mechanismus zum Entwickeln der Authentifizierung und Autorisierung für auf Spring basierende Projekte auf hochgradig anpassbare Weise. Mit minimaler deklarativer Unterstützung erhalten wir Schutz vor häufigen Angriffen wie Sitzungsfixierung, Click-Jacking und Fälschung von standortübergreifenden Anforderungen.
  • Mobil: Bietet Funktionen zum Erkennen des Geräts und zum entsprechenden Anpassen des Anwendungsverhaltens. Unterstützt außerdem die gerätebezogene Ansichtsverwaltung für eine optimale Benutzererfahrung, die Verwaltung von Websiteeinstellungen und den Site Switcher.
  • Batch: Bietet ein leichtes Framework für die Entwicklung von Batch-Anwendungen für Unternehmenssysteme wie die Datenarchivierung. Intuitive Unterstützung für das Planen, Neustarten, Überspringen, Sammeln von Metriken und Protokollieren. Unterstützt außerdem die Skalierung für Jobs mit hohem Volumen durch Optimierung und Partitionierung.

Unnötig zu erwähnen, dass dies eine ziemlich abstrakte Einführung in das ist, was der Frühling zu bieten hat. Aber es bietet uns genug Boden in Bezug auf die Organisation und Breite von Spring, um unsere Diskussion weiterzuführen.

4. Frühling in Aktion

Es ist üblich, ein Hallo-Welt-Programm hinzuzufügen, um neue Technologien zu verstehen.

Mal sehen, wie der Frühling es zu einem Kinderspiel machen kann, ein Programm zu schreiben, das mehr als nur Hallo-Welt kann . Wir erstellen eine Anwendung, die CRUD-Operationen als REST-APIs für eine Domänenentität wie Employee verfügbar macht, die von einer In-Memory-Datenbank unterstützt wird. Darüber hinaus schützen wir unsere Mutationsendpunkte mithilfe der Basisauthentifizierung. Schließlich kann kein Antrag ohne gute, alte Komponententests wirklich vollständig sein.

4.1. Projektaufbau

Wir werden unser Spring Boot-Projekt mit Spring Initializr einrichten, einem praktischen Online-Tool zum Booten von Projekten mit den richtigen Abhängigkeiten. Wir werden Web, JPA, H2 und Sicherheit als Projektabhängigkeiten hinzufügen, um die Maven-Konfiguration korrekt einzurichten.

Weitere Informationen zum Bootstrapping finden Sie in einem unserer vorherigen Artikel.

4.2. Domänenmodell und Persistenz

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.

Schließlich diskutierten wir die Gründe, die uns dazu zwingen können, Spring als bevorzugten Rahmen für Java zu wählen.

Wir sollten diesen Artikel jedoch mit einem Hinweis beenden. So überzeugend es auch klingen mag, in der Softwareentwicklung gibt es normalerweise keine einheitliche Lösung .

Daher müssen wir unsere Weisheit anwenden, um die einfachste Lösung für die spezifischen Probleme auszuwählen, die wir lösen möchten.