Spring Boot karkasas

M.Gžegoževskis ... 2021-10-01 Java
  • Programavimas
  • Java
About 7 min

Spring karkasas sudarytas iš apie 20 astkirų modulių skirtų kurti programinę įranga naudojant Java (opens new window) kalbos plain old Java (opens new window) objects (POJO). Tai įgalina galimybę prisitaikyti prie Java (opens new window) SE modelio programavimo ir pilnai arba dalinai kuriant JAVA (opens new window) EE programinę įrangą skirtą įmonėms. Spring platformos/karkaso nauda:

  • Neturint transaction API (opens new window) vykdyti duomenų bazės tranzakcijas.
  • Sukurti metodą, kuris atlieka prisijungimą prie nutolosios paslaugos neturint nuotolinio prisijungimo API (opens new window).
  • Sukurti žiniučių apdorojimo metodą be papildomo JMS API (opens new window) panaudojimo.
  • Daugelis populiariausių paslaugų yra numatyta su šiuo karkasu pvz. Monitoringo programa, greitas Web servisų sūkurimas ir paleidimas pvz. REST API (opens new window), mikroservisų sukūrimas, jar archyvo sukūrimas, kuriame yra visa reikiama konfigūracija: Aplikacijų serveris, duomenų bazė ir papildomi įrankiai paleisti programinei įrangai.

Spring karkaso sandara žiūrėti 5.1 paveikslėlį.

Related image

5.1 pav. Spring karkaso sandara

Spring projekto kurimas yra gan paprastas kadangi tai yra suderinama su Maven ir Gradle projekto kūrimo įrankiais.

Naudojantiems Maven konfigūraciją sukurti minimalią Spring Web aplikaciją pakanka pridėti startinį bibliotekų rinkinį "spring-boot-starter-web":

<parent>
    <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.1.RELEASE</version>
</parent>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>
1
2
3
4
5
6
7
8
9
10
11

Gradle naudotojiems analogiškai bus sukurta Spring Web aplikacija pridėjus startinį bibliotekų rinkinį "spring-boot-starter-web":

dependencies {
  compile("org.springframework.boot:spring-boot-starter-web:1.5.1.RELEASE")
}
1
2
3

Pradedantiesiems naudoti Spring karkasą rekomenduojama sukurti pirmąją aplikaciją naudojant Spring Boot. Spring Boot yra spartus būdas kurti aplikacijas Spring karkaso pagrindu, kurios yra paruoštos produkcijai. Projekto konfigūravimas vietoje programinio kodo rašymo tai siūlo Spring Boot. Taip yra paspartinamas procesas kurti Spring aplikacijas kiek įmanoma greičiau.

Nuo ko pradėti plačiau pasiskaityti galite pagal dominančią sritį oficialioje Spring karkaso svetainėje kur yra pateikti aplikacijų pavyzdžiai su detaliomis pamokomis ir programinio kodo pavyzdžiais rasite čia: https://spring.io/guides (opens new window).

Modernios programavimo aplinkos IDE turi galimybę pasirinkti dažniausiai naudojamas bibliotekas pasirenkant iš duoto sąrašo naudojant Spring Initializr įrankį. Įrankis skirtas sugeneruoti Spring Boot startinį projektą su pasirinktomis bibliotekomis. Jeigu Spring Initializr nėra įdiegtas, galima naudotis šio įrankio internetinę versiją ir sukurti projektą, kuris yra atsiunčiamas ir paleidžiamas naudojantis Maven arba Gradle įrankiu. Detaliau Spring Initializr įrankį galite panagrinėti šiuo adresu: http://start.spring.io/ (opens new window).

Naudojantis Spring DATA kuriant REST API (opens new window), įprastinės SQL užklausos yra aprašomos naudojant Java (opens new window) interfeisą ir SQL užklausa yra aprašoma tiesiog metodo pavadinime:

@RepositoryRestResource
interface ClassRoomRepository extends CrudRepository<ClassRoom, Long>{
  List<ClassRoom> findByEmployeesFirstNameContains(@Param("q")String firstName);
}
@RepositoryRestResource
  interface EmployeeRepository extends CrudRepository<Employee, Long>{
    List<Employee> findTop5ByFirstName(@Param("q") String firstName);
    List<Employee> findDistinctByRoleNotIn(@Param("pareigos") String role);
}
1
2
3
4
5
6
7
8
9

Plačiau apie Spring Data - https://www.youtube.com/watch?v=wZKmA6XodNE (opens new window)

Norint sukurti Web aplikaciją su grafine vartotojo sąsaja naudojant Spring Boot karkasą yra naudojamas įprastinis MVC projektavimo šablonas. Modelis tai paprastas Java (opens new window) POJO. Vaizdas (angl. View) yra naudojami template engines, kurių yra labai daug. Pasirinktinai galite rinktis bet kurį iš siūlomų variklių skirtų kurti grafinę vartotojo sąsają:

JSP + JSTL (opens new window), Thymeleaf (opens new window), Freemarker (opens new window), Handlebars (opens new window), jtwig (opens new window), Velocity (opens new window), HTTL (opens new window), Scalate (opens new window), Jade (opens new window), Mustache - Based on JMustache (opens new window), Pebble (opens new window) ir kiti.

Kad atvaizuoti vaizdą naršyklėje reikia duomenų iš "BackEnd", šie duomenis yra perduodami Controller pagalba į View. IntelliJ IDEA pagal nutylėjimą kuriant Spring Boot projektą yra siūlomas Thymeleaf šablonų variklis. Štai taip atrodo šio šablonų variklio View dokumentas:

<div>
  <form class="form-horizontal" th:object="${product}" th:action="@{/product}"method="post">
  <input type="hidden" th:field="*{id}"/>
  <input type="hidden" th:field="*{version}"/>
  <div class="form-group">
    <label class="col-sm-2 control-label">Description:</label>
    <div class="col-sm-10">
     <input type="text" class="form-control" th:field="*{description}"/>
</div>
1
2
3
4
5
6
7
8
9

Įvykdžius šį programinį kodą bus atvaizduotas šis vaizdas žr. 5.3 pav.

5.3. pav. Thymeleaf šablonų variklio rezultatas

Kaip sukurti Spring Web MVC projektą galite vadovautis šiuo pavyzdžiu: https://springframework.guru/spring-boot-web-application-part-4-spring-mvc/ (opens new window). Arba vadovautis šiais žingsniais:

  • Pasirinkti programinę įrangą pvz: IntelliJ IDEA.
    1. Pasirinkti projektų kūrimo įrankį: Maven, Gradle ar kitą, startinę konfigūraciją galima rasti oficialioje svetainėje: https://spring.io/guides (opens new window).
    2. Siūloma konfigūracija (žr. 5.4 pav.):
    • Web - Full Stack programa.

    • Lombok - kuriant entity nereikia get/set.

    • Security - apribojimai ir papildomos funkcijos.

    • Thymeleaf - varyklis generuoti šablonus/html.

    • JPA - Java (opens new window) persistence API (opens new window) sąsaja su DB.

    • MySQL - duomenų bazė.

    • DevTools - Nereikia perkrauti visos programos iš naujo.

      5.4 pav. Siūlomas Spring Initializr įrankio bibliotekų sąrašas

    1. applications.properties dokumente priklausomai nuo pasirinktos duomenų bazės, nurodyti prisijungimo informacija:

      spring.datasource.url=jdbc:mysql://localhost:3306/test
      spring.datasource.username=root
      spring.datasource.password=slaptažodis
      spring.datasource.driverClassName=com.mysql.jdbc.Driver
      
      1
      2
      3
      4
    • Naudojantis IntelliJ IDEA spausti:View > Tool windows > Database,

      Iššokusiame lange pasirinkti + simbolį prijungti savo egzistuojančią arba naują duomenų bazę.

      Papildomai privalote atnaujinti savo Maven ar Gradle dependency, jeigu keitėte duomenų bazę ar norite pakeisti į kitą.

      Pastaba! Įvykdyti savo programą ir įsitikinti jog viskas sklandžiai veikia.

      http://localhost:8080/ (opens new window) - pagal nutylėjimą, kadangi naudojama Security yra:

      Prisijungimo vardas: user;

      Slaptažodis: default security password: 263196a4-313b-4d19-919c-97aebbbce72e (Rasite konsolėje kompiliuojant savo programą).

    • sukurti klasę Security ir ją įkelti į configuration package

      @Configuration
      public class Security extends WebSecurityConfigurerAdapter{
        @Override
        protected void configure(HttpSecurity http) throws Exception {
          http.authorizeRequests().antMatchers("/").permitAll();
          http.csrf().disable();
          http.headers().frameOptions().disable();
        }
      }
      
      1
      2
      3
      4
      5
      6
      7
      8
      9
    • Siūloma sukurti Java (opens new window) Packages taip sudarant projekto struktūrą:

    • Domain package sukurti Entity (Modelis) priklausomai nuo pasirinktos temos pavyzdžiui: Gyvunas.java (opens new window), kadangi naudojama Lombok įprastinis Java (opens new window) POJO atrodo ženkliai paprastesnis:

      @Data
      @Entity
      public class Gyvunas {
        @Id @GeneratedValue Long id;
        private String amzius;
        private String pavadinimas;
        protected Gyvunas(){}
        public Gyvunas(String amzius, String pavadinimas) {
          this.amzius = amzius;
          this.pavadinimas = pavadinimas;
        }
      }
      
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
    • Sukurti repozitoriją **GyvunasRepository.java (opens new window)**ir ją patalpinti į repositories package:

      interface GyvunasRepository extends CrudRepository<Gyvunas, Long>{}
      
      1
    • Service kataloge sukurti interfeisą: GyvunasService.java (opens new window) ir jo įgyvendinimą: GyvunasServiceImpl.java (opens new window):

      interface GyvunasService {
        Iterable<Gyvunas> atvaizduotiGyvunus();
        Gyvunas gyvunasPagalId(Integer id);
        Gyvunas issaugotiGyvuna(Gyvunas gyvunas);
        void panaikintiGyvuna(Integer id);
      }
      
      1
      2
      3
      4
      5
      6
      @Service 
      class GyvunasServiceImpl implements GyvunasService{
        private GyvunasRepository gyvunasRepository;
        @Autowired
        public void setGyvunasRepository(GyvunasRepository gyvunasRepository) {
          this.gyvunasRepository = gyvunasRepository;
        }
        @Override
        public Iterable<Gyvunas> atvaizduotiGyvunus() {
          return gyvunasRepository.findAll();
        }
        @Override
        Gyvunas gyvunasPagalId(Integer id){
          return gyvunasRepository.findOne(id);
        }
        @Override 
        Gyvunas issaugotiGyvuna(Gyvunas gyvunas){
          return gyvunasRepository.save(gyvunas);
        }
        @Override 
        void panaikintiGyvuna(Integer id){
          return gyvunasRepository.delete(id);
        }
      }
      
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
    • Sukurti klasę UzpildomDuomenimis.java (opens new window) skirtą užpildyti duomenų bazę testiniais duomenimis:

      @Component
      public class UzpildomDuomenimis implements ApplicationListener<ContextRefreshedEvent>{
        private GyvunasRepository gyvunasRepository;
        @Autowired
        public void setGyvunasRepository(GyvunasRepository gyvunasRepository) {
          this.gyvunasRepository = gyvunasRepository;
        }
        @Override
        public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
          for (int i = 0; i < 15; i++)
            gyvunasRepository.save(new Gyvunas("belekas", "Lape"+i));
        }
      }
      
      
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
    • Patikrinti ar jūsų duomenų bazė yra užpildoma duomenimis, tada pereiti į tolimesnį žingsnį Controllers package sukurti naują kontrolerio klasę IndexController.java (opens new window):

      @Controller
      public class IndexController {
        @RequestMapping("/")
        String index(){
          return "index";
        }
      }
      
      1
      2
      3
      4
      5
      6
      7
    • templates kataloge sukurti index.html. Paleisti projektą ir naršyklėje patrikrinti ar veikia internetinė svetainė ir atvaizduoja index.html turinį: http://localhost:8080/ (opens new window)

    • Sukurti fragments katalogą ir jame sukurti 2 failus: Headerinc.html -> privalomas naudojant Thymeleaf template engine ir Header.html:

    • headerinc.html turinys:

      <!DOCTYPE html>
      <html xmlns:th="http://www.thymeleaf.org">
      <head lang="en" th:fragment="head">
       <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
       <link href="http://cdn.jsdelivr.net/webjars/bootstrap/3.3.4/css/bootstrap.min.css"
       th:href="@{/webjars/bootstrap/3.3.4/css/bootstrap.min.css}"
       rel="stylesheet" media="screen" />
       <script src="http://cdn.jsdelivr.net/webjars/jquery/2.1.4/jquery.min.js"
       th:src="@{/webjars/jquery/2.1.4/jquery.min.js}"></script>
       <link href="../static/css/guru.css"
       th:href="@{/css/guru.css}" rel="stylesheet" media="screen"/>
      </head>
      
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
    • header.html turinys:

      <!DOCTYPE html>
      <html xmlns:th="http://www.thymeleaf.org">
      <head lang="en">
      </head>
      <body>
      <div class="container">
       <div th:fragment="header">
       <nav class="navbar navbar-default">
       <div class="container-fluid">
       <div class="navbar-header">
       <a class="navbar-brand" href="#" th:href="@{/}">Home</a>
       <ul class="nav navbar-nav">
       <li><a href="#" th:href="@{/products}">Products</a></li>
       <li><a href="#" th:href="@{/product/new}">Create Product</a></li></ul>
       </div>
       </div>
       </nav>
       <div class="jumbotron">
       <div class="row text-center">
       <div class="">
       <h2>Spring karkasas</h2>
       <h3>Spring Boot Web Aplikacija</h3>
       </div>
       </div>
       <div class="row text-center">
       <img src="../../static/images/NewBannerBOOTS_2.png" width="400"
       th:src="@{/images/NewBannerBOOTS_2.png}"/>
       </div>
       </div>
       </div>
      </div>
      </body>
      </html>
      
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
    • index.html turinys:

      <!DOCTYPE html>
      <html>
      <head lang="en">
      <title>Spring Framework Guru</title>
      <!--/*/ <th:block th:include="fragments/headerinc :: head"></th:block> /*/-->
      </head>
      <body>
      <div class="container">
      <!--/*/ <th:block th:include="fragments/header :: header"></th:block> /*/-->
      </div>
      </body>
      </html>
      
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
    • Sukurti antrą kontrolerį, kurio pagalba atvaizduosime gyvūnų sąrašą:

      @Controller
      public class GyvunasController {
        private GyvunasService gyvunasService;
        @Autowired
        public void setProductService(GyvunasService gyvunasService) {
          this.gyvunasService = gyvunasService;
        }
        @RequestMapping(value = "/gyvunai", method = RequestMethod.GET)
        public String list(Model model){
          model.addAttribute("gyvunai", gyvunasService.atvaizduotiGuvunus());
        return "gyvunai";
        }
      }
      
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
    • Sukurti gyvunai.html:

      <body>
      <div class="container">
       <!--/*/ <th:block th:include="fragments/header :: header"></th:block> /*/-->
       <div th:if="${not #lists.isEmpty(gyvunai)}">
       <h2>Product List</h2>
       <table class="table table-striped">
       <tr>
       <th>Pavadinimas</th>
       <th>Amzius</th>
       </tr>
       <tr th:each="gyvunas : ${gyvunai}">
       <td th:text="${gyvunas.pavadinimas}">Gyvunas</td>
       <td th:text="${gyvunas.amzius}">Amzius</td>
       </tr>
       </table>
       </div>
      </div>
      
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
    • Naršyklėje atidaryti šią nuorodą: http://localhost:8080/gyvunai jeigu viskas tvarkoje turėtų atvaizduoti panašų vaizdą (žr. 5.5 pav.).

      5.5 pav. Naršyklėje atvaizduotas Gyvunai.html turinys

Last update: September 20, 2021 06:35
Contributors: Marius Gžegoževskis