Spring. dr hab. inż. Marek Wojciechowski

(1)

Spring

dr hab. inż. Marek Wojciechowski

(2)

Plan wykładu

• Wprowadzenie

• Infrastruktura Spring

• Kontener Inversion of Control / Dependency Injection

• Fabryki komponentów

• Spring DAO

• Transakcje w Spring

• JMS w Spring

• Spring MVC

• Thymeleaf

• Programowanie aspektowe

• Spring Boot

(3)

Początki Springa

• Framework dla platformy Java

– Dla aplikacji różnego typu

– Ukierunkowany na aplikacje webowe na platformie Java EE – Otwarty, darmowy

– Rozwijany od 2003

• Wyrósł na krytyce platformy J2EE jako nadmiernie złożonej i niewydajnej

– Rod Johnson: „Expert One-on-One J2EE Development without EJB”, 2002

– Główne zarzuty dotyczyły technologii EJB

• Od początku framework modularny, obejmujący

wszystkie obszary aplikacji, ale integrujący się z innymi

rozwiązaniami

(4)

Czym obecnie jest Spring?

• Spring vs. Spring Framework

– Spring jako rodzina projektów (ekosystem) wokół rdzenia jakim jest Spring Framework

– „Modular by design” (from: spring.io)

– „whatever the infrastructure needs of your application may be, there is a Spring Project to help you build it” (from: spring.io)

• Przykłady projektów Springa (https://spring.io/projects)

– Spring Framework – Spring Boot

– Spring Data – Spring Security – Spring HATEOAS – Spring Cloud

– …

(5)

Ideologia frameworka Spring

• Budowa aplikacji z komponentów POJO (beans)

• Dostarczenie komponentom POJO usług niezbędnych w aplikacjach klasy enterprise w sposób nieinwazyjny

• Ukrycie specyfiki i złożoności poszczególnych interfejsów programistycznych Javy / Javy EE przed kodem aplikacji

• „Odwrócenie sterowania” (Inversion of Control) poprzez wstrzykiwanie zależności (dependency injection)

• Wykorzystanie istniejących rozwiązań i integracja ich z frameworkiem

– ORM, programowanie aspektowe, MVC, technologie szablonów,

…

(6)

Modularna architektura Spring

• Źródło: Spring Framework Reference Documentation

(7)

Inversion of Control / Dependency Injection

• Sercem frameworka Spring jest kontener IoC

• Tradycyjne podejście do współpracy komponentów aplikacji ze sobą zakłada aktywne tworzenie lub

wyszukiwanie komponentów przez komponenty z nich korzystające

• Spring „odwraca sterowanie” w porównaniu z tradycyjnym podejściem:

– Komponenty deklarują jakich innych komponentów potrzebują do swojego działania

– Kontener wstrzykuje zależności do komponentu w momencie jego tworzenia

• Uwaga: obecna wersja Java EE również stosuje wstrzykiwanie

zależności (przez adnotacje), ale najpierw pojawiło się ono w Springu

(8)

Fabryki komponentów (kontenery)

• BeanFactory – interfejs fabryki komponentów Java Bean

• ApplicationContext

– interfejs dziedziczący po BeanFactory

– dodaje: obsługę komunikatów, internacjonalizację, obsługę zdarzeń, rejestrowanie nasłuchu zdarzeń

• WebApplicationContext

– interfejs dziedziczący po ApplicationContext

– dodaje konfigurację dla aplikacji webowych (kontekst serwletów, zasięgi)

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

class Foo {

ApplicationContext ctx = new

ClassPathXmlApplicationContext("beans.xml");

}

plik konfiguracyjny

(9)

Metody specyfikacji metadanych o komponentach dla kontenera Inversion of Control

• XML

– Tradycyjny format konfiguracji w Springu – Konfiguracja odseparowana od kodu Java

• Adnotacje

– Konfiguracja blisko kodu

– Mniej elastyczne rozwiązanie niż XML (inwazyjne)

– Preferowane przez programistów w ramach odchodzenia od XML-a

• Konfiguracja Java-based

– Najnowsze rozwiązanie z dostępnych w Springu

– Konfiguracja w Javie, ale zewnętrzna w stosunku do kodu beanów

– Adnotacje @Configuration, @Bean, @Import, @DependsOn

(10)

Konfiguracja beanów (XML)

</beans>

(11)

Strategie Dependency Injection w Spring

• Wstrzykiwanie zależności przez konstruktor

– Generalnie zalecane

– Odpowiednie dla obowiązkowych zależności

– Pozwala na tworzenie obiektów niemodyfikowalnych

• Wstrzykiwanie zależności przez metody setter

– Odpowiednie dla zależności opcjonalnych

– Pozwala na rozwiązanie problemu cyklicznych zależności między

beanami

(12)

Współpraca beanów:

podejście tradycyjne

public interface MovieFinder { List<Movie> findAll(); } class IMDBFinder implements MovieFinder {

…

public List<Movie> findAll() { … } }

class MovieLister {

private MovieFinder finder;

public MovieLister() { this.finder = new IMDBFinder(); } public Movie[] moviesDirectedBy(String director) {

List<Movie> allMovies = finder.findAll();

// process movie list }

}

trwałe powiązanie

(13)

Wstrzykiwanie zależności przez konstruktor (1/2)

public interface MovieFinder { List<Movie> findAll(); } class IMDBFinder implements MovieFinder {

…

public List<Movie> findAll() { … } }

class MovieLister {

private MovieFinder finder;

public MovieLister (MovieFinder finder) { this.finder = finder; } public Movie[] moviesDirectedBy(String director) { … }

}

(14)

Wstrzykiwanie zależności przez konstruktor (2/2)

<beans>

<bean id="MovieFinder" class="spring.IMDBFinder">

</bean>

<constructor-arg ref="MovieFinder"/>

</bean>

</beans>

beans.xml

(15)

Wstrzykiwanie zależności przez setter (1/2)

public interface MovieFinder { List<Movie> findAll(); } class IMDBFinder implements MovieFinder {

private String url;

public void setUrl(String url) { this.url = url; } public List<Movie> findAll() { … }

}

class MovieLister {

private MovieFinder finder;

public void setFinder(MovieFinder finder) { this.finder = finder; } public Movie[] moviesDirectedBy(String director) { … }

}

metody setter

(16)

Wstrzykiwanie zależności przez setter (2/2)

<beans>

<ref bean="MovieFinder"/>

</property>

</bean>

<bean id="MovieFinder" class="spring.IMDBFinder">

</property>

</bean>

</beans>

beans.xml

(17)

Spring beans:

natura, zasięgi, tworzenie

• Brak nadklas bazowych i obowiązkowych interfejsów

• Podstawowe zasięgi komponentów

– singleton (zasięg domyślny)

• Jedna współdzielona instancja na kontener

• Zastosowanie: bezstanowa logika biznesowa

– prototype

• Wiele instancji w kontenerze

• Przy każdym uzyskaniu z kontenera jest tworzona nowa instancja

• Zastosowanie: gdy stan powiązany z klientem

• Dodatkowe zasięgi w kontenerach „web-aware”

– request, session, application, websocket

(18)

Zachłanne i odroczone tworzenie singletonów

• Domyślnie instancje beanów o zasięgu „singleton” są tworzone podczas inicjalizacji kontenera

• Można zlecić tworzenie singletona dopiero w momencie odwołania do beana, tj. gdy faktycznie jest potrzebny:

– lazy-init="true"

(19)

Korzystanie z beanów w kontenerze:

Przykład (1/4)

package my.spring;

class Department { String name;

String city;

public void setName(String name) { this.name = name; } public String getName() { return this.name; }

public void setCity(String city) { this.city = city; } public String getCity() { return this.city; }

}

Department.java

(20)

package my.spring;

class Employee { String name;

Department dept;

public void setName(String name) { this.name = name; } public String getName() { return this.name; }

public void setDept(Department dept) {this.dept=dept;}

public Department getDept() { return this.dept; } }

Employee.java

Korzystanie z beanów w kontenerze:

Przykład (2/4)

(21)

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"

"http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

</bean>

<bean id="deptBean" class="my.spring.Department"

scope="singleton">

</bean>

</beans>

beans.xml

domyślnie

Korzystanie z beanów w kontenerze:

Przykład (3/4)

(22)

package ploug.spring;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {

public static void main(String[] args) {

ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");

Employee employee = (Employee) ctx.getBean("empBean");

System.out.println("Name: " + employee.getName());

System.out.println("Department: " + employee.getDept().getName());

System.out.println("Location: " + employee.getDept().getLocation());

...

SpringTest.java

Korzystanie z beanów w kontenerze:

Przykład (4/4)

(23)

Autowiring beanów

• Domyślnie komponenty współpracujące są wskazywane jawnie w konfiguracji beanów

– pierwotne rozwiązanie w Spring

– mimo późniejszych prostszych rozwiązań, przez długi czas zalecane w dużych projektach

• Od Spring 2.5 dostępny jest styl wstrzykiwania zależności określany jako „autowiring”

– zlecenie kontenerowi automatycznego dopasowania współpracujących beanów na podstawie typu

• W XML: atrybut autowire w elemencie <bean>:

– no

– byName – byType

– constructor

(24)

Wstrzykiwanie (autowiring) beanów Springa przez adnotacje

• Adnotacje dotyczące wstrzykiwania zależności

– @Autowired (lub obecnie standardowy @Inject) – @Qualifier (do rozstrzygania niejednoznaczności) – @Resource (do wstrzykiwania przez nazwę)

• Konieczna aktywacja mechanizmu autowiring:

• Powyższa konfiguracja dotyczy tylko powiązań między beanami, a nie samych beanów!

– Bez dodatkowych ustawień na poziomie kodu Java, beany definiowane w XML

<beans ...> ...

<context:annotation-config/>

</beans>

beans.xml

(25)

Konfiguracja beanów Springa przez adnotacje

• Adnotacje stereotypowe

– @Component

– @Repository, @Service, @Controller (oznaczone @Component)

• Brane pod uwagę podczas automatycznego skanowania pakietów aplikacji w poszukiwaniu beanów

• Konieczna aktywacja skanowania komponentów:

– Java: klasa konfiguracyjna opatrzona adnotacjami:

• @Configuration (sama oznaczona adnotacją @Component!)

• @ComponentScan(basePackages="…")

– automatycznie włącza też autowiring (annotation-config)

– XML

• domyślnie atrybut annotation-config="true"

<beans ...> ...

<context:component-scan base-package="…" />

</beans>

beans.xml

(26)

Java-based configuration of Spring beans

• Configuration separated from bean classes (and no XML)

– @Configuration marks the class as a source of bean definitions for the Spring IoC container

– @Bean tells Spring that a method returns an object that should be registered as a bean in the Spring IoC container

@Configuration

public class MoviesConfig {

@Bean // by default: @Scope("singleton")

public MovieLister movieLister() { // by default: bean name = method name return new MovieLister( movieFinder() );

}

@Bean

public MovieFinder movieFinder() { return new MovieFinder( );

} }

(27)

Konfiguracja kontenera Spring IoC bez XML

• Specjalizowane wersje ApplicationContext inicjalizowane klasą konfiguracyjną zamiast pliku XML

– AnnotationConfigApplicationContext

– AnnotationConfigWebApplicationContext

ApplicationContext ctx = new AnnotationConfigApplicationContext(MoviesConfig.class);

MovieLister movieLister = ctx.getBean("movieLister", MovieLister.class);

…

(28)

Spring DAO

• Wzorzec projektowy Data Access Object (DAO)

– rozdzielenie mechanizmu trwałości obiektów od reguł biznesowych

• Spring oferuje wsparcie dla

– interfejsu JDBC

– narzędzi ORM: Hibernate, JDO, iBATIS SQL Maps

• Dlaczego kolejna warstwa nad JDBC?

– zarządzanie Connection, ResultSet, Statement

– uniwersalny wyjątek DataAccessException

(29)

Spring DAO JDBC: Przykład (1/2)

...

import org.springframework.jdbc.core.JdbcTemplate;

import org.springframework.jdbc.datasource.DriverManagerDataSource;

...

DriverManagerDataSource dbBean =

(DriverManagerDataSource)ctx.getBean("dbBean");

JdbcTemplate template = new JdbcTemplate(dbBean);

List result = template.queryForList("SELECT * FROM emp");

for (Object o : result) { Map map = (Map)o;

System.out.println(map.get("ENAME") + " " + map.get("JOB"));

}

SpringDAOTest.java

(30)

Spring DAO JDBC: Przykład (2/2)

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"

"http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

...

<bean id="dbBean"

class="org.springframework.jdbc.datasource.DriverManagerDataSource">

</bean>

</beans>

beans.xml

(31)

Transakcje w Spring

• Wsparcie transakcji w architekturze Spring

– Interfejs PlatformTransactionManager – Wybór między JTA, Hibernate, JDO, JDBC – Szablon TransactionTemplate

– Deklaratywne zarządzanie transakcjami za pomocą POJO

i programowania aspektowego przy użyciu ProxyFactoryBean i TransactionInterceptor

– Demarkacja transakcji przez metadane i adnotacje

• @Transactional

– Aktywacja przetwarzania transakcyjnego w XML lub klasie konfiguracyjnej (@EnableTransactionManagement)

• Transakcje automatycznie aktywowane przez Spring Boot po dodaniu

zależności Spring Data

(32)

Transakcje w Spring: Przykład (1/2)

...

<bean id="dataSource"

class="org.springframework.jndi.JndiObjectFactoryBean">

</bean>

<bean id="transactionManager"

class="org.springframework.transaction.jta.JtaTransactionManager"/>

<bean id="empManagerJdbcBean"

class="my.spring.empManagerJdbc">

</bean>

…

beans.xml

(33)

Transakcje w Spring - przykład (2/2)

...

<bean id="empManagerBean"

class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

<props>

<prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>

<prop key="store*">PROPAGATION_REQUIRED</prop>

</props>

</property>

</bean>

…

beans.xml

PROPAGATION_REQUIRED, PROPAGATION_SUPPORTS,

PROPAGATION_MANDATORY, PROPAGATION_REQUIRES_NEW, PROPAGATION_NOT_SUPPORTED, PROPAGATION_NEVER,

PROPAGATION_NESTED

(34)

Własności transakcji w Spring

• Propagation

– MANDATORY, NESTED, NEVER, NOT_SUPPORTED, REQUIRED, REQUIRES_NEW, SUPPORTS

• Isolation

– DEFAULT, READ_COMMITTED, READ_UNCOMMITTED, REPEATABLE_READ, SERIALIZABLE

• readOnly: false / true

• rollbackFor

• noRollbackFor

• …

(35)

JMS w Spring

• Spring integruje się z JMS i upraszcza korzystanie z JMS API na podobnych zasadach jak z JDBC

• JmsTemplate

– Wysyłanie komunikatów

– Synchroniczny odbiór komunikatów

• Asynchroniczny odbiór komunikatów

– Message-Driven POJOs

– Metoda beana oznaczona @JmsListener

• JmsTransactionManager do integracji JMS z mechanizmami transakcyjnymi Springa

• Jako alternatywę dla JMS Spring oferuje również obsługę

RabbitMQ i Apache Kafka

(36)

JmsTemplate – wysłanie komunikatu

public class JmsQueueSender {

private JmsTemplate jmsTemplate;

private Queue queue;

public void setConnectionFactory(ConnectionFactory cf) { this.jmsTemplate = new JmsTemplate(cf);

} public void setQueue(Queue queue) { this.queue = queue;

}

public void sendMessage() {

this.jmsTemplate.send(this.queue, new MessageCreator() {

public Message createMessage(Session session) throws JMSException { return session.createTextMessage("message text");

} });

} }

(37)

Message-Driven POJO (MBP)

public class MyPojoListener implements MessageListener { public void onMessage(Message message) {

if (message instanceof TextMessage) { try {

string txt = ((TextMessage) message).getText();

...

}

catch (JMSException ex) {

throw new RuntimeException(ex);

} } } }

(38)

Kontener dla MDP

<bean id="jmsContainer"

class="org.springframework.jms.listener

.DefaultMessageListenerContainer">

</bean>

(39)

Spring MVC

• Implementacja wzorca architektonicznego Model-View-Controler

• Kontrolery i interceptory wewnątrz kontenera IoC

• Zalety:

– Elastyczna architektura

– Serwlety DispatcherServlet współdzielą kontekst – Łatwa konfiguracja środowiska

– Brak zależności aplikacji od szkieletu

– Warstwa widoku nieprzywiązana do konkretnej technologii

(40)

Przykład Spring MVC (1/4)

• Zarządca (dyspozytor) DispatcherServlet

– Implementuje wzorzec „front controller”

– Odpowiada za routing (przekierowuje przychodzące żądania do kontrolerów aplikacyjnych)

<?xml version = '1.0' encoding = 'windows-1252'?>

<web-app>

<servlet-name>empdept</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>empdept</servlet-name>

<url-pattern>/empdept/*</url-pattern>

</servlet-mapping>

</web-app>

web.xml

(41)

Przykład Spring MVC (2/4)

<bean id="dbBean"

…

</bean>

<bean

class="org.springframework.web.servlet.view.InternalResourceViewResolver">

<value>org.springframework.web.servlet.view.JstlView</value>

</property>

</bean>

empdept-servlet.xml

(42)

Przykład Spring MVC (3/4)

public class EmpDeptController implements Controller { public ModelAndView handleRequest(

HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException {

ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");

DriverManagerDataSource dbBean =

(DriverManagerDataSource)ctx.getBean("dbBean");

JdbcTemplate template = new JdbcTemplate(dbBean);

List employeesRaw = template.queryForList("select ename from emp");

List employees = new ArrayList();

for (Object o : employeesRaw)

employees.add(((Map)o).get("ENAME"));

ModelAndView mv = new ModelAndView("emps");

mv.addObject("employees", employees);

return mv; } }

EmpDeptController.java

(43)

Przykład Spring MVC (4/4)

<%@ page contentType="text/html;charset=windows-1252" %>

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

<html>

<body>

<c:forEach var="emp" items="${employees}">

<c:out value="${emp}"/> <br/>

</c:forEach>

</body>

</html>

/WEB-INF/jsp/emps.jsp

(44)

Język wyrażeń SpEL

• Spring Expression Language

• Język o składni podobnej do Unified EL

– #{…} – pełna składnia wyrażeń

– ${…} – tylko odwołania do właściwości

• Dodatkowe możliwości w porównaniu z Unified EL

– Wywołania metod

– Obsługa szablonów dla łańcuchów znaków

(45)

Biblioteka znaczników dla JSP

• Upraszcza budowę formularzy

• Znaczniki obsługują wiązanie danych do obiektu obsługującego stan formularza, dostępnego

w kontrolerze jako @ModelAttribute

<%@ taglib prefix="form"

uri="http://www.springframework.org/tags/form" %>

…

<form:form method="POST"

action="/addEmployee" modelAttribute="employee">

First Name:

<form:input path="firstName"/>

Last Name:

<form:input path="lastName"/>

</form:form>

…

(46)

Thymeleaf

• Modern server-side Java template engine

• "Natural templates" (HTML correctly displayed in browsers)

• Popular choice for Spring MVC (with seamless integration)

<table>

<thead>

<tr>

<th th:text="#{msg.headers.salary}">Salary</th>

</tr>

</thead>

<tbody>

<td th:text="${emp.name}">Smith</td>

</tr>

</tbody>

</table>

(47)

Programowanie aspektowe (AOP)

Order

handling Customer

handling Inventory handling

Security

Transactions

Logging

Functionality

Aspects (cr oss -cut tin g concerns )

(48)

Programowanie aspektowe

• Metoda programowania mająca na celu modularyzację kodu i likwidację nakładających się problemów przekrojowych

• Podstawowe pojęcia AOP

– aspekt (aspect): nazwany problem przekrojowy

– rada (advice): dodatkowe zachowanie/czynność które zostaje zainicjowane w punkcie złączenia

– punkt złączenia (join point): miejsce w strukturze wykonywania

się aplikacji w którym powinna zostać zastosowana rada

(49)

Spring AOP

• Rodzaje rad

– around advice: przed i po punkcie styku, możliwość przerwania przepływu kontroli przez zwrócenie własnej wartości lub wyjątku – before advice: przed punktem styku, brak blokowania przepływu

kontroli

– throws advice: w momencie zgłoszenia wyjątku

– after returning advice: po poprawnym wykonaniu

(50)

Przykład Spring AOP (1/3)

public interface MyInterface { public void foo(); } public class MyClass implements MyInterface { public void foo() { /* tutaj ciało metody */ } }

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;

public class TraceBeforeAdvice implements MethodBeforeAdvice { public void before(Method m, Object[] args, Object target) throws Throwable { /* tutaj kod porady */ }

}

(51)

Przykład Spring AOP (2/3)

<beans>

<bean id="MyBean"

class="org.springframework.aop.framework.ProxyFactoryBean">

<value>MyInterface</value>

</property>

<list><value>theTracingBeforeAdvisor</value></list>

</property>

</bean>

…

beans.xml

(52)

Przykład Spring AOP (3/3)

…

<bean id="theTracingBeforeAdvisor"

class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">

</property>

<value>./MyInterface/.foo</value>

</property>

</bean>

</beans>

beans.xml

(53)

Spring Boot

• Framework upraszczających tworzenie projektów w Springu

• Możliwości i cechy

(wg https://spring.io/projects/spring-boot)

– Tworzenie aplikacji stand-alone w Springu

– Zagnieżdżanie serwera (Tomcat, Jetty lub Undertow) w aplikacji (bez pakowania aplikacji do archiwum WAR dla serwera)

– Dostarczenie przemyślanych „startowych” zależności upraszczających konfigurację budowania aplikacji

– Automatyczna konfiguracja bibliotek Springa i firm trzecich gdy tylko będzie to możliwe

– Dostarczenie gotowych do zastosowań produkcyjnych funkcji

tradycyjnie oczekiwanych od serwera aplikacji np. monitoring

– Brak generacji kodu i konfiguracji w XML

(54)

Tworzenie projektów Spring Boot

• Spring Initializr (https://start.spring.io/)

– Webowy kreator konfiguracji projektu

– Projekty (Maven / Gradle) pobierane jako archiwa ZIP

• IDE (Spring Tool Suite, Intellij IDEA, …)

– Kreatory projektów wywołują REST API Spring Initializra

• Spring Boot CLI

– Narzędzie linii poleceń uruchamiające skrypty Groovy

– Prosta metoda tworzenia aplikacji w Springu bazujących na języku

Groovy

(55)

Spring Initializr (1/2)

(56)

Spring Initializr (2/2)

(57)

Spring Boot starters

• Gruboziarniste zależności grupujące biblioteki dla

popularnych funkcjonalności (np., Web, Test, Data JPA)

– Upraszczają konfigurację projektu i jej utrzymanie

…

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-data-jpa</artifactId>

</dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

</dependency>

…

</ dependencies >

…

pom.xml

(58)

Główna klasa aplikacji Spring Boot

• @SpringBootApplication to adnotacja pomocnicza dodająca:

– @Configuration: Oznacza klasę jako źródło definicji beanów Springa (Java-based configuration)

– @ComponentScan: Zleca Springowi poszukiwanie komponentów,

klas konfiguracyjnych i komponentów usługowych w bieżącym pakiecie – @EnableAutoConfiguration: Zleca Spring Boot wywnioskowanie

konfiguracji aplikacji na podstawie zależności JAR na ścieżce CLASSPATH

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication

public class BookingsApplication {

public static void main(String[] args) {

SpringApplication.run(BookingsApplication.class, args);

} }