Menguasai framework Spring 5, Bagian 1: Spring MVC

Spring MVC adalah library tradisional framework Spring untuk membangun aplikasi web Java. Ini adalah salah satu kerangka kerja web paling populer untuk membangun aplikasi web Java yang berfungsi penuh dan layanan web RESTful. Dalam tutorial ini, Anda akan mendapatkan gambaran umum Spring MVC dan belajar bagaimana membangun aplikasi web Java menggunakan Spring Boot, Spring Initializr, dan Thymeleaf.

unduh Unduh kode Dapatkan kode sumber untuk aplikasi contoh dalam tutorial ini. Dibuat untuk JavaWorld oleh Steven Haines

Spring Boot dengan Spring Initializr

Kami akan mempercepat aplikasi web Spring MVC kami dengan bantuan Spring Boot dan Spring Initializr. Diberikan masukan untuk jenis aplikasi yang akan dibangun, Spring Initializr menggunakan dependensi dan default yang paling umum untuk mengatur dan mengkonfigurasi aplikasi Spring Boot dasar. Anda juga dapat menambahkan dependensi khusus dan Spring Initializr akan menyertakan dan mengelolanya, memastikan kompatibilitas versi dengan perangkat lunak pihak ketiga dan Spring. Aplikasi Spring Boot berjalan mandiri, tanpa mengharuskan Anda menyediakan lingkungan runtime.

Dalam kasus ini, karena kita sedang membangun aplikasi web, Spring Boot secara otomatis akan menyertakan dan mengkonfigurasi Tomcat sebagai bagian dari runtime aplikasi. Kami juga dapat menyesuaikan aplikasi dengan menambahkan driver database H2 ke file POM Maven kami. Spring Boot kemudian akan secara otomatis membuat database dan DataSourceinstance tertanam dalam konteks aplikasi. Setelah dependensi ditetapkan, Spring Boot akan menyediakan konfigurasi default untuk aplikasi tersebut. Tentu saja kita dapat mengubah konfigurasi jika kita mau, tetapi berkat Spring Boot kita memiliki permulaan: aplikasi yang terkonfigurasi sepenuhnya dan berfungsi langsung di luar kotak.

Setelah kami memilih dan mengkonfigurasi dependensi kami, kami akan meneruskan pilihan tersebut ke Spring Initializr, yang akan menyediakan file ZIP yang dapat diunduh berisi proyek Spring Boot dasar.

Spring MVC dengan mesin database H2

Kita akan mulai dengan membuat aplikasi web Spring MVC dasar yang menyimpan data ke database tertanam H2.

Langkah 1. Siapkan dan konfigurasikan aplikasi

Arahkan ke Spring Initializr di start.spring.io dan pilih Hasilkan Proyek Maven dengan Java dan Spring Boot 2.0.X , di mana X adalah versi Spring Boot terbaru (2.0.3 pada saat penulisan ini). Pastikan Anda memilih Spring Boot 2.x sehingga Anda dapat mengimplementasikan Spring Web MVC 5. Spring Boot 1.4 dan Spring Boot 1.5 akan menerapkan Spring 4.

Masukkan nama grup dengan format yang cocok dengan alamat web Anda, seperti com.geekcap.javaworld, dan masukkan nama artefak, seperti spring5mvc-example. Gambar 1 menunjukkan konfigurasi saya.

Steven Haines

Untuk menambahkan dependensi ke aplikasi web, Anda dapat memasukkan daftar dependensi yang dipisahkan koma ke dalam bidang teks Cari dependensi atau klik Beralih ke versi lengkap . Kami akan mengambil rute yang lebih mudah dengan mengklik Beralih ke versi lengkap . Dependensi dibagi menjadi beberapa kelompok, seperti Core, Web, dan Template Engine. Untuk contoh ini, centang kotak untuk: Web -> Web, Mesin Template -> Thymeleaf, SQL -> JPA, dan SQL -> H2 . Inilah yang akan ditambahkan oleh masing-masing pilihan tersebut ke aplikasi:

  • Web: Spring MVC dan Tomcat
  • Thymeleaf: mesin template web Thymeleaf
  • JPA: Spring JPA, Hibernate, dan Spring Data
  • H2: Database H2 tertanam

Setelah selesai, klik tombol Hasilkan Proyek di bagian bawah halaman. Spring Initializr akan membuat file ZIP yang sudah jadi dengan semua sumber proyek yang diperlukan, yang dapat Anda unduh.

Langkah 2. Impor proyek Spring Initializr ke IDE Anda

Ekstrak file ZIP dari Spring Initializr, lalu impor proyek tersebut ke IDE favorit Anda. Misalnya, untuk mengimpor proyek ke IntelliJ, pilih File -> New Project , seperti yang ditunjukkan pada Gambar 2.

Steven Haines

Langkah 3. Siapkan POM Maven Anda

Selanjutnya, navigasikan ke Impor proyek dari modul eksternal , pilih Maven , dan tekan Berikutnya . Pastikan untuk memilih SDK proyek Java 1.8, lalu tekan Selesai .

Aplikasi starter Spring Boot

Sekarang mari kita lihat aplikasi starter Spring Boot yang telah dihasilkan oleh upaya (minimal) kami sejauh ini.

Untuk memulai, Kode 1 menunjukkan file POM Maven.

Daftar 1. Maven pom.xml

   4.0.0 com.geekcap.javaworld spring5mvc-example 0.0.1-SNAPSHOT jar spring5mvc-example Demo project for Spring Boot  org.springframework.boot spring-boot-starter-parent 2.0.3.RELEASE     UTF-8 UTF-8 1.8    org.springframework.boot spring-boot-starter-data-jpa   org.springframework.boot spring-boot-starter-thymeleaf   org.springframework.boot spring-boot-starter-web   com.h2database h2 runtime   org.springframework.boot spring-boot-starter-test test      org.springframework.boot spring-boot-maven-plugin     

Perhatikan bahwa file POM menggunakan orangtua POM khusus: spring-boot-starter-parent. Kami akan menggunakan POM induk untuk mengelola versi semua dependensi kami dan memastikan versinya kompatibel. Repositori di akhir file POM merujuk pada repositori Spring snapshot dan milestone . Kami membutuhkan ini karena Spring Boot 2.x masih merupakan rilis tonggak sejarah pada saat penulisan ini.

Dependensinya cukup minimal, dan sebagian besar diawali dengan spring-boot-starter:

  • spring-boot-starter-data-jpa
  • spring-boot-starter-thymeleaf
  • spring-boot-starter-web
  • spring-boot-starter-test

Masing-masing dependensi starter ini membawa semua sub-dependensi yang dibutuhkannya. Gambar 3 menunjukkan tampilan dependensi yang diperluas sebagian di IntelliJ.

Steven Haines

File POM menyertakan dependensi berikut:

  • spring-boot-starter-data-jpa termasuk Hibernate dan Spring Data.
  • spring-boot-starter-thymeleaf termasuk mesin template Thymeleaf.
  • spring-boot-starter-webtermasuk spring-boot-starter-tomcat, versi tertanam dari Apache Tomcat.
  • spring-boot-starter-json termasuk perpustakaan Jackson JSON.
  • spring-web and spring-webmvc termasuk Spring MVC.
  • spring-boot-starter-test termasuk pustaka pengujian seperti JUnit dan Mockito.

Ketika Spring Boot melihat ketergantungan ini di CLASSPATH, itu memulai konfigurasi otomatis. Misalnya, ketika menemukan spring-boot-starter-web, itu membuat versi tertanam dari Tomcat, dan ketika menemukan H2 dan spring-boot-starter-jpaitu membuat database tertanam H2 dan Hibernate EntityManager. Ini kemudian menghubungkan EntityManagerke Spring Data.

Spring Boot juga membuat satu kelas yang dapat digunakan untuk menjalankan aplikasi. Kelas untuk aplikasi contoh ditunjukkan pada Kode 2.

Daftar 2. Spring5mvcExampleApplication.java

 package com.geekcap.javaworld.spring5mvcexample; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class Spring5mvcExampleApplication { public static void main(String[] args) { SpringApplication.run(Spring5mvcExampleApplication.class, args); } } 

This class leverages the SpringApplication.run() method, passing in the class to run (Spring5mvcExampleApplication in this example). The @SpringBootApplication annotation includes the following annotations:

  • @Configuration informs Spring that the Spring5mvcExampleApplication class contains configuration information. (This annotation can be used to create beans that will get registered with the Spring context.)
  • @EnableAutoConfiguration tells Spring to automatically configure resources from dependencies found in the CLASSPATH, such as H2 and Tomcat.
  • @ComponentScan tells Spring to scan packages in the CLASSPATH under the current package (com.geekcap.javaworld.spring5mvcexample) for Spring-annotated components such as @Service and @Controller.

Spring scans the CLASSPATH and automatically creates components such as the embedded Tomcat server and H2 database. It then populates the Spring context with the application components found in the package scan. In essence, Spring Boot makes it very easy to select and configure the services, components, controllers, entities, and so forth that you need for your application. Once you've done that, Spring will automatically find them, make them available in the Spring context, and autowire everything together.

We've got our Spring Boot starter project setup and ready to go. In the next section we'll create the Spring MVC components for our Java web application.

What is the Spring context?

The Spring context is a registry of all available Spring beans. Classes are identified as Spring beans by annotating them with specific Spring annotations. Examples include @Service, which identifies a business service, @Controller, which identifies a Spring MVC controller (i.e., handles web requests), and @Entity, which is a JPA annotation used to identify classes that are mapped to database tables.

Once these beans are annotated they need to be registered with the Spring context, which Spring Boot does by performing a package scan of all classes in packages in your project. As the Spring context is being built, it implements the inversion-of-control (IoC) design pattern through dependency injection: when a Spring bean needs a dependency, such as a service or repository, the bean can either define a constructor that accepts the dependent bean or it can leverage the @Autowired annotation to tell Spring that it needs that dependency. Spring resolves all dependencies and "autowires" the application together.

Dependency Injection is a powerful design pattern because, rather than creating and managing dependencies inside your code--which can be messy and leads to tightly coupled classes--you can instead delegate control to the Spring container. Your class simply tells the container what dependencies it needs to run and the container provides the appropriate dependencies to your class at runtime.

About Spring MVC 5

Spring MVC implements the popular Model-View-Controller pattern, which you've probably seen in other web frameworks. The Model-View-Controller pattern separates concerns into three categories:

  • Model represents your domain objects.
  • View renders your model to a view, such as to an HTML page.
  • Controller sits between your view and model and translates change requests in the view into changes in the model, and vice versa. In practical terms, the controller accepts incoming requests, potentially updates the model, and sends your model objects to a "view" to render back to the client.

In Spring MVC, controllers are identified by the @Controller annotation and accompanied by a @RequestMapping annotation. The annotation defines the HTTP verb (standard HTTP commands like GET, POST, PUT, and DELETE) and URI for which the request-mapping method will be applied. Spring 4 introduced shortcut request mappings, which make things even easier. We'll use these mappings--@GetMapping, @PostMapping, @PutMapping, @PatchMapping, and @DeleteMapping--for our example application.

The model in Spring MVC

Untuk aplikasi kita, kita akan mendefinisikan objek model sederhana, a Widget, menyimpannya dalam database H2 yang disematkan, dan membangun pengontrol untuk mengelola widget. Mari kita mulai dengan Widgetkelas, yang ditunjukkan pada Kode 3.