Programowanie

Rozliczenie pojazdu REST, JDBC, MySQL. Zaczynamy drugi projekt z wykorzystaniem wcześniej zbudowanej bazy danych. Jest to prostsza wersja komunikacji z bazą danych wbudowana w Spring Boot. Zaletą jest prostota budowy zapytań, jednak wadą jest fakt, że nie da się jej zastosować do bardziej wymagających zapytań. Jednak w naszym prostym projekcie zupełnie wystarczy. Tak jak w przypadku pierwszego projektu wykorzystamy wzorzec projektowy REST API i stworzymy aplikację pozwalające na komunikację klient – server. Tak samo, jak w artykule Rozliczenie pojazdu REST MyBatis nie będzie to w pełni działająca aplikacja. Pozwoli to porównać, jakie należy wprowadzić zmiany w zależności od zastosowanego sposobu komunikacji z bazą danych. Część front end powstanie w innym artykule.

Rozliczenie pojazdu REST JDBC – Tworzymy projekt

Zacznijmy od stworzenia nowego projektu. Na początku wejdę na stronę https://start.spring.io/, gdzie utworzę nasz projekt. W moim przypadku będzie on wyglądał następująco.

Rozliczenie pojazdu REST JDBC – Budowa projektu

Konfiguracja projektu

W pierwszej kolejności będziemy dodawać odpowiednie biblioteki, dzięki którym w naszym projekcie będzie można korzystać z REST, JDBC oraz MySQL. Przechodzimy do pliku pom.xml i dodajemy do sekcji dependences następujące elementy.

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

Pierwsze dwie sekcje dependencji informuje Spring, że ta aplikacja ma być aplikacją webową, czyli po jej uruchomieniu ma ciągle nasłuchiwać w oczekiwaniu na żądania. Trzecią to sterownik bazy danych MySQL. Czwarta dodaje bibliotekę JDBC. Jak porównamy wcześniejszy artykuł, zmiana jest tylko w ostatnim zapisie.

Kolejnym krokiem jest skonfigurowanie bazy danych. W tym celu edytujemy plik application.property i dodajemy odpowiednie linijki.

spring.datasource.url=jdbc:mysql://localhost:3306/transportMyBatis?serverTimezone=UTC
spring.datasource.username=transportMyBatis
spring.datasource.password=transportMyBatis

logging.file=log/transportMyBatis.log
server.port=8091

Jak widać, korzystamy z bazy danych stworzonych przy okazji wcześniejszego artykułu, jednak w tym przypadku nie ma to znaczenia.

Teraz zaczynamy wykorzystywać JDBC.

W przypadku JDBC tworzymy tylko klasę TransportDB w schemacie db. W klasie będziemy przechowywać wszystkie metody wraz z zapytaniami.

package pl.lomza.programowanie.rozliczenie_pojazdu_rest_jdbc.db;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import pl.lomza.programowanie.rozliczenie_pojazdu_rest_jdbc.common.Ride;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class TransportDB {
    private final static Logger log= LoggerFactory.getLogger(TransportDB.class);
    private final NamedParameterJdbcTemplate template;
    private final BeanPropertyRowMapper<Ride> rideMapper = BeanPropertyRowMapper.newInstance(Ride.class);

    public TransportDB(NamedParameterJdbcTemplate template) {
        this.template = template;
    }


    public List<Ride> getRides(long vehicleId) {
        log.info("List rides");
        return template.query(
                "SELECT r.id, r.rideDate, r.counterBefore, r.counterAfter, r.km, " +
                        "r.whence, r.`where`, r.rideKind, r.fuelCondition, r.fuelAdd, r.fuelAfter, " +
                        "SUM(s.fuel) as fuel, f.price, SUM(s.fuel*f.price) as currency, r.fuelNorm " +
                        "FROM transportMyBatis.Ride r " +
                        "LEFT JOIN transportMyBatis.Settlement  s on r.id = s.idRide " +
                        "LEFT JOIN transportMyBatis.Refuel f on f.id = s.idRefuel " +
                        "WHERE r.idVehicle = :vehicleId "+
                        "GROUP BY r.id, r.whence, r.`where`, r.rideKind, f.price " +
                        "ORDER BY r.id ",
                new MapSqlParameterSource("vehicleId", vehicleId), rideMapper);
    }

    public Ride getRide(long vehicleId,  long rideId) {
        log.info("Object ride");
        Map<String, String> map = new HashMap<>();
        map.put("vehicleId", Long.toString(vehicleId));
        map.put("rideId", Long.toString(rideId));
        return template.queryForObject(
                "SELECT r.id, r.rideDate, r.counterBefore, r.counterAfter, r.km, " +
                        "r.whence, r.`where`, r.rideKind, r.fuelCondition, r.fuelAdd, r.fuelAfter, " +
                        "SUM(s.fuel) as fuel, f.price, SUM(s.fuel*f.price) as currency, r.fuelNorm " +
                        "FROM transportMyBatis.Ride r " +
                        "LEFT JOIN transportMyBatis.Settlement  s on r.id = s.idRide " +
                        "LEFT JOIN transportMyBatis.Refuel f on f.id = s.idRefuel " +
                        "WHERE r.idVehicle = :vehicleId and r.id = :rideId " +
                        "GROUP BY r.id, r.whence, r.`where`, r.rideKind, f.price " +
                        "ORDER BY r.id",
                map, rideMapper);
    }
}

Uwaga: W razie problemów z bazą danych należy sprawdzić w każdym zapytaniu, czy na końcu linii jest pusty znak. Jeżeli go zabraknie, zapytanie się nie wykona.

To wystarczy do komunikacji z bazą danych. Teraz musimy podłączyć to do naszego kontrolera. Robimy to w następujący sposób:

package pl.lomza.programowanie.rozliczenie_pojazdu_rest_jdbc.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import pl.lomza.programowanie.rozliczenie_pojazdu_rest_jdbc.common.Ride;
import pl.lomza.programowanie.rozliczenie_pojazdu_rest_jdbc.db.TransportDB;

import java.util.List;

@RestController
public class TransportController {
    private final static Logger log = LoggerFactory.getLogger(TransportController.class);
    private final TransportDB transportDB;

    public TransportController(TransportDB transportDB) {
        this.transportDB = transportDB;
    }

    @GetMapping("/vehicle/{vehicleId}/rides")
    public List<Ride> getRides(@PathVariable("vehicleId") long vehicleId) {
        log.info("Wyświetlamy listę przejazdów");
        return transportDB.getRides(vehicleId);
    }
    @GetMapping("vehicle/{vehicleId}/ride/{rideId}")
    public Ride getRide(@PathVariable("vehicleId") long vehicleId, @PathVariable("rideId") long rideId) {
        log.info("Wyświetlamy przejazd");
        return transportDB.getRide(vehicleId, rideId);
    }
}

Jednak jest tu w porównaniu do artykułu z Rozliczenie pojazdu REST MyBatis mała zmiana. Wcześniej przy czytywaniu interfejsu TransportDAO używaliśmy @Autowired. Tym razem jednak robimy to przez konstruktor. Obie metody są dobre, ale ogólnie preferowana jest metoda przez konstruktor. Jest to związane przede wszystkim z testowaniem aplikacji. Dlatego teraz właśnie takie podejście zaprezentowałem.

Pokażemy jeszcze, jak wygląda klasa Ride:

public class Ride {
    private long id;
    private LocalDate rideDate;
    private int counterBefore;
    private int counterAfter;
    private int km;
    private String whence;
    private String where;
    private String rideKind;
    private double fuelCondition;
    private double fuelAdd;
    private double fuelAfter;
    private Double fuel;
    private Double price;
    private Double currency;
    private double fuelNorm;

    public long getId() {
        return id;
    }
    public void setId(long id) {
        this.id = id;
    }
    public LocalDate getRideDate() {
        return rideDate;
    }
    public void setRideDate(LocalDate rideDate) {
        this.rideDate = rideDate;
    }
    public int getCounterBefore() {
        return counterBefore;
    }
    public void setCounterBefore(int counterBefore) {
        this.counterBefore = counterBefore;
    }
    public int getCounterAfter() {
        return counterAfter;
    }
    public void setCounterAfter(int counterAfter) {
        this.counterAfter = counterAfter;
    }
    public int getKm() {
        return km;
    }
    public void setKm(int km) {
        this.km = km;
    }
    public String getWhence() {
        return whence;
    }
    public void setWhence(String whence) {
        this.whence = whence;
    }
    public String getWhere() {
        return where;
    }
    public void setWhere(String where) {
        this.where = where;
    }
    public String getRideKind() {
        return rideKind;
    }
    public void setRideKind(String rideKind) {
        this.rideKind = rideKind;
    }
    public double getFuelCondition() {
        return fuelCondition;
    }
    public void setFuelCondition(double fuelCondition) {
        this.fuelCondition = fuelCondition;
    }
    public double getFuelAdd() {
        return fuelAdd;
    }
    public void setFuelAdd(double fuelAdd) {
        this.fuelAdd = fuelAdd;
    }
    public double getFuelAfter() {
        return fuelAfter;
    }
    public void setFuelAfter(double fuelAfter) {
        this.fuelAfter = fuelAfter;
    }
    public Double getFuel() {
        return fuel;
    }
    public void setFuel(Double fuel) {
        this.fuel = fuel;
    }
    public Double getPrice() {
        return price;
    }
    public void setPrice(Double price) {
        this.price = price;
    }
    public Double getCurrency() {
        return currency;
    }
    public void setCurrency(Double currency) {
        this.currency = currency;
    }
    public double getFuelNorm() {
        return fuelNorm;
    }
    public void setFuelNorm(double fuelNorm) {
        this.fuelNorm = fuelNorm;
    }
}

Jeszcze jeden element od pokazania mianowicie główny plik projektu trochę się zmienił, więc go prezentujemy.

package pl.lomza.programowanie.rozliczenie_pojazdu_rest_jdbc;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import pl.lomza.programowanie.rozliczenie_pojazdu_rest_jdbc.db.TransportDB;
import javax.sql.DataSource;

@SpringBootApplication
public class RozliczeniePojazduRestJdbcApplication {
	public static void main(String[] args) {
		SpringApplication.run(RozliczeniePojazduRestJdbcApplication.class, args);
	}
	@Bean
	public TransportDB transportDB(NamedParameterJdbcTemplate template){
		return new TransportDB(template);
	}
	@Bean
	public PlatformTransactionManager transactionManager(DataSource dataSource)
	{
		return new DataSourceTransactionManager(dataSource);
	}
}

Tak wygląda cała aplikacja z wykorzystaniem JDBC. Pozostało nam wszystko przetestować i powinno działać. Jeżeli jednak nie działa, warto podejrzeć, jak ja to zrobiłem. Zapraszam na mojego GitHub pod adresem:

https://github.com/grzegorzkossa/rozliczenie_pojazdu_rest_jdbc

To jednak nie koniec. W następnym artykule pokaże jak te samo zadanie wykonać przy wykorzystaniu JPA. Zapraszam do kolejnego artykułu.

Rozliczenie pojazdu aktualizacja do bazy. Zajmiemy się aktualizacją danych w tabeli. Jest to drugi element budowy projektu, a zarazem będzie nam potrzebny, w dalszych artykułach.

Rozliczenie pojazdu aktualizacja – wprowadzenie

Za aktualizację w bazie odpowiada instrukcja update. Przykład zastosowania instrukcji update to:

UPDATE [nazwa bazy].[nazwa tabeli]
SET [kolumna 1]=[wartość 1], [kolumna 2]=[wartość 2]
WHERE id=[wartość ID];

Nasza tabela może zawierać wiele kolumn. Jednak aktualizacja ma dotyczyć tylko dwóch z nich. Nie ma potrzeby wpisywania danych do kolumn, które nie wymagają aktualizacji. Możliwe jest również aktualizowanie jednej kolumny, pozostawiamy wtedy wartość kolumna 1 i wartość 1 a przecinek i kolumna 2 i wartość 2 usuwamy. Jeżeli jest potrzeba dodania kolejnych kolumn, rozdzielamy je przecinkiem. W większości przypadków są również kolumny, których nie powinno się zmieniać nigdy. Do takich kolumn należy na przykład createDate. Przechowujemy w niej datę utworzenia wpisu, więc jeżeli jest nam potrzebna informacja o ostatniej aktualizacji, lepszym rozwiązaniem jest dodanie kolejnej kolumny.

Rozliczenie pojazdu aktualizacja – zapytania

Tabela Person (osoba)

Aktualizujemy dane o osobie:

UPDATE transportMyBatis.Person
SET firstName='Janek', lastName='Kowalski'
WHERE id=1;

W przypadku tabeli Person zmieniamy wartości obydwu kolumn, czyli zarówno imie, jak i nazwisko. Jednak w rzeczywistości może istnieje potrzeba zmiany tylko jednej z nich, wtedy należy skorygować odpowiednio zapytanie, tak jak opisałem to we wstępie. Istnieje również możliwość podania w zmiennej wartości null i w samym zapytania sprawdzenie, czy dane są null, a jeżeli tak to pominięcie tej kolumny aktualizacji. To rozwiązanie zależy od bazy danych.

Tabela Vehicle (pojazd)

UPDATE transportMyBatis.Vehicle
SET registrationNumber='LMA4521', mark='Opel'
WHERE id=1;

W tabeli pojazd również aktualizujemy jedynie dwie wartości, czyli markę samochodu oraz numer rejestracyjny. Pozostałe dane powinny zostać bez zmian.

Tabela Ride (przejazd)

UPDATE transportMyBatis.Ride
SET rideDate=' 2020-04-12', counterBefore=12200, counterAfter=12346, km=146, whence='Łomża', `where`='Warszawa', rideKind='Dojazd do pracy', fuelCondition=60, fuelAdd=0, fuelAfter=51.9, fuelConsumed=8.1, fuelNorm=5.7
WHERE id=1;

W przejazdach jest już więcej kolumn do aktualizacji. Jednak w przykładach w dalszych artykułach będziemy przygotowywać takie dane, które będą nam potrzebne w danej sytuacji. Możemy chcieć pozostawić normę spalania ustawioną na null i dopiero po jakimś czasie synchronizator uzupełnia tę wartość.

Tabela Refuel (tankowanie)

UPDATE transportMyBatis.Refuel
SET name='', counterBefore=11950, counterAfter=12675, km=725, refuel=44.7, price=4.40, value=196.7, fuelNorm=6.2
WHERE id=1;

W naszym przykładzie aktualizujemy tylko wybrane kolumny. Przy tworzeniu już konkretnego rozwiązania pozmieniamy ilość aktualizowanych kolumn w zależności do potrzeb. Jednak na razie wybraliśmy tylko te, których aktualizacja ma sens.

Tabela Settlement ()

UPDATE transportMyBatis.Settlement
SET fuel=6.4
WHERE id=1;

Teraz aktualizujemy zużycie paliwa na 100 kilometrów. Pozostałe identyfikatory pozostawiamy bez zmian.

Zapraszam do kolejnych artykułów rozliczenie pojazdu aplikacja.

Rozliczenie pojazdu zapis do bazy. Zajmiemy się dodawaniem danych do tabel. Jest to nam potrzebne, do dalszych artykułów.

Rozliczenie pojazdu zapis – zapytania

Za zapis do bazy odpowiada instrukcja insert. Przykład zastosowania instrukcji insert to:

INSERT INTO [nazwa bazy].[nazwa tabeli]
([kolumna 1], [kolumna 2], ...)
VALUES([wartość 1, [wartość 2], ...);

W przykładnie zastosowałem dwie kolumny i żyłem trzech kropek, które świadczą, że kolumn może być więcej. Jednak faktycznie najmniej może być jedna kolumna.

Tabela Person (osoba)

Dodajemy dane o osobie:

INSERT INTO transportMyBatis.Person
(firstName, lastName)
VALUES('Jan', 'Kowalski');

Jak pamiętamy ze wcześniejszego artykułu, tabela zawiera trzy kolumny a w naszym zapisie mamy tylko dwie. Wiemy jednak, że brakująca kolumna to Id. Kolumna Id jest kolumną tworzoną automatycznie, przy tworzeniu rekordu. Dlatego uzupełnianie jej nie jest potrzebne.

Tabela Vehicle (pojazd)

INSERT INTO transportMyBatis.Vehicle
(idPerson, createDate, registrationNumber, mark)
VALUES(1, '2020-04-12 17:34:51.0', 'LOM4521', 'Opel');

Tym razem również brakuje kolumny id, która utworzy się automatycznie. Mamy dodatkowo relacje do tabeli Person. Jak pamiętasz, IdPerson jest powiązany z tabelą Person. Wskazuje na pierwszego użytkownika aplikacji, czyli w naszym przypadku samochód należy do Jana Kowalskiego, jak wynika z utworzonego pierwszego wpisu do tabeli Person.

Tabela Ride (przejazd)

INSERT INTO transportMyBatis.Ride
(idVehicle, createDate, rideDate, counterBefore, counterAfter, km, whence, `where`, rideKind, fuelCondition, fuelAdd, fuelAfter, fuelConsumed, fuelNorm)
VALUES(1, '2020-04-12 17:34:51.0', '2020-04-12 00:00:00.0', 12200, 12346, 146, 'Łomża', 'Warszawa', 'Dojazd do pracy', 60, 0, 51.9, 8.1, 5,7);

Jak widzimy w tym zapisie, przejazd jest połączony z pojazdem (kolumna 1). W drugiej kolumnie mamy datę utworzenia wpisu. Trzecia kolumna to data przejazdu.

Kolejne trzy kolumny to stan początkowy licznika, stan końcowy i ilość przejechanych kilometrów. Następnie mamy dane dotyczące skąd jedziemy, gdzie i w jakim celu. Ostanie pięć kolumn dotyczy rozliczenia tankowania. Dziesiąta to stan początkowy paliwa, jedenasta ilość zatankowanych litrów a dwunasta to stan po zakończeniu przejazdu. Kolejna kolumna mówi, ile zużyliśmy paliwa, Ostania jest to zużycie na sto kilometrów.

Tabela Refuel (tankowanie)

INSERT INTO transportMyBatis.Refuel
(idVehicle, idRide, createDate, refuelDate, name, counterBefore, counterAfter, km, refuel, price, value, fuelNorm)
VALUES(0, 0, '', '', '', 0, 0, 0, 0, 0, 0, 0);

W kolumnie tankowanie przechowujemy wszystkie informacje związane z zakupem paliwa. Tabela jest powiązana z tabelami projazd i przejazd, w relacji jeden do wielu. Dodajemy również dany zakupu i datę utworzenia wpisu.

Teraz zaczyna się coś bardziej interesującego. Mianowicie stan licznika od ostatniego tankowania oraz stan licznika przy tankowaniu. Dzięki tym kolumnom możemy wyliczyć, ile przejechaliśmy kilometrów. Te dane będą nam potrzebne do wyliczenia zużycia paliwa w ostatniej kolumnie. Pozostałe kolumny to ilość zatankowanego paliwa, cena oraz wartość. Dzięki tym informacjom możemy określić, ponoszone koszty. Takie zestawienia przygotujemy w artykule pobieranie danych.

Tabela Settlement ()

INSERT INTO transportMyBatis.Settlement
(idVehicle, idRide, idRefuel, createDate, fuel)
VALUES(1,1, 1, '2020-04-12 17:34:51.0', 6.3);

Została już nam ostatnia tabela. Ta tabela przyda się nam przy rozliczeniach. Dzięki niej będziemy w stanie określić, ile kosztował nas każdy kurs.

Zapraszam do kolejnych artykułów rozliczenie pojazdu aplikacja.