Introducere în programarea în rețea. Vedeți ce este „JSP” în alte dicționare

1) NetBeans 7.3;
2) Maven;
3) Hibernați;
4) Spring MVC;
5) JSP+JSTL;
6) Cunoștințe despre Servlets, Sessions, JavaBean, XML etc.;
7) HTML+CSS (puțină frumusețe pentru gusturile dvs., dar este mai bine să plătiți persoanele nepotrivite - veți avea destule probleme cu partea de server);
8) Java SE (cunoașterea colecțiilor, capacitatea de a gestiona excepții... În general, un set standard);
9) Cunoașterea modelelor de proiectare (DAO, Factory);
10) JPA;
11) SVN;
12) SQL (pentru scrierea de scripturi care populează bazele noastre de date).

Să începem cu unde ne vom stoca codul și cum să-l partajăm prietenilor. Cred că nu toți începătorii știu despre depozite, iar această parte este doar pentru ei.

SVN Există un astfel de lucru ca un depozit - server la distanta stocarea codului.
Daca iti dau Test, și îl trimiți ca arhivă, atunci cel mai probabil vei fi trimis și tu. Poate că nu te vor trimite, dar cu siguranță vor fi dezamăgiți de tine.
Există diferite depozite CVS, SVN, Git. Pentru începători, cred că SVN este optim. Ei bine, principalul lucru pentru tine nu este să știi ce este, ci să îl poți aplica. Deocamdată va fi suficient, restul va veni cu experiență.

După toate acestea, vei avea un link către spațiul tău. Pentru a înțelege ce este acesta, trebuie să luați unul dintre proiectele dvs. (sau să creați un proiect gol în NetBeans). Faceți clic dreapta pe el și „Gestionarea versiunilor” -> „Importați în depozitul Subversion” va fi disponibil în meniul dvs. După aceasta, va apărea o casetă de dialog care conține calea către depozit - acesta este linkul pe care l-ați primit pe site în fila „ Sursă».

Apoi, ștergeți complet proiectul pe care l-ați angajat. Apoi, accesați folderul în care sunt stocate proiectele dvs. și verificați dacă totul a fost efectiv șters. Apoi reveniți la NetBeans și căutați fila Grup în bara de meniu (pe panoul unde File, View, Edit, Go, Source...) conține Subversion. Și în submeniul de pe el există „Obțineți”. Următorul în casete de dialog Va trebui să furnizați un link către depozit (acesta este linkul pe care l-ați primit pe site-ul web în fila „Codul sursă”). Și când vă oferă să descărcați foldere, va trebui să vă găsiți proiectul în arborele depozitului. și selectează-l, iar la final îți vei descărca proiectul. Acesta este modul în care se schimbă codul.
Proiectul dvs. se va sincroniza în mod constant cu depozitul și va marca fișierele care au fost modificate sau noi (oricare este diferită de versiunea din depozit). Pentru a actualiza, trebuie să apelați meniul contextual, iar în fila „Version Control” va exista o listă mare cu ceea ce puteți face cu proiectul. „Actualizare” înseamnă actualizarea fișierelor; „Commit” - puneți codul pe care l-ați scris sau modificat în depozit; „Resetare” - revine la versiunea din depozit, iar „Comparare” - afișează modificări ale rândurilor care diferă de cele șterse. Acesta este un mod de partajare a codului de echipă care este întotdeauna folosit și trebuie să vă obișnuiți.

Ați descărcat deja NetBeans, v-ați jucat cu SVN - acum să trecem la treabă. Creați un proiect. Faceți clic pe „Creați un proiect”, acolo selectați Maven-> Aplicație web. Spune-i cum vrei, este toată imaginația ta. Deci, avem o aplicație web, proiectul nostru este asamblat folosind Maven, avem un obiectiv și acum este timpul să ne gândim cum să o implementăm. Adică, tu, ca dezvoltator, trebuie să te gândești la cum va arăta aplicația ta, ce arhitectură va avea, arborele pachetelor și așa mai departe. Numărul total de linii de cod aici este de aproximativ 4000 și este mai bine să ai grijă de arhitectura frumoasă în avans, altfel mai târziu pur și simplu nu vei înțelege ce este unde și cum funcționează pentru tine, prin ce minune tu, de exemplu, afișați ultimul lucru achiziționat, cum calculați suma totală a achizițiilor. Și dacă ți se cere apoi să termini sau să adaugi ceva, îți vei da seama că este mai ușor să scrii totul de la zero.

Și, desigur, trebuie să ne dăm seama de planul nostru de acțiune.

Deci: Planul de acțiune 1) descrieți entitatea(entitățile) - entități. Acesta este un POJO - o clasă asociată cu baza de date folosind o adnotare (@Entity) sau prin XML. Vom folosi JPA, deci trebuie să importam javax.persistence.* De ce nu API-ul Hibernate Persistence, pentru că dacă îl folosim și apoi vrem să schimbăm biblioteca ORM, va trebui să ne rescriem clasele, iar JPA este un standard de la Soare. Referitor la ce este JPA - ei bine, vă pot spune cu propriile mele cuvinte: este o bibliotecă care oferă un API pentru lucrul cu obiecte *de lungă durată*, adică ne permite să ne salvăm convenabil obiectele în baza de date. Vă pot da un sfat: creați un pachet separat pentru asta, numiți-l entitate sau domeniu - orice doriți, principalul lucru este că vă este clar. S-ar putea să arate astfel: edu.shop.model.domain.Customer.java edu.shop.model.domain.Notebook.java.
O voi descrie mai detaliat direct atunci când voi lua în considerare acest articol. Acum sarcina este să găsești un plan de acțiune.

2) Creați HibernateUtil (în general, sufixul sau prefixul Util implică faptul că codul din această clasă este universal și este folosit de multe clase).
Deci, în HibernateUtil plasăm o SessionFactory. E greu. Acest cod, în teorie, ar trebui să fie independent de întreaga aplicație, deoarece stabilește o conexiune la baza de date la pornire și ar trebui să ne ofere doar Sesiuni cu baza de date. Înregistrăm și clasele noastre de entități în această clasă. Vă voi spune mai multe despre această clasă mai târziu. Să-l punem și într-un pachet separat, de exemplu, edu.shop.model.hbutil.HibernateUtil.java

3) Scrieți DAO.
Ce ar trebui să scriu în el? Scriem ceea ce dorim să obținem din baza de date, dar nu trebuie să ne gândim la modul în care au fost obținute aceste date, rezultatul este important. De exemplu, definim interfața ProductDAO și scriem metode în ea
Lista getAllProducts(); apoi scriem implementarea lui ProductDAOImpl.

Care este ideea? Dacă tu și cu mine am scris această aplicație, ai spune: „Micha, am nevoie de următoarele date din baza de date: toate produsele pe care le am în baza de date.” Răspund: „nu o întrebare”. Și apoi următoarea dezvoltare a evenimentelor: în codul dvs., oriunde trebuie să faceți interogări la baza de date, scrieți următorul%

*aici este un apel la metoda*.getAllProducts(); - și vezi că compilatorul nu înjură, și s-ar putea să nu fi avut timp să scriu încă implementarea acestei interfețe. Și care este rezultatul? Ai totul compilat, dar nici măcar nu ai cod de lucru. Aici vom folosi Enums și modelul Factory și altceva, dar totul are timpul lui. În DAO trebuie să acordați o atenție deosebită gestionării excepțiilor, cel puțin generând pagini de eroare. Astfel încât să puteți găsi rapid o bucată de cod rupt. În caz contrar, veți fi pur și simplu torturat cu depanare.

3) Lucrul nostru cu Spring MVC va începe aici. Aceasta este o poveste lungă și un articol separat îi va fi dedicat. Voi spune imediat că acesta este cel mai dificil lucru din această aplicație. Dar vă voi arăta o opțiune mai simplă, cum să afișați totul fără să vă faceți griji cu adevărat Model MVC.
Să ne referim la utilizarea scriptlet-urilor.

4) Aici vom avea clase auxiliare care adaugă tot felul de bunătăți proiectului nostru: calcularea sumei totale de achiziții; ultimul articol cumpărat; variabile auxiliare care ne vor fi utile pentru funcționarea metodei, care, de exemplu, vor afișa lucruri din baza de date pentru noi nu mai mult de 5000 UAH, sau nu mai puțin de 500; afișajul tuturor laptopurilor Asus. Acest punct este strâns legat de cel precedent.

Să lăsăm așa deocamdată. Ne vom da seama de restul puțin mai târziu. Deci, avem un plan, să începem să-l implementăm.

Entitate Am creat proiectul nostru și am creat pachetul nostru de entitate. Să fie edu.shop.entity. Acolo creăm următoarele clase:

Notă. Coșul în care vor fi stocate bunurile noastre achiziționate va fi ca un tabel în baza de date, am făcut asta pentru că voi arăta câteva elemente de bază ale lucrului cu baza de date pe el. Pentru un caz real, mai potrivit ar fi să folosim colecții pentru a ne depozita bunurile.

1) Produs
2) Caiet
3) Camera foto
4) Cartea
5) Cablu
6) Client
7) Cărucior

Să vorbim puțin despre ce este o clasă de entități.
Entity este o clasă POJO asociată cu baza de date folosind o adnotare (@Entity) sau prin XML. Următoarele cerințe se aplică acestei clase:

Trebuie să aibă un constructor gol (public sau protejat);
- Nu poate fi imbricat, interfață sau enumerare;
- Nu poate fi definitivă și nu poate conține câmpuri/proprietăți finale;
- Trebuie să conțină cel puțin un câmp @Id.

În acest caz, entitatea poate:

Entitățile pot fi legate între ele: unu-la-unu, unu-la-mulți, mulți-la-unu și mulți-la-mulți.

Vom folosi adnotări. Și aici avem imediat ocazia să o descriem în două moduri. Fie vom scrie adnotări direct deasupra câmpurilor, fie deasupra getter-urilor. Voi spune un lucru: este corect să scrieți mai sus getters și puteți întreba motivul pe Google. Nu pot descrie absolut toate subiectele aici.

Mai este un lucru pe care vreau să-l spun. Pentru a face acest lucru, va trebui să afișați 2 exemple de descriere a clasei de entități. Deci, primul exemplu:
Am scris comentarii la el în codul însuși:

Import java.io.Serializable; import javax.persistence.*; import javax.validation.constraints.Size; /** * * @author Mikhail Shumenko */ @Entity //Cu această adnotare indicăm că această clasă este o entitate. @Table(name = "CART") // Cu această adnotare indicăm că un tabel numit CART este responsabil pentru această entitate din baza de date // Aș dori să remarc că cazul nu este important, această adnotare poate fi omisă, atunci Hibernate va crea o bază de date pentru noi cu //nume precum clasa publică a clasei CartEntity implementează Serializable ( //Aici scriem adnotări deasupra câmpurilor. Scrierea corectă deasupra getters-ului //Descrieți ID-ul tabelului @Id //Indicați că această clasă câmpul este responsabil pentru o coloană din tabel cu numele Id //Dacă nu o vom specifica, hibernate va crea o coloană cu același nume ca și câmpul @Column(name = "ID") // Puteți scrie un mult aici)) De ce am scris-o așa aici? În general, puteți scrie AUTO în //@GeneratedValue(strategy=GenerationType.instead of TABLE), apoi //când tabelul este încărcat pentru prima dată, Id-ul va fi generat automat de la 1 la valoarea sa maximă. //Dacă aveți 20 de lucruri în tabel, atunci de la 1 la 20 vor fi generate //Dar cu adăugările ulterioare, id-ul lucrului adăugat va fi cam așa - 345768. //Am scris totul astfel încât ultimul meu. id a fost stocat în tabel și generat apoi în mod adecvat cu adăugările ulterioare. //Există și SEQUENCE, dar nu este acceptată în Derby și vom lucra cu ea. //În general, acestea sunt nuanțe. Puteți afla despre ele singur @TableGenerator(name = "cartid", table = "cartpktb", pkColumnName = "idCart", pkColumnValue = "idCartValue",allocationSize = 1) @GeneratedValue (strategy = GenerationType.TABLE, generator = "cartid") private Integer id; //Указываем !} dimensiune maximă. Acesta este un șir de 25 de caractere. @Size(max = 25) @Column(name = "NAMEITEM") //Dacă tipul câmpului nostru este String, atunci va fi creată o coloană cu tipul VARCHAR (în Derby) //Dacă Integer, atunci va fi o coloană în pe care îl puteți plasa numai Integer //boolean în Derby este o coloană de tip SMALLINT private String nameItem; @Column(name = "PRICE") private Integer price; public CartEntity() ( ) public CartEntity(String nameItem, int preț) ( this.nameItem = nameItem; this.price = price; ) public CartEntity(Integer id, String nameItem, int preț) ( this.id=id; this. nameItem = nameItem; this.price = price ) public CartEntity(Integer id) ( this.id = id; ) public Integer getId() ( return id; ) public void setId(Integer id) ( this.id = id; ) public String getNameItem() ( return nameItem; ) public void setNameItem(String nameItem) ( this.nameItem = nameItem; ) public Integer getPrice() ( return price; ) public void setPrice(Integer price) ( this.price = price; ) )

A doua cale: scriem deasupra getters. Consultați codul pentru explicații. import java.io.Serializable; import javax.persistence.*; /** * * @author miha */ @Entity //Vezi, nu am specificat adnotarea @Table //Hibernate va înțelege totul pentru mine. clasă publică Produsul implementează Serializabil ( id Integer privat; nume șir privat de caractereProdus; Integer privat Produs disponibil; @Id @GeneratedValue(strategy = GenerationType.AUTO) //Am descris Id-ul deasupra getterului, ceea ce înseamnă că restul câmpurilor vor fi prelucrate getters public Integer getId() ( return id; ) public void setId(Integer id) ( this.id = id; ) public String getNameProduct() ( return nameProduct; ) public void setNameProduct(String nameProduct) ( this.nameProduct = nameProduct) ; ) public Integer getAvailableProduct() ( return availableProduct; ) public void setAvailableProduct (Integer availableProduct) ( this.availableProduct = availableProduct; ) )

Deci, aveți două exemple de clase de entități. Creați restul folosind aceste exemple. Domenii precum: model, an apariție, denumire, cost - totul depinde de imaginația ta. Asigurați-vă că includeți câmpul Disponibil. Îți va fi de folos mai târziu. Puteți să o faceți boolean și să adăugați o coloană numită cantitate. Toate acestea ne vor fi de folos.

Acum să dăm un exemplu de HibernateUtil /* * Pentru a schimba acest șablon, alegeți Instrumente | Șabloane * și deschideți șablonul în editor. */ pachet edu.shumenko.hibernate; import edu.shumenko.entity.BookEntity; import edu.shumenko.entity.CableEntity; import edu.shumenko.entity.CameraEntity; import edu.shumenko.entity.CartEntity; import edu.shumenko.entity.CustomerEntity; import edu.shumenko.entity.NotebookEntity; import edu.shumenko.entity.ProductEntity; import org.hibernate.cfg.AnnotationConfiguration; import org.hibernate.SessionFactory; /** * Clasa Hibernate Utility cu o metodă convenabilă pentru a obține obiectul Session Factory *. * * @author Mikhail Shumenko */ public class HibernateUtil ( //Creați SessionFactory. privat static final SessionFactory sessionFactory; static ( încercați ( //Creați o nouă instanță de AnnotationConfiguration AnnotationConfiguration ac = nou AnnotationConfiguration(); //Avem nevoie de aceasta în astfel încât să adăugăm toate clasele noastre de entități // fiecare dintre entitățile tale trebuie să fie înregistrată aici, dacă nu o înregistrezi, nu va funcționa .class).addAnnotatedClass(NotebookEntity.class).addAnnotatedClass(. CustomerEntity.class); //Deci am creat Session Factory //Este necesar pentru că lucrăm cu baza de date prin sesiuni //Detaliile vor veni mai târziu, deocamdată știm cum să o facem și cum să lucrăm cu ea ac.configure().buildSessionFactory(); catch (Throwable ex) ( // Înregistrează excepția. System.err.println(" Crearea inițială a SessionFactory a eșuat." + ex); aruncă un nou ExceptionInInitializerError(ex); ) ) public static SessionFactory getSessionFactory() ( return sessionFactory; ) ) DAO Să trecem la următoarea parte. Ce este DAO. Acesta este un model de design.

Intelesul sau:
- Toate accesul la baza de date în sistem se face prin DAO pentru încapsulare.
- Fiecare instanță DAO este responsabilă pentru un obiect sau entitate de domeniu primar. Dacă un obiect de domeniu are un ciclu de viață independent, trebuie să aibă propriul său DAO.
- DAO este responsabil pentru operațiunile de creare, citire (prin cheie primară), actualizare și ștergere (adică CRUD (creare, citire, actualizare, ștergere)) a unui obiect de domeniu.
- DAO poate rezolva interogări pe baza altor criterii decât cheia principala. Mă refer la metode precum finder sau finders. Metoda finder returnează de obicei o colecție de obiecte de domeniu pentru care DAO este responsabil.
- DAO nu se ocupă de tranzacții, sesiuni sau conexiuni. Acest lucru se face în afara DAO pentru a oferi flexibilitate.
Google vă va spune întotdeauna mai multe.

Vom scrie un DAO pentru produsele noastre pentru moment.
Deci, să ne gândim la ceea ce avem de fapt nevoie. Tabelul Product va avea 4 câmpuri Id, nameProduct,available+amount+actionForServlet. Vom avea nevoie de el pentru a crea categorii pe site-ul nostru. Nu ne deranjam încă cu ultimul câmp. Singurul lucru de care avem nevoie este să obținem o listă de produse.

Scrierea unei interfețe
interfață publică ProductDAO ( ProductDAO INSTANCE_PRODUCT= new ProductDAOImpl(); ListGetProducts(); //și metoda cu care vom lucra)

Implementarea interfeței noastre. Consultați codul pentru explicații.
/* * Pentru a schimba acest șablon, alegeți Instrumente | Șabloane * și deschideți șablonul în editor. */ pachet edu.shop.model.dao; import java.util.List; import org.hibernate.Criteria; import org.hibernate.Session; /** * * @author Mikhail Shumenko */ public class ProductDAOImpl implementează ProductDAO ( @Override public ListGetProducts() ( ListResult = null; //Creează o sesiune, este necesară pentru a utiliza tranzacții //În linii mari, o tranzacție este ca un punctul de recuperare, dacă nu este finalizat, atunci toate modificările sunt anulate Session session = HibernateUtil.getSessionFactory().openSession(). din baza de date // Această formulare cred că vă va fi suficientă deocamdată // Ca parametru, trecem clasa de entitate pe care o folosim Dacă datele ar fi primite din tabelul Cart, atunci // ar trebui pass Cart.class Criteria criterii = session.createCriteria(Product.class result = (List) criteria.list(); session.getTransaction().commit ) catch (Exception e) ( // Asigurați-vă că scrieți gestionarea excepțiilor); Dar vă las să faceți singuri acest lucru e.printStackTrace() în final ( if (session != null) session.close(); ) returnează rezultatul; ) )

Deci acum avem capacitatea de a prelua date din baza de date. Puteți folosi scriptlet-uri pentru a crea o buclă simplă pentru fiecare și pentru a vă afișa produsele pe pagina index.jsp

Categorii Categoria //INSTANCE_PRODUCT ce este? //În ProductDAO este descrisă o astfel de variabilă, este responsabilă pentru crearea ProductDAOImpl //Ei bine, la noi totul va fi diferit, nu trebuie să vă amintiți prea mult. //ProductDAO INSTANCE_PRODUCT= nou ProductDAOImpl(); Disponibilitate

Dar aceasta este pentru prima dată și, în general, este rău să faci asta. Acest lucru rupe modelul nostru MVC. Voi explica cum să o fac corect în lecția următoare, dacă îmi dau o invitație. În a doua lecție ne vom ocupa de primăvară, în a treia vom atinge modelul Factory și vom aprofunda mai mult în Hibernate. Pentru cei care sunt deosebit de nerăbdători, vă voi arăta cum să ștergeți din baza de date, să salvați în baza de date și să ștergeți complet totul din baza de date. Ei bine, să lăsăm o discuție detaliată pentru mai târziu despre cum să facem ca toate acestea să interacționeze în ansamblu cu aplicația noastră.

Salvați în DB public void addItemToCart(CartEntity cart) ( Session session = HibernateUtil.getSessionFactory().openSession(); try ( session.beginTransaction().begin(); session.save(cart); session.getTransaction().commit (); ) catch (Exception ex) ( ex.printStackTrace(); ) finally ( if (session != null) ( session.close(); ) ) Ștergeți din baza de date prin id public void deleteItemFromCart(Integer id) ( Session session = HibernateUtil.getSessionFactory().openSession(); try ( session.beginTransaction().begin(); CartEntity itemDelete = (CartEntity) session.get(CartEntity.class, id); session.delete(itemDelete); getTransaction().commit(); catch (excepție ex) (ex.printStackTrace(); ) finally ( if (session != null) ( session.close(); ) ) Se elimină id-ul grupului din baza de date. public void deleteAllItemToCart(List idAllItemsInCart) ( Sesiune de sesiune = HibernateUtil.getSessionFactory().openSession(); try ( session.beginTransaction().begin(); for(Integer id:idAllItemsInCart)( CartEntity itemDelete =) sesiune (CargettEntity =) (CartEntity.class, id); session.delete(itemDelete); session.getTransaction().commit(); închide(); ) ) )

Veți avea nevoie și de un fișier de configurare Hibernate. Creați o bază de date de magazin în Derby. Nume de utilizator și parolă utilizator rootși respectiv trece. Dacă nu merge, nu fi supărat - îi voi mai acorda ceva timp.

org.hibernate.dialect.DerbyDialect org.apache.derby.jdbc.ClientDriver jdbc:derby://localhost:1527/shop root pass UTF-8 update

Vom vorbi despre cum să ne completam bazele de date mai târziu. Le puteți completa manual. Sau așteptați următoarea lecție.

Continui să descriu procesul de creare a unei aplicații web folosind servlet-uri, jsp, Maven și Tomcat. , dacă este nevoie.

Creăm entități. Să creăm o clasă User în pachetul de entități, în care vom crea două variabile șir private nume și parolă. Să creăm constructori (implicit și unul care ar accepta ambele valori), getters/setters, suprascriem metoda toString() pentru orice eventualitate, precum și metodele equals() și hashCode(). clasă publică Utilizator (nume șir privat; parolă șir privat; utilizator public() ( ) public Utilizator(nume șir, parolă șir) ( this.name = nume; this.password = parolă; ) public String getName() ( return name; ) public void setName(String name) ( this.name = nume; ) public String getPassword() ( returnează parola; ) public void setPassword(String parola) ( this.password = parola; ) @Override public String toString() ( return "Utilizator(" + "nume="" + nume + "\"" + ", parola="" + parolă + "\"" + ")" ) @Override public boolean equals(Object o) ( dacă (acest = = o) returnează adevărat; dacă (o == null || getClass() != o.getClass()) returnează fals; Utilizator utilizator= (Utilizator) o; if (nume != null ? !name.equals(user.name) : user.name != null) returnează false; returnează parola != null ? password.equals(user.password): user.password == null; ) @Override public int hashCode() ( int rezultat = nume != nul ? name.hashCode() : 0; rezultat = 31 * rezultat + (parolă != null ? parola.hashCode() : 0); rezultat returnat; ) ) Acum putem începe să creăm o listă de utilizatori, unde ne vom adăuga utilizatorii și de unde îi vom lua pentru afișare. Dar aici e o problema. Nu creăm obiectele noastre servlet; Tomcat le creează pentru noi. Metodele pe care le suprascriem în ele sunt, de asemenea, deja definite pentru noi și nu putem adăuga un parametru. Cum să creez atunci lista comuna, care ar fi vizibil în ambele servlet-uri? Dacă pur și simplu ne creăm propriul obiect listă în fiecare servlet, se va dovedi că vom adăuga utilizatori la o singură listă, dar afișarea unei liste de utilizatori care utilizează servletul ListServlet va fi complet diferită. Se pare că avem nevoie de un obiect care ar fi comun ambelor servlet-uri. În general, avem nevoie de un obiect care să fie comun tuturor claselor din programul nostru; singurul obiect pentru întregul program. Sper că ați auzit ceva despre modelele de design. Și poate pentru unii aceasta este prima nevoie reală de a folosi un șablon în programul lor. Poți fi creativ și să faci niște singleton cool, cu verificări duble și sincronizare (da, avem o aplicație multi-threaded, deoarece Tomcat rulează servlet-uri în fire diferite), dar voi folosi opțiunea cu inițializare timpurie, deoarece în acest caz destul de potrivit. Crearea unui model. Apoi vom crea o clasă (și vom implementa șablonul singleton în ea) în pachetul de model și o vom numi, de asemenea, destul de colorat Model. Să creăm un obiect listă de utilizatori privat în el și să facem două metode: una astfel încât să puteți adăuga un utilizator, iar a doua - lăsați-l să returneze pur și simplu o listă de șiruri de caractere (nume de utilizator). Deoarece obiectul nostru utilizator constă dintr-un nume și o parolă, nu am dori să „dezvăluim” parolele de utilizator, așa că vom returna doar o listă cu numele acestora. clasă publică Model ( private static Model instance = new Model(); private List model; public static Model getInstance() ( return instance; ) private Model() ( model = new ArrayList(); ) public void add(Utilizator utilizator) ( model.add(user); public List list() ( return model.stream() .map(User::getName) .collect(Collectors.toList()); ) ) Un pic despre mvc. Din moment ce ați auzit despre singleton, înseamnă că probabil ați auzit despre un alt model de design - MVC (model-view-controller, sau în rusă model-view-controller, sau la fel ca în engleză model-view-controller). Esența sa este de a separa logica afacerii de prezentare. Adică, separă codul care definește ce să fac din codul care defineste cum se afișează. Vizualizarea (vizualizarea sau doar vizualizările) este responsabilă pentru forma în care sunt prezentate unele date. În cazul nostru, vizualizările sunt paginile noastre JSP. De aceea le-am pus într-un folder numit vederi. Modelul reprezintă datele reale cu care funcționează programul. În cazul nostru, aceștia sunt utilizatori (lista de utilizatori). Ei bine, controlorii - legătură de legăturăîntre ele. Ei preiau date din model și le transferă în vizualizări sau primesc unele date de la Tomcat, le procesează și le transferă pe model. Logica de afaceri (de ex. ce să fac) ar trebui să fie descrise în ele, și nu în model sau vedere. Astfel, fiecare își face treaba lui:

• modelul stochează date
• Vizualizările desenează o reprezentare frumoasă a datelor
• controlorii procesează datele

Acest lucru le permite tuturor să fie destul de simple și ușor de întreținut. Și nu o aruncare monstruoasă a întregului cod într-o singură clasă. MVC nu este potrivit doar pentru programarea web, dar este încă foarte comun (dacă nu întotdeauna) în acest domeniu. În cazul nostru, servleturile vor acționa ca controlori. Da, aceasta este o descriere foarte superficială și chiar grosieră a acestui model, dar acest articol nu este despre modele de design, ci despre cum să faci o aplicație web simplă :) Cine vrea să afle mai multe - Google știe totul! :) Să revenim la părerile noastre. Creați un formular pentru adăugarea unui utilizator. Să adăugăm un formular în fișierul add.jsp, format din două intrări de text (una obișnuită, cealaltă de tip parolă) și un buton pentru trimiterea datelor către server. Nume: Parola: Trimitere Aici formularul are un atribut metoda cu valoarea post. Aceasta înseamnă că datele din acest formular vor fi trimise către server sub forma unei cereri POST. atribut de acțiune nu este specificat, atunci această solicitare va zbura către aceeași adresă la care am mers la această pagină (/add). Astfel, servletul nostru, care este legat la această adresă, la primirea unei cereri GET, returnează acest jsp cu formularul de adăugare a utilizatorilor, iar dacă primește o solicitare POST, atunci acest formular și-a trimis datele acolo (pe care le vom prelua de la obiectul de cerere din metoda doPost(), procesați-l și transferați-l în model pentru salvare). Este de remarcat faptul că intrările au aici un parametru de nume (pentru un câmp cu nume are numele valorii, iar pentru un câmp cu parolă are trecerea valorii). Acesta este un punct destul de important. Deoarece pentru a obține aceste date (nume și parolă care vor fi introduse) din cerere (deja în interiorul servlet-ului), vom folosi exact aceste nume și trecere. Dar mai multe despre asta mai târziu. Butonul pentru trimiterea datelor în sine este din nou realizat sub forma unui buton, și nu sub formă de intrare, așa cum este de obicei obișnuit. Nu știu cât de universală este această opțiune, dar funcționează pentru mine în Chrome :) Procesarea unei cereri POST cu un servlet. Să revenim la servletul AddServlet. Știm deja că, pentru ca servletul nostru să poată „prinde” solicitările GET, suprascriem metoda doGet() din clasa HttpServlet. Pentru a învăța servlet-ul nostru să capteze și cererile POST, suprascriem și metoda doPost(). Primește obiecte de cerere și răspuns similare de la Tomcat, cu care vom lucra. Mai întâi, să extragem din cerere numele și parametrii de trecere pe care i-a trimis formularul (dacă i-ați denumit diferit în formular, atunci acestea sunt numele pe care le scrieți). Apoi ne vom crea obiectul utilizator folosind datele primite. Apoi vom obține obiectul model și vom adăuga utilizatorul creat la model. @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) aruncă ServletException, IOException ( String name = req.getParameter("name"); String password = req.getParameter("pass"); User user = new User(nume, parola) ); Model model = Model.getInstance(); Acum să trecem la servletul ListServlet. Am implementat deja metoda doGet(), care pur și simplu transferă controlul în vizualizarea list.jsp. Dacă nu aveți încă acest lucru, faceți-o prin analogie cu aceeași metodă din servletul AddServlet. Acum ar fi bine să obțineți o listă de nume de utilizator din model și să le treceți la vizualizare, care le va primi acolo și le va afișa frumos. Pentru a face acest lucru, vom folosi din nou obiectul de solicitare pe care l-am primit de la Tomcat. Putem adăuga un atribut acestui obiect, dându-i un nume și, de fapt, obiectul în sine pe care am dori să-l transferăm în vizualizare. Datorită faptului că atunci când transferăm procesul de execuție de la un servlet la o vizualizare, trecem acolo aceleași obiecte de cerere și răspuns pe care le-a primit servletul însuși, apoi adăugând lista noastră de nume la obiectul de solicitare, putem apoi din această solicitare obiect în vizualizare creați lista noastră de nume de utilizator și obțineți. Am terminat cu clasa ListServlet, așa că iată codul pentru întreaga clasă a pachetului app.servlets; import app.model.Model; import javax.servlet.RequestDispatcher; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.IOException; import java.util.List; clasa publică ListServlet extinde HttpServlet ( @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) aruncă ServletException, IOException ( Model model = Model.getInstance(); List names = model.list(); req.setAttribute("userNames", name) ); RequestDispatcher requestDispatcher = req.getRequestDispatcher("views/list.jsp"); Acum să trecem la fișierul list.jsp. Acest fișier va fi executat numai atunci când ListServlet trece procesul de execuție aici. În plus, în acel servlet am pregătit deja o listă de nume de utilizator din model și am trecut-o aici în obiectul de solicitare. Având în vedere o listă de nume, o putem parcurge pentru buclăși afișați fiecare nume. După cum am spus deja, fișierele jsp pot executa cod java (în principiu, acesta este ceea ce le face diferite de paginile html statice). Pentru a executa un cod, este suficient să plasăm o construcție în locul de care avem nevoie. În interiorul unei astfel de construcții, avem acces la mai multe variabile: request - obiectul nostru de solicitare, pe care l-am transmis de la servlet, unde a fost numit pur și simplu. req response - obiectul de răspuns, în Servletul a fost numit resp out - un obiect de tip JspWriter (moștenit de la Writer obișnuit), cu ajutorul căruia putem „scrie” ceva direct în pagina html însăși. Out.println("Bună lume!") este foarte asemănător cu System.out.println("Bună lume!"), dar nu le confundați! out.println() „scrie” în pagina html și System.out.println - în ieșirea sistemului. Dacă apelați metoda System.out.println() în interiorul secțiunii cu cod jsp, veți vedea rezultatele în consola Tomcat, și nu pe pagină, așa cum v-ar plăcea :) Puteți căuta alte obiecte disponibile în jsp . Folosind obiectul request putem obține lista de nume care a fost transmisă de la servlet (am atașat atributul corespunzător acestui obiect), iar folosind obiectul out putem afișa aceste nume. Să facem asta deocamdată formular html listă: Dacă vrem să afișăm o listă numai dacă există utilizatori și, în caz contrar, să afișăm un avertisment că nu există încă utilizatori, putem rescrie puțin această secțiune: Acum că știm cum să transferăm date de la servlet-uri în vizualizări, putem îmbunătățiți puțin AdServlet-ul nostru, pentru a afișa o notificare despre adăugarea cu succes a unui utilizator. Pentru a face acest lucru, în metoda doPost(), după adăugarea unui nou utilizator la model, putem adăuga numele acestui utilizator la atributele obiectului req și trece controlul înapoi în vizualizarea add.jsp. Și în ea faceți deja o secțiune cu cod Java, unde puteți verifica dacă un astfel de atribut este în cerere și, dacă da, apoi afișați un mesaj că utilizatorul a fost adăugat cu succes. După aceste modificări, codul complet al servlet-ului AddServlet va arăta cam așa: pachet app.servlets; import app.entities.User; import app.model.Model; import javax.servlet.RequestDispatcher; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.IOException; clasa publică AddServlet extinde HttpServlet ( @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) aruncă ServletException, IOException ( RequestDispatcher requestDispatcher = req.getRequestDispatcher("views/add.jsp"); @requestDispatcher, resp. Suprascrierea protejată void doPost(HttpServletRequest req, HttpServletResponse resp) aruncă ServletException, IOException ( String name = req.getParameter("name"); String password = req.getParameter("pass"); User user = new User(nume, parolă) ; Model model = Model.getInstance(); req.setAttribute("userName", name doGet(req, resp); în modelul utilizatorului, după care apelăm metoda doGet(), căreia îi transmitem cererea și răspunsul curent. Și metoda doGet() transferă deja controlul către vizualizare, unde trimite un obiect de cerere cu numele utilizatorului adăugat atașat ca atribut. Rămâne să corectăm add.jsp în sine, astfel încât să afișeze o astfel de notificare dacă un astfel de atribut este prezent. Versiunea finală este add.jsp Adaugă un utilizator nou Super aplicație! Adăugați nume de utilizator: Parolă: Trimiteți Înapoi la principal Corpul paginii este format dintr-un div cu antet, după care există un container div pentru conținut, acesta verifică dacă există un atribut cu numele de utilizator, apoi un div cu un formular pentru adăugarea utilizatorilor, iar la sfârșit există un subsol cu ​​un buton pentru a reveni la pagina principală. Poate părea că sunt prea multe div-uri, dar le vom folosi mai târziu când vom adăuga stiluri :) Și versiunea finală este list.jsp Users Super app! Utilizatori Înapoi la pagina principală Astfel, avem o aplicație web complet funcțională, care poate stoca și adăuga utilizatori, precum și afișa o listă cu numele acestora. Tot ce rămâne este să înfrumusețezi... :) Adăugarea de stiluri. Folosim cadrul W3.CSS. Momentan, aplicația noastră funcționează, dar absolut nebunește :) Trebuie să adăugăm un fundal, text și culori pentru butoane, să stilizăm liste, să facem aliniere, să adăugăm indentări, în general o mulțime de lucruri. Dacă scrii stiluri manual, poate dura mult timp și nervi. Prin urmare, vă sugerez să utilizați cadrul CSS W3.CSS. Are deja cursuri gata făcute cu stiluri, tot ce rămâne este să le plasezi în locurile potrivite clase css, pe care vrem să-l aplicăm în aceste locuri. Pentru a le adăuga în paginile noastre, mai întâi trebuie să includem un fișier cu stiluri. Acest lucru se poate face în două moduri: 1. parcurgeți paginile noastre și în secțiunea de cap introduceți un link direct către fișierul cu stiluri Această opțiune este potrivită dacă aveți o conexiune constantă la Internet. Apoi, când vă deschideți paginile pe server local- stilurile vor fi extrase de pe Internet. 2. Dacă doriți să aveți toate stilurile la nivel local și să nu fiți dependent de o conexiune la Internet, puteți pur și simplu să descărcați fișierul cu stiluri și să-l plasați undeva în folderul web (de exemplu web/styles/w3.css), apoi parcurgeți toate paginile noastre (index.html, add.jsp, list.jsp) și introduceți un link către acest fișier cu stiluri în secțiunea head. După aceea, parcurgeți etichetele și etichetați-le cu stilurile care vă plac . Nu mă voi opri asupra acestui lucru în detaliu, dar îmi voi da imediat opțiuni gata făcute trei dintre dosarele mele cu clase de stil aranjate. index.html Super aplicație! Super aplicație! Listează utilizatori Adaugă utilizator add.jsp Adaugă utilizator nou Super aplicație! Adaugă utilizator Nume: Parolă: Trimite Înapoi la lista principală.jsp Lista de utilizatori Super aplicație! Utilizatori Înapoi la principal Asta e tot :) Dacă mai aveți întrebări sau aveți comentarii sau, dimpotrivă, ceva nu merge - lăsați un comentariu. Ei bine, voi atașa câteva capturi de ecran cu ceea ce a ieșit din toate acestea.

Și, în sfârșit. Dacă doriți să exersați cu acest proiect, puteți încerca:

• faceți un servlet și jsp pentru a șterge un utilizator și încă câteva pentru a schimba/editați utilizator existent. Veți obține o aplicație web reală CrUD :) pe servlet-uri))
• înlocuiți lista (Lista) cu lucrul cu o bază de date, astfel încât utilizatorii adăugați să nu dispară după repornirea serverului :)

Noroc!

Paginile JSP au o sintaxă hibridă: o combinație dintre sintaxa standard conformă cu specificația HTML și sintaxa JSP definită de specificația Java Server Pages. Sintaxa JSP definește regulile pentru scrierea paginilor JSP constând din etichete standard Etichete HTML și JSP.

Paginile JSP, pe lângă etichetele HTML, conțin etichete JSP din următoarele categorii:

directive JSP

Directivele JSP oferă informații globale cu privire la cereri specifice, trimise către server și furnizați informațiile necesare în etapa de difuzare. Directivele sunt întotdeauna plasate la începutul paginii JSP înaintea tuturor celorlalte etichete, astfel încât analizator(analizator) La analizarea textului, JSP a evidențiat instrucțiunile globale chiar de la început. Astfel, JSP Engine (JSP runtime) analizează codul și creează un servlet din JSP. Directive reprezintă mesaje către containerul JSP.

Sintaxă directive JSP după cum urmează:

Sintaxa jobului directiveîn XML:

O directivă JSP poate avea mai multe atribute. În acest caz, directiva poate fi repetată pentru fiecare dintre atribute. În același timp, cuplurile „NumeAtribut=valoare” poate fi plasat sub o directivă cu un spațiu ca separator.

Există trei tipuri de directive:

• pagină
• taglib (biblioteca de etichete)
• include

Directiva de pagină JSP

Directiva de pagină JSP definește proprietățile paginii JSP care afectează traducătorul. Ordinea atributelor într-o directivă pagină nu contează. Încălcarea sintaxei sau prezența atributelor nerecunoscute duce la o eroare de traducere. Exemplu de directivă pagină Următorul cod ar putea servi:

Directiva de pagină declară că această pagină JSP nu utilizează buffering, că este posibil ca mulți utilizatori să acceseze o anumită pagină JSP în același timp și că o pagină de eroare numită error.jsp.

Directiva de pagină JSP poate conține informații despre pagină:

Lista de atribute posibile ale directivei pagină prezentate în tabel.

Nume atribut Valoare Descriere

limba	Linia	Specifică limba utilizată în scriptleturile, expresiile sau orice fișiere incluse ale fișierului JSP, inclusiv corpul codului tradus. Valoarea implicită este „java”
se extinde	Linia	Specifică superclasa pentru servletul generat. Acest atribut trebuie folosit cu mare grijă, deoarece este posibil ca serverul să folosească deja o superclasă
import	Linia	Definiția pachetelor de importat, de exemplu: declaraţie< jsp : scriptlet >scriptlet< jsp : expression >expresie Vă recomandăm alte articole Cum funcționează mineritul criptomonedei Procesul de extragere a criptomonedei Rezumatul unei lecții la grădiniță „Programatorul este un vrăjitor grozav” Cum să treci verificarea când te conectezi la contul tău pe Aliexpress?