CodeGym /Java Blogu /Rastgele /Sunucu uygulamaları ve JSP'ler kullanarak basit bir web u...

Seviye

San Francisco

21 July 2023
211 views
0 comments

Sunucu uygulamaları ve JSP'ler kullanarak basit bir web uygulaması oluşturma (bölüm 1)

Makaleyi anlamak için gereken bilgi: Java Core'u zaten az çok anladınız ve JavaEE teknolojileri ve web programlamaya bakmak istiyorsunuz . Şu anda makaleye yakın konuları ele alan Java Collections görevini çalışıyor olmanız sizin için en mantıklısı olacaktır .

Bu materyal , IntelliJ Idea Enterprise'da en basit web projesini oluşturma makalemin mantıksal devamıdır . O yazıda, çalışan bir web projesi şablonunun nasıl oluşturulacağını gösterdim. Bu kez size Java Servlet API ve JavaServer Pages API kullanarak basit ama tamamen çekici bir web uygulamasının nasıl oluşturulacağını göstereceğim . Uygulamamızın iki bağlantı içeren bir ana sayfası olacaktır:

kullanıcı eklemek için bir sayfaya bağlantı;
kullanıcı listesine bir bağlantı.

Daha önce olduğu gibi, IntelliJ Idea Enterprise Edition , Apache Maven (sadece bazı bağımlılıkları bağlayacağız) ve Apache Tomcat kullanacağım . Sonunda, W3.CSS çerçevesini kullanarak uygulamamızı "güzelleştireceğiz". Şimdi ekleyeceğimiz boş bir projeniz olduğunu varsayacağız. Değilse, ilk makaleyi gözden geçirin ve bir tane yapın. Sadece birkaç dakikanızı alacak :)

Gelecekteki uygulamamızın yapısı hakkında biraz

Ana sayfamız (/) , bir başlık ve iki bağlantı/düğme içeren en sıradan statik HTML sayfası olacaktır :

yeni bir kullanıcı ekle ( / ekle öğesine gider );
kullanıcı listesini görüntüleyin ( / list konumuna gider ).

Tomcat bu adresler için istekleri yakalayacak ve bunları yapacağımız iki sunucu uygulamasından birine gönderecek (eşlemeyi web.xml'de belirteceğiz ) . Servlet'ler daha sonra istekleri işleyecek, verileri hazırlayacak (veya bir kullanıcı ekliyorsak verileri kaydedecek) ve kontrolü uygun JSP dosyalarına aktaracak ve ardından sonucu "oluşturacak". Verileri basit bir vanilya listesinde (Liste) saklayacağız.

Statik bir ana sayfa oluşturun

Web klasörünüzde index.jsp varsa , silin. Bunun yerine, bu klasörde index.html adlı basit bir HTML dosyası oluşturun:


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>My super project!</title>
</head>
<body>
    <!-- header -->
    <div>
        <h1>Super app!<//h1>
    </div>

    <div>       <!-- content -->
        <div>    <!-- button holder -->
            <button onclick="location.href='/list'">List users<//button>
            <button onclick="location.href='/add'">Add user<//button>
        </div>
    </div>
</body>
</html>

Burada karmaşık bir şey yok. Başlık etiketinde sayfamızın başlığını belirtiyoruz. Sayfa gövdesinde iki ana divimiz var: başlık ve içerik . İçerik div, düğmelerimiz için bir tutucu içerir. Ve sizi bir tıklama ile ilgili adrese götüren iki düğmemiz var. Projeyi çalıştırabilir ve şimdi nasıl göründüğünü görebilirsiniz. Düğmelere tıklarsanız, 404-hata sayfaları alırsınız, çünkü ilgili sayfalar henüz mevcut değil. Ancak düğmelerin çalıştığını söyleyebiliriz. Bunun en evrensel yaklaşım olmadığını unutmayın: Tarayıcıda JavaScript kapalıysa, bu düğmeler çalışmaz. Ancak kimsenin JavaScript'i devre dışı bırakmadığını varsayacağız. :) Açıkçası, basit bağlantılarla idare edebilirsiniz, ama ben düğmeleri tercih ederim. Nasıl isterseniz öyle yapabilirsiniz. Ve örneklerimde çok sayıda div olacağı gerçeğini dert etmeyin . Bunları daha sonra stillerle dolduracağız ve her şey daha güzel görünecek. :)

Sonucu işlemek için JSP dosyaları oluşturun

Aynı web dizininde JSP dosyalarımızı ekleyeceğimiz bir klasör oluşturun . Ben buna " görüntüler " adını verdim ama bir kez daha doğaçlama yapabilirsiniz. Bu klasörde iki JSP dosyası oluşturacağız:

add.jsp — kullanıcı eklemek için bir sayfa;
list.jsp — kullanıcı listesinin görüntülendiği sayfa.

Onlara uygun sayfa başlıkları atayın. " Yeni kullanıcı ekle " ve " Kullanıcı listesi " gibi bir şey ve biz onu bu şekilde bırakacağız.

İki servlet oluştur

Servlet'ler, Tomcat'in kendilerine gönderdiği istekleri alacak ve işleyecektir . src/main/java klasöründe kaynak kodumuzu koyacağımız app paketini oluşturun . Diğer paketler de oraya gidecek. Bu paketlerin birbiri içinde oluşmasını engellemek için uygulama paketinde bir sınıf oluşturacağız (daha sonra sileceğiz). Şimdi uygulama paketinde üç farklı paket oluşturun :

varlıklar — varlıklarımız (kullanıcı nesnelerini tanımlayan sınıf) buraya gelir;
model — modelimizin gittiği yer burasıdır (bunun hakkında biraz sonra konuşacağız);
servlet'ler — ve servlet'lerimizin gittiği yer burasıdır.

Bunu yaptıktan sonra, o sınıfı sakin bir şekilde uygulama paketinden silebilirsiniz (tabii ki siz oluşturduysanız). servlet paketinde iki sınıf oluşturun:

AddServlet — / add adresine gönderilen istekleri işler ;
ListServlet — / liste gönderilen istekleri işler .

Maven'de bağımlılıkları bağlama

Tomcat 9. *, Servlet 4.0 ve JavaServer Pages 2.3 belirtimlerini uygular . Tomcat 9'un resmi belgelerinin ilk paragrafının ikinci satırında belirtilen budur . Bu, benim gibi Tomcat'in bu sürümünü kullanıyorsanız , yazacağınız ve çalıştıracağınız kodun bu sürümleri kullanacağı anlamına gelir. Ancak bu özelliklerin projemizde olmasını isteriz ki bunları kullanan kodumuz en azından başarılı bir şekilde derlenebilsin. Bunu yapmak için de onları projemize yüklememiz gerekiyor. Maven'in kurtarmaya geldiği yer burasıdır .

Genel kural şudur: Maven kullanarak projenize bir şey bağlamanız gerekirse:

Maven'den depo web sitesine gidin;
gerekli kitaplığın gerekli sürümünü bulun;
pom.xml dosyanıza yapıştırılması gereken bağımlılık kodunu alın;
yapıştırmak! :)

Hadi başlayalım. Öncelikle POM dosyasını hazırlayın . /version girişinden sonra , ancak /project öncesinde bir yere aşağıdakini ekleyin:


<dependencies>

</dependencies>

Bunu, bu etiketler içindeki gerekli bağımlılıkları listeleyeceğimizi belirtmek için yapıyoruz. Şimdi mvnrepository.com adresine gidin . Üstte bir arama alanı var. Başlamak için ' servlet'i arayın . Yedi binden fazla kez kullanılmış olan ilk sonuç bize yakışıyor. Unutmayın, sürüm 4.0'a ihtiyacımız var ( Tomcat 9 için). Diğer sürümler eski uygulamalar için uygun olabilir. Bu oldukça yeni bir sürüm, bu yüzden çok fazla kullanım yok. Ama buna ihtiyacımız var. Çeşitli paket yöneticileri için bu bağımlılığın kodunu alabileceğiniz veya basitçe indirebileceğiniz bir sayfa açılır. Ama Maven kullanarak bağlamak istediğimiz için Maven sekmesindeki kodu seçeceğiz. POM dosyamızın Dependency kısmına kopyalayıp yapıştırıyoruz. IDEA'nın sağ alt köşesinde otomatik içe aktarmayı etkinleştirmek isteyip istemediğinizi soran bir bildirim alırsanız devam edin ve kabul edin. Yanlışlıkla reddettiyseniz, " Ayarlar " a gidin ve otomatik içe aktarmayı manuel olarak açın: Ayarlar (Ctrl + Alt + S) -> Oluşturma, Yürütme, Dağıtım -> Maven -> İçe Aktarma .ve bu proje için IDEA yapılandırma dosyaları senkronize halde. Aynı prensibi izleyerek, JavaServer Pages 2.3'ü bulup bağlayacağız ("JSP" için arama yapın). Maven'i zaten başlattığımıza göre, ona kaynak dosyalarımızın Java 8 sözdizimini takip ettiğini ve onları bu sürüm için bayt kodunda derlememiz gerektiğini söyleyelim. Tüm bu adımlardan sonra pom.xml dosyamız şuna benzer:


<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cc.codegym.info.fatfaggy</groupId>
    <artifactId>my-super-project</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compile.source>1.8</maven.compile.source>
        <maven.compile.target>1.8</maven.compile.target>
    </properties>

    <dependencies>
        <!-- Servlet API 4.0 for tomcat 9 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.0</version>
            <scope>provided</scope>
        </dependency>

        <!-- JavaServer Pages API 2.3 for tomcat 9 -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.1</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

</project>

Servletlerimizi gerçek servletlere dönüştürün

Şu anda oluşturduğumuz servlet çiftleri aslında sıradan sınıflar. Herhangi bir işlevselliğe sahip değiller. Ama artık Servlet API'sini projemize bağladık ve buna göre onun sınıflarını kullanabiliriz. Sunucu uygulamalarımızı "gerçek" yapmak için tek yapmamız gereken HttpServlet sınıfını miras almalarını sağlamak.

Eşleme veya işaretleme

Şimdi bir şekilde Tomcat'e / add adresi isteklerinin AddServlet'imiz tarafından işlendiğini ve / list adresi isteklerinin ListServlet tarafından işlendiğini söylemek güzel olurdu . Bu işleme eşleme (işaretleme) denir. Bu, web.xml'de aynı prensip kullanılarak yapılır :

başlamak için sunucu uygulamasını tanımlayın (bir ad verin ve sınıfın kendisine giden yolu belirtin);
daha sonra bu sunucu uygulamasını belirli bir adrese bağlayın (sunucu uygulamasının az önce verdiğimiz adını belirtin ve isteklerinin bu sunucu uygulamasına gönderilmesi gereken adresi belirtin).

Sunucu uygulamasını tanımlayın:


<servlet>
    <servlet-name>add</servlet-name>
    <servlet-class>app.servlets.AddServlet</servlet-class>
</servlet>

Şimdi onu şu adrese bağlayın:


<servlet-mapping>
    <servlet-name>add</servlet-name>
    <url-pattern>/add</url-pattern>
</servlet-mapping>

Gördüğünüz gibi sunucu uygulaması adı her iki durumda da aynıdır. Sonuç olarak Tomcat , /add için bir istek alındığında bunun app.servlets.AddServlet'e gönderilmesi gerektiğini bilir. İkinci servlet için de aynı şeyi yapıyoruz. Sonunda, web.xml dosyamız yaklaşık olarak aşağıdaki içeriğe sahiptir:


<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">

    <!-- add servlet -->
    <servlet>
        <servlet-name>add</servlet-name>
        <servlet-class>app.servlets.AddServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>add</servlet-name>
        <url-pattern>/add</url-pattern>
    </servlet-mapping>

    <!-- list servlet -->
    <servlet>
        <servlet-name>list</servlet-name>
        <servlet-class>app.servlets.ListServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>list</servlet-name>
        <url-pattern>/list</url-pattern>
    </servlet-mapping>
</web-app>

Bu arada, ana sayfa (/) için işaretleme oluşturmadık. Gerçek şu ki, bu durumda ona ihtiyacımız yok. Ana sayfamız, yalnızca iki düğmeyi görüntüleyen basit bir HTML dosyasıdır. Dinamik bir içeriği yoktur, bu nedenle / 'den gelen istekler için ayrı bir sunucu uygulaması oluşturmamıza gerek yoktur , bu uygulama bizim için iki düğme çizmek üzere bazı JSP'lere ( ayrıca oluşturulması gerekir) iletmekten başka bir şey yapmaz. Buna ihtiyacımız yok. Statik bir sayfa bize yakışır. Tomcat bir istek aldığında, bu adres için isteği işleyebilecek tek bir sunucu uygulaması olup olmadığını kontrol edecek ve ardından bu adresin aslında hazır HTML dosyasını zaten içerdiğini görecektir., hizmet edecek. Uygulamamızı yeniden çalıştırabiliriz (sunucuyu yeniden başlatabilir veya yeniden konuşlandırabiliriz - ne isterseniz) ve ana sayfanın görüntülendiğinden, hiçbir şeyin bozulmadığından ve düğmelere tıkladığımızda geçişlerin gerçekleştiğinden emin olabiliriz (yine bir hata alsak da). Bu arada, daha önce 404 hatası alırken şimdi 405 alıyoruz. Bu, eşleştirmenin işe yaradığı ve servletlerin bulunduğu, ancak isteği işlemek için uygun bir yöntemleri olmadığı anlamına gelir.

Kısa ara: "kaputun altında" ne olur?

Muhtemelen uygulamamızın Tomcat'te nasıl çalıştığını zaten düşündünüz. Orada ne olur? Ve main() yöntemi nerede? Tarayıcınızda localhost:8080'e gider gitmez, tarayıcı HTTP protokolünü kullanarak bu adrese bir istek gönderir. Umarım birçok farklı türde istek olduğunun ve en popüler olanlarının GET ve POST olduğunun farkındasındır. Her talebe cevap verilmelidir. Bir GET isteğinin, tarayıcıya döndürülen, kullanıma hazır HTML kodunun bir yanıtını alması beklenir. Tarayıcı daha sonra kodu tüm güzel harfler, düğmeler ve formlarla değiştirir. Bir POST isteği, aynı zamanda bazı bilgiler de taşıdığı için biraz daha ilginçtir. Örneğin, bir web sitesindeki kayıt veya oturum açma formuna kimlik bilgilerini girdiğinizi ve "Gönder"i tıkladığınızı varsayalım. Bu, kişisel bilgilerinizle birlikte bir POST isteğinin sunucuya gönderilmesine neden olur. Sunucu bu bilgileri alır, işler ve bazı yanıtlar verir (örneğin, profilinizi içeren bir HTML sayfası). Aralarındaki temel fark, GET isteklerinin yalnızca sunucudan veri almak için kullanılması, POST isteklerinin ise bazı bilgiler taşımasıdır (ve sunucudaki veriler değişebilir). Örneğin resminizi sunucuya yüklediğinizde POST isteğinde oraya taşınır ve sunucu veritabanına ekler yani değişiklik olur. Şimdi Tomcat'e geri dönelim. Bir istemciden istek aldığında adrese bakar. Bu adres için istekleri işlemek için uygun bir sunucu uygulaması (veya hemen döndürülebilecek kullanılabilir bir kaynak) olup olmadığını kontrol eder. Dönecek bir şey bulamazsa, daha sonra bir HTML sayfası yerine 404 hatasıyla yanıt verir. Ancak bu adreste "oturan" uygun bir sunucu uygulaması bulursa, istek türüne (GET, POST veya başka bir şey) bakar ve sunucu uygulamasına bu tür sorguları işleyebilecek bir yöntemi olup olmadığını sorar. Sunucu uygulaması bu türün nasıl işleneceğini bilmediğini söylüyorsa, o zamanTomcat bir 405 kodu döndürür. Ve projemizde olan da buydu. Ancak uygun bir sunucu uygulaması bulunursa ve uygun bir yöntemi varsa Tomcat bir sunucu uygulaması nesnesi oluşturur ve onu yeni bir iş parçacığında başlatır.(bu, kendi kendine çalışmasına izin verir) ve Tomcat, istekleri kabul edip göndererek kendi işine devam eder. Ek olarak, Tomcat iki nesne daha oluşturur: bir HttpServletRequest (kısaca "istek" olarak adlandıracağım) ve bir HttpServletResponse ("yanıt" olarak adlandıracağım). İstemcinin isteğinden alınan tüm verileri ilk nesneye koyar, böylece tüm veriler ondan çıkarılabilir. Ve tüm bunlardan sonra, bu iki nesneyi, ayrı bir iş parçacığı üzerinde başlatılan servlet'in uygun yöntemine geçirir. Servlet işini bitirir bitirmez ve istemciye gönderilmeye hazır bir yanıt alır almaz, Tomcat'e "Bitirdim. Her şey hazır" diyen bir bayrak sallar. Tomcat yanıtı alır ve istemciye gönderir. Bu, Tomcat'in istekleri almasını ve yanıtları göndermesini sağlar, dikkati dağılmadan ve tüm iş, ayrı iş parçacığı üzerinde çalışan servlet'ler tarafından yapılır. Bu, servlet kodunu yazdığımızda hangi işin gerçekleştirileceğini belirlediğimiz anlamına gelir. Ve main() yöntemini Tomcat'in kendi içinde konumlanmış olarak düşünebilirsiniz (evet, Java'da yazılmıştır) ve Tomcat'i "başlattığımızda", main() yöntemi başlatılır.

Sunucu uygulamaları ve JSP'ler kullanarak basit bir web uygulaması oluşturma (bölüm 1) - 2

GET yöntemlerini yakalamak ve süper basit yanıtlar göndermek için servlet'leri kullanın

Şu anda sunucu uygulamalarımızın uygun yöntemleri (GET) yok, bu nedenle Tomcat bir 405 hatası veriyor. Hadi onları yaratalım! Biz servlet'lerimizin miras aldığı HttpServlet sınıfı, çeşitli yöntemler bildirir. Yöntemlere belirli bir kod atamak için bunları geçersiz kılmamız yeterlidir. doGet()Bu durumda, yöntemi her iki sunucu uygulamasında geçersiz kılmamız gerekir .


@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

}

Gördüğünüz gibi, bu metot iki argüman alır: req (request) ve resp (response). Bunlar, Tomcat'in sunucu uygulamasında uygun yöntemi çağırdığında bizim için oluşturduğu ve doldurduğu nesnelerin ta kendisidir. Başlamak için en basit yanıtları oluşturacağız. Bunu yapmak için resp nesnesini alıp ondan bir PrintWriter nesnesi alacağız. Bu tür bir nesne, bir yanıt oluşturmak için kullanılır. Basit bir dizi çıktısı almak için kullanacağız.


@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    PrintWriter writer = resp.getWriter();
    writer.println("GET method from AddServlet");
}

ListServlet'te benzer bir şey yapacağız ve ardından sunucumuzu yeniden başlatacağız. Gördüğünüz gibi, her şey çalışıyor! Düğmelere tıkladığınızda, PrintWriter ile "yazdığımız" metnin bulunduğu sayfalar alırsınız. Ancak yanıt içeren sayfalar oluşturmak için hazırladığımız JSP dosyaları kullanılmıyor. Bunun nedeni, asla idam edilmemeleridir. Sunucu uygulamamız yanıtı kendisi oluşturur ve çalışmayı bitirerek Tomcat'e istemciye yanıt vermeye hazır olduğunu bildirir. Tomcat sadece yanıtı alır ve istemciye geri gönderir.

Kontrolü sunucu uygulamalarından JSP dosyalarına geçirelim. Yöntemlerimizin kodunu aşağıdaki gibi değiştireceğiz:

istek nesnesinden bir istek gönderici nesnesi alırız ve ona kontrolü aktarmak istediğimiz JSP sayfasının adresini iletiriz;
Tomcat'ten aldığımız istek ve yanıt nesnelerini iletmeyi unutmadan, bu nesneyi kontrolü belirtilen JSP sayfasına aktarmak için kullanırız.


@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    RequestDispatcher requestDispatcher = req.getRequestDispatcher("views/add.jsp");
    requestDispatcher.forward(req, resp);
}

JSP sayfalarının gövde etiketine, hangi sayfanın görüntülendiğini açıkça görebilmemiz için bir şeyler ekleyebilirsiniz. Bunu yaptıktan sonra sunucuyu yeniden başlatın ve kontrol edin. Ana sayfadaki butonlara tıklıyoruz ve sayfalar açılıyor yani istekler servletlere gönderiliyor. Ardından kontrol, şu anda oluşturulmakta olan JSP sayfalarına geçer. Şimdilik bu kadar. Bu yazının bundan sonraki bölümünde uygulamamızın işlevselliği üzerinde çalışacağız.

Daha fazla okuma:
Sunucu uygulamaları ve JSP'ler kullanarak basit bir web uygulaması oluşturma (bölüm 2) Java servlet kullanan ilk uygulamanız

Yorumlar

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION