Panduan Cepat untuk Spring Roo

1. Ikhtisar

Spring Roo adalah alat Rapid Application Development (RAD) yang bertujuan untuk memberikan hasil yang cepat dan instan yang difokuskan pada aplikasi web Spring dan teknologi Spring yang lebih baru. Ini memungkinkan kita untuk menghasilkan kode boilerplate dan struktur proyek untuk aplikasi Spring dengan perintah yang mudah digunakan.

Roo dapat digunakan sebagai aplikasi mandiri yang dijalankan dari baris perintah sistem operasi. Tidak ada persyaratan untuk menggunakan Eclipse, Spring Tool Suite (STS) atau IDE lainnya; sebenarnya, kita dapat menggunakan editor teks apa saja untuk menulis kode!

Namun, untuk kesederhanaan, kami akan menggunakan STS IDE dengan Roo Extension.

2. Memasang Spring Roo

2.1. Persyaratan

Untuk mengikuti tutorial ini, ini harus diinstal:

  1. Java JDK 8
  2. STS
  3. Spring Roo

2.2. Instalasi

Setelah kita mengunduh dan menginstal Java JDK dan STS, kita perlu unzip Spring Roo dan menambahkannya ke jalur sistem.

Mari buat variabel lingkungan ROO_HOME dan tambahkan % ROO_HOME% \ bin ke jalur.

Untuk memverifikasi bahwa Roo diinstal dengan benar, kita dapat membuka baris perintah dan menjalankan perintah berikut:

mkdir baeldung cd baeldung roo quit

Setelah beberapa detik kita akan melihat:

 _ ___ _ __ _ __(_)_ __ __ _ _ __ ___ ___ / __| '_ \| '__| | '_ \ / _` | | '__/ _ \ / _ \ \__ \ |_) | | | | | | | (_| | | | | (_) | (_) | |___/ .__/|_| |_|_| |_|\__, | |_| \___/ \___/ |_| |___/ 2.0.0.RC1 Welcome to Spring Roo. For assistance press TAB or type "hint" then hit ENTER.

Roo diinstal, dan berfungsi. Harap dicatat bahwa versi Spring Roo akan bervariasi dan langkah serta instruksi mungkin tergantung pada versi sebenarnya yang digunakan.

Penting: Spring Roo 2.0 tidak kompatibel dengan versi sebelumnya 1.x.

2.3. Menambah dan Mengkonfigurasi Ekstensi STS

Out-of-the-box, STS mendukung pengembangan aplikasi Spring dan menyertakan ekstensi yang siap digunakan. Namun, ekstensi Spring Roo tidak disertakan. Oleh karena itu, kami perlu menambahkannya secara manual.

Di STS, mari menuju ke Instal Perangkat Lunak Baru dan impor bookmark ke Situs Perangkat Lunak yang Tersedia . Saat ini, bookmark ada di folder% ROO_HOME% \ conf . Setelah kami mengimpor bookmark, kami dapat mencari hanya roo dan menginstal versi terbaru dari Spring IDE Roo Support . Akhirnya, kita akan diminta untuk merestart STS.

Untuk langkah-langkah terperinci dan terbaru, kami selalu dapat pergi dan memeriksa dokumentasi Memulai Spring Roo.

Setelah kami memasang Dukungan Roo di STS, kami perlu menyiapkan ekstensi. Ini semudah mengarahkan Roo Support ke folder % ROO_HOME% . Sekali lagi, Spring Roo Getting Started memberikan langkah-langkah terperinci bagaimana melakukannya.

Sekarang kita bisa pergi ke menu aplikasi "Window" sekali lagi dan pilih Show View> Roo Shell.

3. Proyek Pertama

3.1. Menyiapkan Proyek di STS

Di STS, buka jendela Roo Shell dan klik ikon Create New Roo Project . Ini akan membuka jendela New Roo Project .

Kami akan menamai proyek roo dan menggunakan com.baeldung sebagai nama paket tingkat atas kami. Kita dapat meninggalkan semua nilai default lainnya dan melanjutkan hingga akhir untuk membuat proyek baru menggunakan Roo.

Di STS ini akan menjalankan perintah berikut untuk kita:

project setup --topLevelPackage com.baeldung --projectName "roo" --java 8 --packaging JAR

Seperti yang telah disebutkan, kami tidak memerlukan IDE, dan kami dapat menjalankan sendiri perintah itu dari Roo Shell! Untuk kesederhanaan, kami menggunakan fitur bawaan STS.

Jika kami mendapatkan kesalahan berikut:

Could not calculate build plan: Plugin org.codehaus.mojo:aspectj-maven-plugin:1.8 or one of its dependencies could not be resolved: Failed to read artifact descriptor for org.codehaus.mojo:aspectj-maven-plugin:jar:1.8

the easiest way to fix it is to manually edit pom.xml file and update aspectj.plugin.version from 1.8 to 1.9:

1.9

At this stage, there shouldn't be any errors in the project, and there will be a few auto-generated files for us.

3.2. Roo Shell

Now it is time to familiarize with the Roo Shell. Spring Roo's primary user interface is, in fact, command prompt!

Therefore, let's go back to Roo Shell window. In it, let's run the first command by typing ‘h' and pressing CTRL+SPACE:

roo> h help hint

Roo will automatically suggest and autocomplete commands for us. We can type ‘hi', press CTRL+SPACE, and Roo will auto-suggest hint command.

Another great feature of Roo Shell is the context awareness. For example, the output of the hint command will change depending on the previous input.

Let's now execute the hint command and see what happens:

roo> hint Roo requires the installation of a persistence configuration. Type 'jpa setup' and then hit CTRL+SPACE. We suggest you type 'H' then CTRL+SPACE to complete "HIBERNATE". After the --provider, press CTRL+SPACE for database choices. For testing purposes, type (or CTRL+SPACE) HYPERSONIC_IN_MEMORY. If you press CTRL+SPACE again, you'll see there are no more options. As such, you're ready to press ENTER to execute the command. Once JPA is installed, type 'hint' and ENTER for the next suggestion.

It gives us the next steps we need to perform. Let's add a database now:

roo> jpa setup --provider HIBERNATE --database HYPERSONIC_IN_MEMORY Created SRC_MAIN_RESOURCES\application.properties Updated SRC_MAIN_RESOURCES\application.properties Updated SRC_MAIN_RESOURCES\application-dev.properties Updated ROOT\pom.xml [added dependencies org.springframework.boot:spring-boot-starter-data-jpa:, org.springframework.boot:spring-boot-starter-jdbc:, org.hsqldb:hsqldb:; added property 'springlets.version' = '1.2.0.RC1'; added dependencies io.springlets:springlets-data-jpa:${springlets.version}, io.springlets:springlets-data-jpa:${springlets.version}; added dependencies io.springlets:springlets-data-commons:${springlets.version}, io.springlets:springlets-data-commons:${springlets.version}]

At this stage, we will need to execute some commands. Between each of them, we can always run hint command to see what is suggested by Roo. This is a very useful feature.

Let's run the commands first, and we will go through them afterward:

roo> entity jpa --class ~.domain.Book field string --fieldName title --notNull field string --fieldName author --notNull field string --fieldName isbn --notNull repository jpa --entity ~.domain.Book service --all web mvc setup web mvc view setup --type THYMELEAF web mvc controller --entity ~.domain.Book --responseType THYMELEAF

We are now ready to run our application. However, let's step back through the commands to see what we have done.

First, we created a new JPA persistent entity in the src/main/java folder. Next, we created three String fields in Book class, gave them a name and set to be not null.

After that, we have generated Spring Data repository for the specified entity and created a new service interface.

In the end, we included Spring MVC configuration, installed Thymeleaf and created a new controller that manages our entity. Because we have passed Thymeleaf as the response type, the generated methods and views will reflect this.

3.3. Running the Application

Let's refresh the project and right click on roo project and select Run As > Spring Boot App.

Once the application has started, we can open a web browser and go to //localhost:8080. Next, to Roo icon, we will see Book menu and underneath two options: Create Book and List Books. We can use this to add a book to our application and view the list of added books.

3.4. Other Features

When we open Book.java class file, we'll notice that the class is annotated with @Roo annotations. These were added by Roo Shell and are used to control and customize the content of AspectJ inter-type declaration (ITD) files. We can view the files in Package Explorer in STS by unselecting “Hide generated Spring Roo ITDs” filter in View Menu, or we can open the files directly from the file system.

Roo annotations have SOURCE retention policy. This means the annotations won't be present in compiled class bytecode, and there won't be any dependency to Roo in deployed applications.

Another, obviously missing part in the Book.java class are getters and setters. These are stored in separate AspectJ ITDs files, as already mentioned. Roo will actively maintain this boilerplate code for us. Therefore, changes to fields in any class will be automatically reflected in AspectJ ITDs as Roo is “monitoring” all changes – either done via Roo Shell or directly by a developer in IDE.

Roo will take care of the repetitive code like toString() or equals() methods too.

Selain itu, kerangka kerja dapat dengan mudah dihapus dari proyek, menghindari vendor lock-in, dengan menghapus anotasi dan memasukkan AspectJ ITD ke kode java standar.

4. Kesimpulan

Dalam contoh singkat ini, kami berhasil menginstal dan mengkonfigurasi Spring Roo di STS dan membuat proyek kecil.

Kami menggunakan Roo Shell untuk menyiapkannya dan tidak perlu menulis satu baris pun kode Java yang sebenarnya! Dan kami bisa mendapatkan prototipe aplikasi yang berfungsi dalam beberapa menit dan Roo menangani semua kode boilerplate untuk kami.

Seperti biasa, kode yang digunakan selama diskusi dapat ditemukan di GitHub.