Blade - En komplett guide
1. Oversikt
Blade er et lite Java 8+ MVC-rammeverk, bygget fra bunnen av med noen klare mål i tankene: å være selvstendig, produktiv, elegant, intuitiv og superrask.
Mange forskjellige rammer inspirerte designet: Node's Express, Pythons flaske og Golangs Macaron / Martini.
Blade er også en del av et ambisiøst større prosjekt, Let's Blade. Den inkluderer en heterogen samling av andre små biblioteker, fra Captcha-generasjon til JSON-konvertering, fra mal til en enkel databasetilkobling.
I denne opplæringen vil vi imidlertid bare fokusere på MVC.
2. Komme i gang
Først av alt, la oss lage et tomt Maven-prosjekt og legge til den nyeste Blade MVC-avhengigheten i pom.xml:
com.bladejava blade-mvc 2.0.14.RELEASE 2.1. Samle et bladapplikasjon
Siden appen vår blir opprettet som en JAR, vil den ikke ha en / lib mappe, som i en KRIG. Som et resultat fører dette oss til problemet hvordan vi skaffer blad-mvc JAR, sammen med andre JAR vi måtte trenge, til appen vår.
De forskjellige måtene å gjøre dette på, hver med fordeler og ulemper, er forklart i How to Create an Executable JAR with Maven tutorial.
For enkelhets skyld, vi bruker Maven Assembly Plugin teknikk, som eksploderer JAR importert i pom.xml og pakker deretter sammen alle klassene i en enkelt uber-JAR.
2.2. Kjører en bladapplikasjon
Blade er basert på Netty, et fantastisk asynkront arrangementdrevet nettverksapplikasjonsrammeverk. Derfor, for å kjøre vår Blade-baserte applikasjon trenger vi ikke noen ekstern applikasjonsserver eller Servlet Container; JRE vil være nok:
java -jar target / sample-blade-app.jar Etter det vil applikasjonen være tilgjengelig på // lokal vert: 9000 URL.
3. Forstå arkitekturen
Arkitekturen til Blade er veldig grei:
Det følger alltid den samme livssyklusen:
- Netty mottar en forespørsel
- Middlewares er utført (valgfritt)
- WebHooks kjøres (valgfritt)
- Routing utføres
- Svaret sendes til klienten
- Rydde opp
Vi vil utforske funksjonene ovenfor i de neste avsnittene.
4. Rute
Kort sagt, ruting i MVC er mekanismen som brukes til å lage en binding mellom en URL og en kontroller.
Blade tilbyr to typer ruter: en grunnleggende og en merket.
4.1. Grunnleggende ruter
Grunnleggende ruter er ment for veldig liten programvare, som mikrotjenester eller minimale webapplikasjoner:
Blade.of () .get ("/ basic-routes-example", ctx -> ctx.text ("GET called")) .post ("/ basic-routes-example", ctx -> ctx.text (" POST kalt ")) .put (" / basic-routes-example ", ctx -> ctx.text (" PUT called ")) .delete (" / basic-routes-example ", ctx -> ctx.text (" SLETTE kalt ")) .start (App.class, args); Navnet på metoden som brukes til å registrere en rute tilsvarer HTTP-verbet som skal brukes til å videresende forespørselen. Så enkelt som det.
I dette tilfellet returnerer vi en tekst, men vi kan også gjengi sider, som vi vil se senere i denne opplæringen.
4.2. Kommenterte ruter
Gjerne, for mer realistiske brukstilfeller, kan vi definere alle rutene vi trenger ved å bruke merknader. Vi bør bruke separate klasser for det.
Først og fremst må vi lage en kontroller gjennom @Sti kommentar, som vil bli skannet av Blade under oppstart.
Vi må da bruke ruteanmerkningen relatert til HTTP-metoden vi vil fange opp:
@Path offentlig klasse RouteExampleController {@GetRoute ("/ ruter-eksempel") offentlig streng get () {return "get.html"; } @ PostRoute ("/ ruter-eksempel") offentlig strenginnlegg () {return "post.html"; } @ PutRoute ("/ ruter-eksempel") offentlig String put () {return "put.html"; } @DeleteRoute ("/ ruter-eksempel") offentlig streng sletting () {retur "delete.html"; }} Vi kan også bruke det enkle @Rute kommentar og spesifiser HTTP-metoden som parameter:
@Route (value = "/ another-route-example", method = HttpMethod.GET) public String anotherGet () {return "get.html"; } På den andre siden, Hvis vi ikke setter noen metodeparameter, vil ruten avskjære hvert HTTP-anrop til den URL-en, uansett verbet.
4.3. Parameterinjeksjon
Det er flere måter å overføre parametere til våre ruter. La oss utforske dem med noen eksempler fra dokumentasjonen.
- Skjema parameter:
@GetRoute ("/ home") public void formParam (@Param String name) {System.out.println ("name:" + name); } - Avslappende parameter:
@GetRoute ("/ users /: uid") public void restfulParam (@PathParam Integer uid) {System.out.println ("uid:" + uid); } - Parameter for filopplasting:
@PostRoute ("/ upload") offentlig ugyldig filParam (@MultipartParam FileItem fileItem) {byte [] file = fileItem.getData (); } - Topptekstparameter:
@GetRoute ("/ header") public void headerParam (@HeaderParam String referer) {System.out.println ("Referer:" + referer); } - Informasjonskapselparameter:
@GetRoute ("/ cookie") offentlig ugyldig cookieParam (@CookieParam String myCookie) {System.out.println ("myCookie:" + myCookie); } - Kroppsparameter:
@PostRoute ("/ bodyParam") offentlig ugyldig bodyParam (@BodyParam brukerbruker) {System.out.println ("bruker:" + bruker.toString ()); } - Verdiobjektparameter, kalt ved å sende attributtene til ruten:
@PostRoute ("/ voParam") offentlig ugyldig voParam (@Param brukerbruker) {System.out.println ("bruker:" + bruker.toString ()); } 5. Statiske ressurser
Blade kan også betjene statiske ressurser ved behov, ved å bare sette dem inne i / ressurser / statisk mappe.
For eksempel src / main / resources / static / app.css vil være tilgjengelig på //localhost:9000/static/app.css.
5.1. Tilpasse stiene
Vi kan stille inn denne oppførselen ved å legge til en eller flere statiske stier programmatisk:
blade.addStatics ("/ tilpasset-statisk"); Samme resultat oppnås gjennom konfigurasjon ved å redigere filen src / main / resources / application.properties:
mvc.statics = / tilpasset-statisk 5.2. Aktivere ressurslisten
Vi kan tillate oppføring av innholdet til en statisk mappe, en funksjon som er slått av som standard av sikkerhetsgrunner:
blade.showFileList (true); Eller i konfigurasjonen:
mvc.statics.show-list = sant Vi kan nå åpne // localhost: 9000 / tilpasset statisk / for å vise innholdet i mappen.
5.3. Bruke WebJars
Som det fremgår av introduksjonen til WebJars-opplæringen, er statiske ressurser pakket som JAR også et levedyktig alternativ.
Blade utsetter dem automatisk under / webjars / sti.
La oss for eksempel importere Bootstrap i pom.xml:
org.webjars bootstrap 4.2.1 Som et resultat vil den være tilgjengelig under //localhost:9000/webjars/bootstrap/4.2.1/css/bootstrap.css
6. HTTP-forespørsel
Siden Blade er ikke basert på Servlet-spesifikasjonen, objekter som grensesnittet Be om og sin klasse HttpForespørsel er litt annerledes enn de vi er vant til.
6.1. Skjemaparametere
Når du leser skjemaparametere, bruker Blade stor bruk av Java-er Valgfri i resultatene av spørringsmetodene (alle metodene nedenfor returnerer en Valgfri gjenstand):
- spørring (strengnavn)
- queryInt (strengnavn)
- queryLong (strengnavn)
- queryDouble (strengnavn)
De er også tilgjengelige med en reserveverdi:
- Strengspørsmål (strengnavn, streng standardverdi)
- int queryInt (String name, int defaultValue)
- long queryLong (String name, long defaultValue)
- double queryDouble (String name, double defaultValue)
Vi kan lese en skjemaparameter gjennom den automatiserte eiendommen:
@PostRoute ("/ save") offentlig ugyldig formParams (@Param String brukernavn) {// ...} Eller fra Be om gjenstand:
@PostRoute ("/ lagre") offentlig ugyldig formParams (Be om forespørsel) {String brukernavn = request.query ("brukernavn", "Baeldung"); } 6.2. JSON Data
La oss nå se på hvordan et JSON-objekt kan tilordnes til en POJO:
curl -X POST // localhost: 9000 / brukere -H 'Content-Type: application / json' \ -d '{"name": "Baeldung", "site": "baeldung.com"}' POJO (kommentert med Lombok for lesbarhet):
offentlig klasse bruker {@Getter @Setter privat strengnavn; @Getter @Setter privat strengside; } Igjen er verdien tilgjengelig som den injiserte eiendommen:
@PostRoute ("/ brukere") offentlig ugyldig bodyParams (@BodyParam brukerbruker) {// ...} Og fra Be om:
@PostRoute ("/ brukere") offentlig ugyldig bodyParams (Be om forespørsel) {String bodyString = request.bodyToString (); } 6.3. RESTful Parametere
RESTFul-parametere i pene URL-er som lokal vert: 9000 / bruker / 42 er også førsteklasses borgere:
@GetRoute ("/ user /: id") offentlig ugyldig bruker (@PathParam Integer id) {// ...} Som vanlig kan vi stole på Be om objekt når det trengs:
@GetRoute ("/ bruker") offentlig ugyldig bruker (Be om forespørsel) {Integer id = request.pathInt ("id"); } Åpenbart er den samme metoden tilgjengelig for Lang og String typer også.
6.4. Databinding
Blade støtter både JSON og Form bindende parametere og fester dem automatisk til modellobjektet:
@PostRoute ("/ brukere") offentlig ugyldig bodyParams (brukerbruker) {} 6.5. Forespørsel og øktattributter
API for lesing og skriving av objekter i en Be om og en Økt er krystallklare.
Metodene med to parametere, som representerer nøkkel og verdi, er mutatorene vi kan bruke til å lagre verdiene våre i de forskjellige sammenhengene:
Øktøkt = forespørsel.økt (); request.attribute ("request-val", "Some Request value"); session.attribute ("session-val", 1337); På den annen side er de samme metodene som aksepterer bare nøkkelparameteren tilgangene:
String requestVal = request.attribute ("forespørsel-val"); Streng sessionVal = session.attribute ("session-val"); // Det er et heltall En interessant funksjon er deres generiske returtype T, som sparer oss for behovet for å kaste resultatet.
6.6. Overskrifter
Forespørselsoverskrifter, tvert imot, kan bare leses fra forespørselen:
String header1 = request.header ("a-header"); String header2 = request.header ("a-safe-header", "med en standardverdi"); Kartlegg allHeaders = request.headers (); 6.7. Verktøy
Følgende verktøymetoder er også tilgjengelige ut av esken, og de er så tydelige at de ikke trenger ytterligere forklaringer:
- boolsk isIE ()
- boolsk isAjax ()
- StrenginnholdType ()
- String userAgent ()
6.8. Lesekaker
La oss se hvordan Be om objekt hjelper oss med å håndtere informasjonskapsler, spesielt når vi leser Valgfri:
Valgfri cookieRaw (strengnavn); Vi kan også få det som en String ved å spesifisere en standardverdi som skal brukes hvis en informasjonskapsel ikke eksisterer:
Strengkake (strengnavn, streng standardverdi); Til slutt, dette er hvordan vi kan lese alle informasjonskapslene på en gang (nøklene er navnet på informasjonskapsler, verdier er Cookies 'verdier):
Kart informasjonskapsler = forespørsel. Informasjonskapsler (); 7. HTTP-respons
Analogt med hva som ble gjort med Be om, kan vi få en referanse til Respons objektet ved å bare erklære det som en parameter for rutemetoden:
@GetRoute ("/") offentlig ugyldig hjemme (svar) {} 7.1. Enkel utgang
Vi kan enkelt sende en enkel utgang til innringeren gjennom en av de praktiske utgangsmetodene, sammen med en 200 HTTP-kode og riktig innholdstype.
For det første kan vi sende en ren tekst:
response.text ("Hello World!");For det andre kan vi produsere en HTML:
respons.html ("");For det tredje kan vi også generere en XML:
response.xml ("Hello World!");Til slutt kan vi sende JSON ved hjelp av en String:
response.json ("{\" The Answer \ ": 42}"); Og til og med fra en POJO som utnytter den automatiske JSON-konverteringen:
Brukerbruker = ny bruker ("Baeldung", "baeldung.com"); respons.json (bruker); 7.2. Filutdata
Nedlasting av en fil fra serveren kunne ikke være tynnere:
respons.download ("the-file.txt", "/path/to/the/file.txt"); Den første parameteren angir navnet på filen som skal lastes ned, mens den andre (a Fil objekt, her konstruert med en String) representerer banen til den faktiske filen på serveren.
7.3. Malgjengivelse
Blade kan også gjengi sider gjennom en malmotor:
respons.render ("admin / brukere.html"); Malenes standardkatalog er src / hoved / ressurser / maler /, derav vil den forrige linjene lete etter filen src / main / resources / templates / admin / users.html.
Vi vil lære mer om dette senere, i Mal seksjon.
7.4. Viderekobling
En omdirigering betyr å sende en 302 HTTP-kode til nettleseren, sammen med en URL å følge med en andre GET.
Vi kan omdirigere til en annen rute, eller til en ekstern URL også:
respons.redirect ("/ målrute"); 7.5. Skrive informasjonskapsler
Vi bør være vant til Blades enkelhet på dette tidspunktet. La oss dermed se hvordan vi kan skrive en uutløpt informasjonskapsel i en enkelt kodelinje:
response.cookie ("cookie-name", "Noe verdi her"); Å fjerne en informasjonskapsel er faktisk like enkelt:
response.removeCookie ("informasjonskapselnavn"); 7.6. Andre operasjoner
Til slutt, Respons objektet gir oss flere andre metoder for å utføre operasjoner som å skrive overskrifter, sette innholdstype, sette statuskoden og så videre.
La oss se raskt på noen av dem:
- Svarstatus (int-status)
- Kartoverskrifter ()
- Svar ikke funnet ()
- Kart informasjonskapsler ()
- SvarinnholdType (strenginnholdType)
- ugyldig kropp (@NonNull byte [] data)
- Svarhode (strengnavn, strengverdi)
8. WebHooks
En WebHook er en interceptor som vi kan gjennom kjøre kode før og etter gjennomføring av en rutemetode.
Vi kan opprette en WebHook ved å bare implementere WebHook funksjonelt grensesnitt og overstyring av før() metode:
@FunctionalInterface offentlig grensesnitt WebHook {boolean before (RouteContext ctx); standard boolsk etter (RouteContext ctx) {return true; }} Som vi kan se, etter() er en standardmetode, derfor overstyrer vi den bare når det er nødvendig.
8.1. Avskjærer enhver forespørsel
De @Bønne kommentar forteller rammeverket for å skanne klassen med IoC Container.
En WebHook som er merket med den, vil følgelig fungere globalt og avskjære forespørsler til hver URL:
@Bean offentlig klasse BaeldungHook implementerer WebHook {@Override public boolean before (RouteContext ctx) {System.out.println ("[BaeldungHook] kalt før rutemetoden"); returner sant; }} 8.2. Begrenset til en URL
Vi kan også fange opp spesifikke nettadresser for kun å utføre kode rundt disse rutemetodene:
Blade.of () .before ("/ user / *", ctx -> System.out.println ("Before:" + ctx.uri ())); .start (App.klasse, args); 8.3. Mellomvare
Middlewares er prioritert WebHooks, som blir utført før noen standard WebHook:
offentlig klasse BaeldungMiddleware implementerer WebHook {@Override public boolean before (RouteContext context) {System.out.println ("[BaeldungMiddleware] called before Route method and other WebHooks"); returner sant; }} De trenger bare å defineres uten @Bønne kommentar, og deretter registrert erklærende gjennom bruk():
Blade.of () .use (ny BaeldungMiddleware ()) .start (App.class, args); I tillegg kommer Blade med følgende sikkerhetsrelaterte innebygde Middlewares, hvis navn skal være selvforklarende:
- BasicAuthMiddleware
- CorsMiddleware
- XssMiddleware
- CsrfMiddleware
9. Konfigurasjon
I Blade er konfigurasjonen helt valgfri, fordi alt fungerer ut av boksen etter konvensjon. Vi kan imidlertid tilpasse standardinnstillingene og introdusere nye attributter i src / main / resources / application.properties fil.
9.1. Lese konfigurasjonen
Vi kan lese konfigurasjonen på forskjellige måter, med eller uten å spesifisere en standardverdi i tilfelle innstillingen ikke er tilgjengelig.
- Under oppstart:
Blade.of () .on (EventType.SERVER_STARTED, e -> {Valgfri versjon = WebContext.blade (). Env ("app.version");}) .start (App.class, args); - Inne i en rute:
@GetRoute ("/ some-route") offentlig ugyldig someRoute () {Strengforfattere = WebContext.blade (). Env ("app.authors", "Ukjente forfattere"); } - I en tilpasset laster, ved å implementere BladeLoader grensesnitt, overstyrer laste() metode, og kommentere klassen med @Bønne:
@Bean offentlig klasse LoadConfig implementerer BladeLoader {@Override public void load (Blade blade) {Valgfri versjon = WebContext.blade (). Env ("app.version"); Stringforfattere = WebContext.blade (). Env ("app.authors", "Ukjent forfattere"); }} 9.2. Konfigurasjonsattributter
De flere innstillingene som allerede er konfigurert, men klar til å tilpasses, er gruppert etter type og oppført på denne adressen i tre kolonnetabeller (navn, beskrivelse, standardverdi). Vi kan også henvise til den oversatte siden, og være oppmerksom på at oversettelsen feilaktig bruker hovedinnstillingenes navn. De virkelige innstillingene er helt små.
Gruppering av konfigurasjonsinnstillinger etter prefiks gjør dem lesbare samtidig på et kart, noe som er nyttig når det er mange av dem:
Miljømiljø = blad. Miljø (); Kartkart = miljø.getPrefix ("app"); Strengversjon = map.get ("versjon"). ToString (); Stringforfattere = map.get ("forfattere", "Ukjente forfattere"). ToString (); 9.3. Håndtere flere miljøer
Når vi distribuerer appen vår til et annet miljø, må vi kanskje spesifisere forskjellige innstillinger, for eksempel de som er relatert til databasetilkoblingen. I stedet for å erstatte application.properties fil, tilbyr Blade oss en måte å konfigurere appen for forskjellige miljøer. Vi kan rett og slett beholde application.properties med alle utviklingsinnstillingene, og deretter opprette andre filer i samme mappe, som applikasjons- produserte eiendommer, som bare inneholder innstillingene som er forskjellige.
Under oppstarten kan vi deretter spesifisere miljøet vi vil bruke, og rammeverket vil slå sammen filene ved å bruke de mest spesifikke innstillingene fra applikasjons- produserte eiendommer, og alle andre innstillinger fra standardinnstillingen application.properties fil:
java -jar target / sample-blade-app.jar --app.env = prod 10. Mal
Mal i Blade er et modulært aspekt. Selv om den integrerer en veldig grunnleggende malmotor, bør vi stole på en ekstern malmotor for profesjonell bruk av visningene. Vi kan da velg en motor fra de tilgjengelige i bladet-malmotorer-arkivet på GitHub, som er FreeMarker, Jetbrick, Småstein, og Hastighet, eller til og med lage en innpakning for å importere en ny mal vi liker.
Blades forfatter foreslår Jetbrick, et annet smart kinesisk prosjekt.
10.1. Bruke standardmotoren
Standardmalen fungerer ved å analysere variabler fra forskjellige sammenhenger gjennom ${} notasjon:
10.2. Koble til en ekstern motor
Å bytte til en annen malmotor er en lek! Vi importerer ganske enkelt avhengigheten av (Blade wrapper of) motoren:
com.bladejava blad-mal-jetbrick 0.1.3 På dette tidspunktet er det nok å skrive en enkel konfigurasjon for å instruere rammeverket for å bruke det biblioteket:
@Bean public class TemplateConfig implementerer BladeLoader {@Override public void load (Blade blade) {blade.templateEngine (new JetbrickTemplateEngine ()); }} Som et resultat, nå hver fil under src / hoved / ressurser / maler / blir analysert med den nye motoren, hvis syntaks ligger utenfor omfanget av denne opplæringen.
10.3. Pakke inn en ny motor
Innpakning av en ny malmotor krever at du oppretter en enkelt klasse som må implementere Malmotor grensesnitt og overstyre gjengi () metode:
ugyldig gjengivelse (ModelAndView modelAndView, skribentforfatter) kaster TemplateException; For dette formålet kan vi ta en titt på koden til selve Jetbrick-innpakningen for å få en ide om hva det betyr.
11. Logging
Blade bruker slf4j-api som logggrensesnitt.
Det inkluderer også en allerede konfigurert loggingsimplementering, kalt blad-logg. Derfor trenger vi ikke importere noe; det fungerer som det er, ved ganske enkelt å definere en Logger:
privat statisk slutt org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger (LogExample.class); 11.1. Tilpasse den integrerte loggeren
Hvis vi vil endre standardkonfigurasjonen, må vi stille inn følgende parametere som systemegenskaper:
- Loggningsnivåer (kan være "spor", "feilsøking", "info", "advare" eller "feil"):
# Root Logger com.blade.logger.rootLevel = info # Package Custom Logging Level com.blade.logger.somepackage = debug # Class Custom Logging Level com.blade.logger.com.baeldung.sample.SomeClass = trace - Viste informasjon:
# Date and Time com.blade.logger.showDate = false # Date and Time Pattern com.blade.logger.datePattern = åååå-MM-dd HH: mm: ss: SSS Z # Trådnavn com.blade.logger.showThread = true # Logger Instance Name com.blade.logger.showLogName = true # Only the Last Part of FQCN com.blade.logger.shortName = true - Logger:
# Path com.blade.logger.dir =. / Logs # Name (det er som standard gjeldende app.name) com.blade.logger.name = eksempel 11.2. Ekskludert Integrated Logger
Selv om det å ha en integrert logger allerede er konfigurert, er veldig nyttig for å starte vårt lille prosjekt, kan vi lett havne i tilfelle andre biblioteker importerer sin egen loggimplementering. Og i så fall kan vi fjerne den integrerte for å unngå konflikter:
com.bladejava blade-mvc $ {blade.version} com.bladejava blad-logg 12. Tilpasninger
12.1. Håndtering av tilpasset unntak
En Exception Handler er også innebygd som standard i rammeverket. Det skriver ut unntaket fra konsollen, og hvis app.devMode er ekte, er stabelsporingen også synlig på websiden.
Imidlertid kan vi håndtere et unntak på en bestemt måte ved å definere en @Bønne utvide DefaultExceptionHandler klasse:
@Bean offentlig klasse GlobalExceptionHandler utvider DefaultExceptionHandler {@Override public void handle (Exception e) {if (e instanceof BaeldungException) {BaeldungException baeldungException = (BaeldungException) e; Streng msg = baeldungException.getMessage (); WebContext.response (). Json (RestResponse.fail (msg)); } annet {super.handle (e); }}} 12.2. Tilpassede feil sider
Tilsvarende feilene 404 ikke funnet og 500 - Intern serverfeil håndteres gjennom tynne standardsider.
Vi kan tvinge rammeverket til å bruke våre egne sider ved å erklære dem i application.properties fil med følgende innstillinger:
mvc.view.404 = min-404.html mvc.view.500 = min-500.html Disse HTML-sidene må absolutt plasseres under src / hoved / ressurser / maler mappe.
Innenfor 500 kan vi dessuten hente unntaket beskjed og stackTrace gjennom deres spesielle variabler:
500 Intern serverfeil Følgende feil oppstod ： "$ {melding}"
$ {stackTrace} 13. Planlagte oppgaver
Et annet interessant trekk ved rammeverket er muligheten for å planlegge utførelsen av en metode.
Det er mulig ved å kommentere metoden til a @Bønne klasse med @Rute kommentar:
@Bean public class ScheduleExample {@Schedule (name = "baeldungTask", cron = "0 * / 1 * * *?") Public void runScheduledTask () {System.out.println ("Dette er en planlagt oppgave som kjører en gang i minuttet . "); }} Faktisk bruker den klassiske cron-uttrykk for å spesifisere Dato tid koordinater. Vi kan lese mer om dem i A Guide to Cron Expressions.
Senere kan vi utnytte de statiske metodene til Oppgavebehandling klasse for å utføre operasjoner på de planlagte oppgavene.
- Få alle planlagte oppgaver:
Liste allScheduledTasks = TaskManager.getTasks (); - Få en oppgave ved navn:
Oppgave myTask = TaskManager.getTask ("baeldungTask"); - Stopp en oppgave ved navn:
boolsk lukket = TaskManager.stopTask ("baeldungTask"); 14. Arrangementer
Som allerede sett i avsnitt 9.1, er det mulig å lytte etter en spesifisert hendelse før du kjører en tilpasset kode.
Blade gir følgende hendelser ut av esken:
offentlig enum EventType {SERVER_STARTING, SERVER_STARTED, SERVER_STOPPING, SERVER_STOPPED, SESSION_CREATED, SESSION_DESTROY, SOURCE_CHANGED, ENVIRONMENT_CHANGED} Mens de seks første er enkle å gjette, trenger de to siste noen tips: MILJØ_ENDRET lar oss utføre en handling hvis en konfigurasjonsfil endres når serveren er oppe. SOURCE_CHANGED, er i stedet ennå ikke implementert og er der kun for fremtidig bruk.
La oss se hvordan vi kan sette en verdi i økten når den blir opprettet:
Blade.of () .on (EventType.SESSION_CREATED, e -> {Session session = (Session) e.attribute ("session"); session.attribute ("name", "Baeldung");}) .start (App .klasse, args); 15. Sesjonsimplementering
Når vi snakker om økten, lagrer standardimplementeringen sesjonsverdier i minnet.
Dermed vil vi kanskje bytte til en annen implementering for å gi cache, utholdenhet eller noe annet. La oss ta Redis, for eksempel. Vi må først lage vår RedisSession innpakning ved å implementere Økt grensesnitt, som vist i dokumentene for HttpSession.
Da ville det bare være å fortelle rammeverket at vi vil bruke det. Vi kan gjøre dette på samme måte som vi gjorde for den tilpassede malmotoren, med den eneste forskjellen at vi kaller sessionType () metode:
@Bean public class SessionConfig implementerer BladeLoader {@Override public void load (Blade blade) {blade.sessionType (new RedisSession ()); }} 16. Kommandolinjeargumenter
Når du kjører Blade fra kommandolinjen, er det tre innstillinger vi kan spesifisere for å endre oppførselen.
For det første kan vi endre IP-adressen, som standard er den lokale 0.0.0.0 loopback:
java -jar target / sample-blade-app.jar --server.address = 192.168.1.100 For det andre kan vi også endre porten, som som standard er 9000:
java -jar target / sample-blade-app.jar - server.port = 8080 Til slutt, som vist i avsnitt 9.3, kan vi endre miljøet for å la et annet application-XXX.properties filen som skal leses over standardfilen, som er application.properties:
java -jar target / sample-blade-app.jar --app.env = prod 17. Kjører i IDE
Enhver moderne Java IDE er i stand til å spille et Blade-prosjekt uten engang å trenge Maven-pluginene. Running Blade i en IDE er spesielt nyttig når du kjører Blade Demos, eksempler skrevet eksplisitt for å vise rammeverkets funksjoner. De arver alle en foreldrepomp, så det er lettere å la IDE gjøre jobben, i stedet for å tilpasse dem manuelt for å kjøre som frittstående apper.
17.1. Formørkelse
I Eclipse er det nok å høyreklikke på prosjektet og starte Kjør som Java-applikasjon, velg vår App klasse, og trykk OK.
Eclipse-konsollen vil imidlertid ikke vise ANSI-farger riktig, og heller ut kodene sine i stedet:
Heldigvis løser problemet for godt å installere ANSI Escape in Console-utvidelsen:
17.2. IntelliJ IDEA
IntelliJ IDEA jobber med ANSI-farger ut av esken. Derfor er det nok å lage prosjektet, høyreklikk på App fil, og start Kjør ‘App.main ()’ (som tilsvarer å trykke Ctrl + Skift + F10):
17.3. Visual Studio-kode
Det er også mulig å bruke VSCode, en populær ikke-Java-sentrisk IDE, ved å tidligere installere Java Extension Pack.
Pressing Ctrl + F5 vil da kjøre prosjektet:
18. Konklusjon
Vi har sett hvordan vi kan bruke Blade til å lage et lite MVC-program.
Hele dokumentasjonen er bare tilgjengelig på kinesisk. Til tross for å være utbredt hovedsakelig i Kina, takket være sin kinesiske opprinnelse, har forfatteren nylig oversatt API og dokumentert kjernefunksjonalitetene til prosjektet på engelsk på GitHub.
Som alltid kan vi finne kildekoden til eksemplet på GitHub.
