Przejdź do treści

Spring Boot – szybkie tworzenie aplikacji web w Javie

Spring Boot

Stworzenie nawet prostej aplikacji w Javie zwykle bywa czasochłonne. Trzeba stworzyć dużo plików xml zawierających konfiguracje, która zazwyczaj jest taka sama lub bardzo podobna dla każdej aplikacji, następnie uruchamianie kontenera, deployowanie aplikacji i inne powtarzalne czynności. Jednak istnieje alternatywa którą jest Spring Boot!

Projekt ten powstał aby ułatwić wszystkim start ze Springiem, eliminuje potrzebę zabawy z tworzeniem konfiguracji xml-owej, gotową aplikację można stworzyć i uruchomić za pomocą jednej klasy. Idealnie nadaje się do projektów studenckich i szybkiego prototypowania aplikacji. Jedyne wymagania jakie stawia przed użytkownikiem to podstawowa znajomość Mavena.

Zaczynamy zabawę ze Spring Boot!

Kod projektu możecie znaleźć w GitHubie pod adresem: https://github.com/mloza/spring-boot-starter

Na początku należy stworzyć projekt Mavenowy. Ustawiamy jako parenta artefakt springowy poprzez dodanie klauzuli do pom.xml:

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.5.RELEASE</version>
</parent>
view raw pom.xml hosted with ❤ by GitHub

Następnie jeżeli to ma być aplikacja webowa dodajemy odpowiednią zależność która powie Springowi, że chcemy stworzyć aplikację web:

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
view raw pom2.xml hosted with ❤ by GitHub

Przy dodawaniu zależności nie podajemy już wersji, dzieje się tak dlatego, że wersje poszczególnych artefaktów wyspecyfikowane są w projekcie nadrzędnym zdefiniowanym jako parent. Cały pom.xml wygląda u mnie następująco:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>pl.mloza</groupId>
<artifactId>spring-boot-starter</artifactId>
<version>1.0-SNAPSHOT</version>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.5.RELEASE</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
</project>
view raw pom3.xml hosted with ❤ by GitHub

Tworzymy właściwą aplikację

Po stworzeniu projektu, możemy przejść do kodowania aplikacji. Zaczynamy od stworzenia nowej klasy, ja zwykle z braku pomysłu nazywam ją Main. Gotowa klasa, która będzie obsługiwać zapytania z przeglądarki wygląda tak:

@SpringBootApplication
@Controller
public class Main {
@RequestMapping("/")
@ResponseBody
public String mainPage() {
return "Hello World!";
}
public static void main(String[] args) {
SpringApplication.run(Main.class, args);
}
}
view raw Main.java hosted with ❤ by GitHub

Jeśli teraz uruchomisz aplikację i przejdziesz w przeglądarce pod adres localhost:8080 ujrzysz Hello World!.

Przejdźmy teraz do szczegółów, zobaczmy co się dzieje w kodzie. Nasza klasa posiada 2 adnotacje:

  • @SpringBootApplication z pakieru org.springframework.boot.autoconfigure, Adnotacja ta włącza automatyczną konfigurację modułów oraz wykrywanie komponentów. Automatyczna konfiguracja działa w ten sposób, że wyszukuje odpowiednie klasy i jeśli są dostępne próbuje je automatycznie skonfigurować. Np. jeśli dodamy moduł bazy danych spróbuje ona uruchomić bazę danych w pamięci i się do niej podłączyć. Wykrywanie komponentów polega na tym, że przeszukuje nasze klasy w poszukiwaniu kontrolerów, serwisów i tym podobnych oraz tworzy ich instancje.
  • @Controller z pakietu org.springframework.stereotype – dzięki temu aplikacja będzie wiedzieć, że nasza klasa obsługuje żądania HTTP.

Kolejnym elementem jest metoda main, taka zwykła która jest wywoływana na początku każdego programu. W niej uruchamiamy aplikacje za pomocą jednej linijki: SpringApplication.run(Main.class, args);. Podajemy w niej nazwę głównej klasy, czyli nasz main i argumenty linii poleceń.

Drugą metodą która znajduje się w klasie jest metoda mainPage ozdobiona 2 adnotacjami:

  • @RequestMapping(„/”) – Mówi aplikacji, że żądanie z przeglądarki o stronę „/”, czyli główną stronę będzie obsługiwała właśnie ta metoda.
  • @ResponseBody – Mówi aplikacji, że metoda zwróci ciało odpowiedzi, to co zostanie zwrócone przez metodę zostanie przesłane do przeglądarki, w tym konkretnym przypadku do przeglądarki zostanie wysłany ciąg znaków: Hello World.

Oddzielenie kontrolera

W przypadku bardzo prostej aplikacji takie podejście się sprawdza, jednak mieszamy tutaj troszeczkę różne warstwy aplikacji. Aby kod był czytelniejszy powinniśmy wydzielić kod kontrolera do oddzielnej klasy. Dodajmy zatem kolejną klasę np. PageController i przenieśmy do niej wszystko co związane z kontrolerem:

@Controller
public class PageController {
@RequestMapping("/")
@ResponseBody
public String mainPage() {
return "Hello World!";
}
}

Przy okazji dodajmy jeszcze jedną metodę która obsłuży inny adres tak aby sumarycznie wyglądało to tak:

@Controller
public class PageController {
@RequestMapping("/")
@ResponseBody
public String mainPage() {
return "Hello World!";
}
@RequestMapping("/hello")
@ResponseBody
public String pageTwo() {
return "Hi!";
}
}

Dzięki wspomnianej wcześniej adnotacji @SpringBootApplication, Spring wyszuka naszą klasę, stworzy jej instancję i będzie tam przekazywał żądania przeglądarki.

Po uruchomieniu aplikacji, pod adresem http://localhost:8080 powinien nadal znajdować się napis Hello World! a pod adresem http://localhost:8080/hello napis Hi!

Kilka szczegółów technicznych dla zainteresowanych

W trakcie uruchamiania aplikacji, logi pokazują, że pod spodem uruchamia się Tomcat. Spring Boot uruchamia embedded Tomcata za nas i wgrywa tam aplikacje abyśmy sami mogli się skupić na tworzeniu kodu zamiast przejmowania się szczegółami technicznymi.

Nasza aplikacja dodatkowo może być wyeksportowana do pliku war tak aby można było ją uruchomić na zewnętrznym tomcacie, jednakże ciekawszą opcją jest stworzenie tak zwanego FatJar, czyli pliku jar z wszystkimi zależnościami i kontenerem, który możemy uruchomić przy pomocy polecenia: java -jar plik.jar. Aby tego dokonać trzeba dodać do pliku pom kilka wpisów:

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
view raw pom4.xml hosted with ❤ by GitHub

Cały plik wygląda teraz tak:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>pl.mloza.blog</groupId>
<artifactId>spring-boot-start</artifactId>
<version>1.0-SNAPSHOT</version>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.2.0.RELEASE</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
view raw pom5.xml hosted with ❤ by GitHub

Uruchomienie Mavenowego celu package (mvn package) spowoduje stworzenie pliku jar w katalogu target w naszym projekcie.

Więcej o tworzeniu poszczególnych plików znajduje się na stronie: http://docs.spring.io/spring-boot/docs/current/reference/html/build-tool-plugins-maven-plugin.html.

Podsumowanie

Spring Boot pozwala tworzyć aplikacje pomijając cały narzut związany z tworzeniem konfiguracji xml. Bardzo szybko można zaprototypować w nim aplikacje. Aktualnie pokazałem jak zrobić prostą aplikację web, jednakże posiada on bardzo wiele komponentów m.in. zapewniających komunikację z bazami danych, pozwalające tworzyć kontrolery REST itp. W kolejnych postach postaram się przybliżyć kilka z nich.

Matriały

5 komentarzy do “Spring Boot – szybkie tworzenie aplikacji web w Javie”

  1. Wow! Spring Boot zaczyna mi się podobać! Zdecydowanie mniej pracy z konfiguracją i przede wszystkim mniej problemów w porównaniu do tego, co czasem „wyprawia” standardowy Spring.

    Kurs jest świetny. Wszystkie szczegóły opisane i to przejrzyście! Szata graficzna jest super – nie rozprasza wieloma kolorami czy reklamami jak w przypadku wielu tutoriali anglojęzycznych, a tekst przyjemnie się czyta.

    Będę tu wracać! 🙂

Dodaj komentarz

Twój adres e-mail nie zostanie opublikowany. Wymagane pola są oznaczone *

%d