Mengapa Memilih Musim Semi sebagai Kerangka Java Anda?

1. Gambaran keseluruhan

Dalam artikel ini, kita akan melihat cadangan nilai utama Spring sebagai salah satu kerangka kerja Java yang paling popular.

Lebih penting lagi, kami akan cuba memahami sebab-sebab Spring menjadi kerangka pilihan kami. Perincian Spring dan bahagian penyusunnya telah banyak dibahas dalam tutorial kami sebelumnya. Oleh itu, kita akan melangkau bahagian "bagaimana" pengenalan dan kebanyakannya memfokus pada "mengapa".

2. Mengapa Menggunakan Kerangka Kerja?

Sebelum kita memulakan sebarang perbincangan khususnya mengenai Spring, mari kita fahami terlebih dahulu mengapa kita perlu menggunakan kerangka kerja sama sekali.

A maksud bahasa pengaturcaraan seperti Java mampu menyokong pelbagai aplikasi . Belum lagi bahawa Java aktif dan terus diperbaiki setiap hari.

Selain itu, terdapat banyak sumber terbuka dan perpustakaan proprietari untuk menyokong Java dalam hal ini.

Oleh itu, mengapa kita memerlukan kerangka kerja? Sejujurnya, tidak semestinya perlu menggunakan kerangka kerja untuk menyelesaikan sesuatu tugas. Tetapi, selalunya disarankan untuk menggunakannya kerana beberapa sebab:

  • Membantu kita menumpukan perhatian pada tugas teras dan bukannya plat boiler yang berkaitan dengannya
  • Menyatukan tahun kebijaksanaan dalam bentuk corak reka bentuk
  • Membantu kami mematuhi standard industri dan peraturan
  • Menurunkan jumlah kos pemilikan untuk aplikasi

Kita baru sahaja menggaru permukaannya dan kita mesti mengatakan bahawa faedahnya sukar diabaikan. Tetapi itu tidak boleh menjadi semua positif, jadi apa kesannya:

  • Memaksa kami menulis permohonan dengan cara tertentu
  • Mengikat versi bahasa dan perpustakaan tertentu
  • Menambah jejak sumber aplikasi

Terus terang, tidak ada peluru perak dalam pengembangan perisian dan kerangka kerja tentu tidak terkecuali daripada itu. Jadi pilihan kerangka mana atau tidak ada yang harus didorong dari konteksnya.

Mudah-mudahan, kita akan berada di tempat yang lebih baik untuk membuat keputusan ini berkenaan dengan Spring di Java pada akhir artikel ini.

3. Tinjauan Ringkas Ekosistem Musim Semi

Sebelum memulakan penilaian kualitatif kami mengenai Spring Framework, mari kita perhatikan lebih dekat bagaimana rupa ekosistem Spring.

Musim semi muncul di suatu tempat pada tahun 2003 pada saat Java Enterprise Edition berkembang pesat dan mengembangkan aplikasi perusahaan sangat menarik tetapi tetap membosankan!

Spring bermula sebagai wadah Inversion of Control (IoC) untuk Java. Kami masih mengaitkan Spring dengan sebahagian besarnya dan sebenarnya, ia merupakan inti kerangka kerja dan projek lain yang telah dibangun di atasnya.

3.1. Kerangka Musim Bunga

Kerangka spring dibahagikan kepada modul yang menjadikannya sangat mudah untuk memilih dan memilih bahagian yang akan digunakan dalam aplikasi apa pun:

  • Teras: Menyediakan ciri teras seperti DI (Dependency Injection), Pengantarabangsaan, Pengesahan, dan AOP (Pengaturcaraan Berorientasikan Aspek)
  • Akses Data: Menyokong akses data melalui JTA (Java Transaction API), JPA (Java Persistence API), dan JDBC (Java Database Connectivity)
  • Web: Menyokong API Servlet (Spring MVC) dan API Reaktif baru-baru ini (Spring WebFlux), dan juga menyokong WebSockets, STOMP, dan WebClient
  • Integrasi: Menyokong integrasi ke Enterprise Java melalui JMS (Java Message Service), JMX (Java Management Extension), dan RMI (Remote Method Invocation)
  • Pengujian: Sokongan yang luas untuk pengujian unit dan integrasi melalui Objek Mock, Perlengkapan Uji, Pengurusan Konteks, dan Caching

3.2. Projek Musim Bunga

Tetapi apa yang menjadikan Spring lebih berharga adalah ekosistem yang kuat yang telah berkembang di sekitarnya selama bertahun-tahun dan yang terus berkembang secara aktif . Ini disusun sebagai projek Spring yang dikembangkan di atas kerangka Spring.

Walaupun senarai projek Spring adalah panjang dan terus berubah, ada beberapa yang perlu disebutkan:

  • Boot: Memberi kami satu set templat yang sangat berpandangan tinggi tetapi dapat diperluas untuk membuat pelbagai projek berdasarkan Spring hampir dalam masa yang singkat. Ini sangat mudah untuk membuat aplikasi Spring mandiri dengan Tomcat tertanam atau bekas serupa.
  • Awan: Memberi sokongan untuk mengembangkan beberapa corak sistem yang diedarkan dengan mudah seperti penemuan perkhidmatan, pemutus litar, dan gerbang API. Ini membantu kita mengurangkan usaha menerapkan corak pelat boiler seperti itu di platform tempatan, jauh atau bahkan diuruskan.
  • Keselamatan: Menyediakan mekanisme yang kuat untuk mengembangkan pengesahan dan kebenaran untuk projek berdasarkan Spring dengan cara yang sangat disesuaikan. Dengan sokongan deklaratif yang minimum, kami mendapat perlindungan daripada serangan biasa seperti penetapan sesi, penggambaran klik, dan pemalsuan permintaan lintas-laman.
  • Mudah alih: Menyediakan keupayaan untuk mengesan peranti dan menyesuaikan tingkah laku aplikasi dengan sewajarnya. Selain itu, menyokong pengurusan pandangan yang menyedari peranti untuk pengalaman pengguna yang optimum, pengurusan keutamaan laman web, dan pengalih laman.
  • Batch: Menyediakan kerangka ringan untuk mengembangkan aplikasi batch untuk sistem perusahaan seperti arsip data. Mempunyai sokongan intuitif untuk menjadwalkan, memulakan semula, melangkau, mengumpulkan metrik, dan log. Selain itu, menyokong peningkatan untuk pekerjaan dengan volume tinggi melalui pengoptimuman dan pemisahan.

Tidak perlu dikatakan bahawa ini adalah pengenalan abstrak untuk apa yang ditawarkan oleh Spring. Tetapi ini memberi kita cukup banyak tempat berkenaan organisasi dan luas Spring untuk memajukan perbincangan kita lebih jauh.

4. Spring dalam Aksi

Sudah menjadi kebiasaan untuk menambahkan program hello-world untuk memahami teknologi baru.

Mari kita lihat bagaimana Spring dapat menjadikannya cakewalk untuk menulis program yang melakukan lebih daripada sekadar hello-world . Kami akan membuat aplikasi yang akan memperlihatkan operasi CRUD sebagai API REST untuk entiti domain seperti Karyawan yang disokong oleh pangkalan data dalam memori. Lebih-lebih lagi, kami akan melindungi titik akhir mutasi kami menggunakan autentikasi asas. Akhirnya, tidak ada aplikasi yang benar-benar lengkap tanpa ujian unit lama yang baik.

4.1. Penyediaan Projek

Kami akan menyiapkan projek Spring Boot kami menggunakan Spring Initializr, yang merupakan alat dalam talian yang mudah untuk boot projek dengan dependensi yang betul. Kami akan menambahkan Web, JPA, H2, dan Keselamatan sebagai kebergantungan projek untuk mendapatkan konfigurasi Maven dengan betul.

Maklumat lebih lanjut mengenai bootstrapping boleh didapati di salah satu artikel kami sebelumnya.

4.2. Model dan Kegigihan Domain

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.

Akhirnya, kami membincangkan sebab-sebab yang dapat memaksa kami untuk memilih Spring sebagai kerangka pilihan untuk Java.

Kita harus mengakhiri artikel ini dengan nota nasihat. Walau memikatnya kedengarannya, biasanya tidak ada satu, satu-ukuran-cocok-semua solusi dalam pengembangan perisian.

Oleh itu, kita mesti menerapkan kebijaksanaan kita dalam memilih jalan penyelesaian yang paling mudah untuk masalah tertentu yang ingin kita selesaikan.