Projekt startowy Spring Boot

Nie sądziłem, że kiedyś to powiem ale...przyszedł czas na to by z radością popracować trochę w wakacje i przygotować posta. 
Będzie to kolejny post specjalny, który możecie potraktować jako ćwiczenie do wykonania w jeden z ciepłych lipcowych wieczorów. 
Ćwiczenie polega na wykonaniu szkieletu aplikacji internetowej (webowej) w Springu.
Zgodnie z tradycją tego cyklu udostępniamy kod zródłowy w postaci projektu na Githubie, gdzie możecie sklonować repozytorium albo po prostu ściągnąć plik zip. 
Do pełnego zrozumienia przykładu wymagana jest wiedza ogólna dotycząca Spring-a, a w szczególności 
Spring Boot-a, który opisujemy w naszym kursie w rozdziale <a ng-href="/kurs-spring/projekt-startowy-spring-boot" ng-click="$event.stopPropagation();" target="_blank">Spring Boot - Projekt startowy</a>.<br/><br/>

Tak jak wspomnieliśmy nasze zadanie polega na stworzeniu szkieletu aplikacji webowej. Aplikacja ma być dostępna pod portem 8888. 
Powinna mieć skonfigurowany dostęp do bazy danych i musi być uruchamialna zarówno na serwerze (np. Tomcat), jak i poza nim (np. za pomocą skryptu). 
Aplikacja ma być bazą do budowy większego systemu, odpowiedzialnego za przechowywanie i przetwarzanie obiektów typu <span class="cit">Item</span>.

<div class="vertical-box-30"></div>
<h2>Maven, Spring Boot i baza H2 </h2>
<div class="vertical-box-20"></div>

Na początku, w ramach pracy nad tym zagadnieniem spróbujemy podzielić go na kilka mniejszych zadań. Ich lista będzie wyglądała następująco:<br/><br/>
- stworzenie mavenowego projektu z użyciem modułów frameworka Spring: <span class="cit">Spring Boot</span>, <span class="cit">Spring MVC</span>, <span class="cit">Spring Data JPA</span>. <br/>
- dodanie podstawowej konfiguracji w pliku <code>application.properties</code>, m.in. dla bazy danych <code>H2</code> oraz <code>Postgres</code>.<br/>
- dodanie przykładowego kontrolera Spring-a typu <code>REST</code>, który będzie zawierał cztery metody dedykowane obsłudze żądań typu: <code>GET</code>, <code>POST</code>, <code>PUT</code>, <code>DELETE</code>. <br/>
- wprowadzenie warstwy serwisu odpowiedzialnej za przetwarzanie danych - <code>ItemService</code> oraz warstwy utrwalania danych: <code>ItemRepository</code>.<br/>
- zaimplementowanie odpowiedniej logiki biznesowej w ramach obsługi żądania <code>GET</code>, po otrzymaniu którego serwer zwróci odpowiedź: <br/>

W ten sposób otrzymamy gotowy projekt bazowy dla dowolnej aplikacji webowej obsługującej typowy proces komunikacji: <br/><br/>
Interfejs Użytkownika  <span class="glyphicon glyphicon-circle-arrow-right" style="height: 24px; font-size: 22px; top: 5px;"></span> 
wysłanie HTTP Request  <span class="glyphicon glyphicon-circle-arrow-right" style="height: 24px; font-size: 22px; top: 5px;"></span> 
przyjęcie HTTP Request przez Spring Controller  <span class="glyphicon glyphicon-circle-arrow-right" style="height: 24px; font-size: 22px; top: 5px;"></span> 
rozpoczęcie przetwarzania danych przez serwis  <span class="glyphicon glyphicon-circle-arrow-right" style="height: 24px; font-size: 22px; top: 5px;"></span> 
wykonanie operacji na bazie przez Spring Repository  <span class="glyphicon glyphicon-circle-arrow-right" style="height: 24px; font-size: 22px; top: 5px;"></span> 
zakończenie przetwarzania danych przez serwis  <span class="glyphicon glyphicon-circle-arrow-right" style="height: 24px; font-size: 24px; top: 5px;"></span> 
wysłanie HTTP Response przez Spring Controller  <span class="glyphicon glyphicon-circle-arrow-right" style="height: 24px; font-size: 22px; top: 5px;"></span> 
Interfejs Użytkownika

Po poprawnym wykonaniu wszystkich kroków powinien powstać projekt zgodny z tym, którego udostępniamy do ściągnięcia poniżej. Jeśli to Wasze pierwsze kroki w Spring Boot, to
proponujemy w pierwszej kolejności pobranie projektu, a następnie odnalezienie wszystkich elementów wskazanych powyżej.

<div class="vertical-box-30"></div>
<h2>Kod źródłowy </h2>
</div>

package com.javappa.postspringboot.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.javappa.postspringboot.dto.ItemDTOResponse;
import com.javappa.postspringboot.service.ItemService;

@RestController
@RequestMapping("/api/items")
public class ItemController {

private ItemService itemService;
    
    @Autowired
    public ItemController(ItemService itemService) {
        this.itemService = itemService;
    }
    
    @PostMapping
    public ResponseEntity<Void> create() throws Exception {
        return new ResponseEntity<Void>(HttpStatus.NO_CONTENT);
    }

@GetMapping
    public ResponseEntity<List<ItemDTOResponse>> read() throws Exception {
        return new ResponseEntity<List<ItemDTOResponse>>(itemService.getItems(), HttpStatus.OK);
    }

@PutMapping
    public ResponseEntity<Void> update() throws Exception {
        return new ResponseEntity<Void>(HttpStatus.NO_CONTENT);
    }

@DeleteMapping
    public ResponseEntity<Void> delete() throws Exception {
        return new ResponseEntity<Void>(HttpStatus.NO_CONTENT);
    }
}

package com.javappa.postspringboot.domain;

import java.io.Serializable;
import java.util.Date;
import java.util.Objects;

import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.MappedSuperclass;
import javax.persistence.PrePersist;
import javax.persistence.PreUpdate;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

import org.springframework.data.domain.Persistable;

@MappedSuperclass
public abstract class AbstractEntity<ID extends Serializable> implements Persistable<ID> {

@Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(unique = true, nullable = false)
    private ID id;
    
    @Column(name = "creation_date")
    @Temporal(TemporalType.TIMESTAMP)
    private Date creationDate;

@Column(name = "modification_date")
    @Temporal(TemporalType.TIMESTAMP)
    private Date modificationDate;

@Override
    public ID getId() {
        return id;
    }

public void setId(ID id) {
        this.id = id;
    }

@Override
    public boolean isNew() {        
        return null == getId();
    }

@Override
    public int hashCode() {
        return Objects.hash(id);
    }

@Override
    public boolean equals(Object o) {

if (this == o) {
            return true;
        }
        if (!(o instanceof AbstractEntity)) {
            return false;
        }
        AbstractEntity<?> that = (AbstractEntity<?>) o;

return Objects.equals(id, that.id);
    }
    
    @PrePersist
    protected void onCreate() {
        
        if (this.creationDate == null) {
            Date currentDate = new Date();
            this.creationDate = currentDate;
            this.modificationDate = currentDate;
        }
    }

@PreUpdate
    protected void onUpdate() {
        this.modificationDate = new Date();
    }

@Override
    public String toString() {
        
        return String.format("Entity of type %s with id: %s", this.getClass().getName(), getId());
    }
}

Autor: Jarek Klimas
Data: 04 lipca 2018
Labele:Backend, Poziom podstawowy, Java, Spring, Spring Boot, Maven

Masz swoje przemyślenia na temat artykułu? Podziel się nimi!

Masz pytanie odnośnie zagadnienia omawianego w artykule?
Coś, co napisaliśmy, nie zaspokoiło Twojego głodu wiedzy?

Daj nam znać co myślisz i skomentuj artykuł na facebooku!

www.facebook.com/javappa

Zapisz się do newslettera :

Stale się rozwijamy, a więc bądź na bieżąco!
Na ten adres będziemy przesyłać informacje o ważniejszych aktualizacjach, a także o nowych materiałach pojawiających się na stronie.

Polub nas na Facebooku:

Nasi partnerzy:

stackshare

Javappa to również profesjonalne usługi programistyczne oparte o technologie JAVA. Jeśli chesz nawiązać z nami kontakt w celu uzyskania doradztwa bądź stworzenia aplikacji webowej powinieneś poznać nasze doświadczenia.
Kliknij O nas .

Starter Jak to działa Aplikacja

Obserwuj nas Polityka Cookies Regulamin Licencja Ochrona prywatności

Pozycjonowanie stron: Grupa TENSE