JavaRush /Blog Java /Random-MS /Aplikasi web dalam Java

Tahap

28 February 2021
48 views
0 comments

Aplikasi web dalam Java

pengenalan

Suatu ketika dahulu, Java mengukuhkan kedudukannya kerana ia memilih aplikasi web sebagai keutamaan. Sejak awalnya, Java telah berjuang untuk mencari jalannya. Pertama, saya mencadangkan applet. Ini telah memberikan banyak peluang kepada pembangun untuk mencipta kandungan dinamik pada halaman HTML statik. Walau bagaimanapun, applet tidak memenuhi jangkaan atas banyak sebab: keselamatan, overhed dan lain-lain. Kemudian pembangun bahasa Java mencadangkan alternatif - Servlet API . Dan ternyata ia adalah keputusan yang tepat. API Servlet ialah spesifikasi yang mana mana-mana aplikasi web Java dibina, sama ada aplikasi berasaskan web atau perkhidmatan web yang mengembalikan maklumat seperti yang diminta. Oleh itu, laluan untuk memahami cara aplikasi web Java berfungsi bermula dengan memahami API Servlet.

API Servlet

Jadi, API Servlet ialah apa yang ditawarkan oleh pembangun bahasa kepada pembangun Java. API Servlet ialah spesifikasi yang harus menjawab soalan utama kami. Anda boleh menemuinya di sini: " JSR-000340 JavaTM Servlet 3.1 Keluaran Akhir untuk Penilaian ". Bab " 1.1 Apakah itu Servlet? " mengatakan bahawa servlet ialah komponen web berdasarkan teknologi Java yang mencipta kandungan dinamik (iaitu kandungan). "Berasaskan Java" bermaksud bahawa servlet ialah kelas Java yang disusun ke dalam bytecode . Servlet diuruskan oleh bekas servlet, kadangkala dipanggil Enjin Servlet. Bekas servlet ialah sambungan pelayan web yang menyediakan fungsi servlet. Sebaliknya, servlet menyediakan interaksi dengan klien dalam paradigma permintaan/tindak balas, yang dilaksanakan oleh bekas servlet. Dalam bab " 1.2 Apakah itu Kontena Servlet? " dikatakan bahawa bekas servlet adalah sebahagian daripada pelayan web atau pelayan aplikasi yang menyediakan perkhidmatan rangkaian yang melaluinya permintaan dan respons dihantar, permintaan dan respons berasaskan MIME dijana dan diproses . Selain itu, bekas servlet menguruskan kitaran hayat servlet (iaitu memutuskan masa untuk menciptanya, memadamkannya, dsb.). Semua bekas servlet mesti menyokong protokol HTTP untuk menerima permintaan dan menghantar respons. Di sini saya ingin menambah bahawa MIME ialah standard, spesifikasi yang memberitahu cara maklumat harus dikodkan dan mesej diformatkan supaya ia boleh dihantar melalui Internet.

Pelayan web

Pelayan web ialah pelayan yang menerima permintaan HTTP daripada pelanggan dan memberikan mereka respons HTTP (biasanya bersama-sama dengan halaman HTML, imej, fail atau data lain). Sumber yang diminta dikenal pasti melalui URL. Salah satu pelayan web paling popular dengan sokongan Servlet API ialah Apache Tomcat . Kebanyakan pelayan web adalah mesin kompleks yang terdiri daripada pelbagai komponen, setiap satunya menjalankan fungsi tertentu. Sebagai contoh:

Penyambung

— Pada input kami mempunyai Penyambung (iaitu penyambung) yang menerima permintaan masuk daripada pelanggan. Penyambung HTTP dalam Tomcat dilaksanakan menggunakan komponen "Coyote". Penyambung menerima data daripada klien dan menyampaikannya kepada Enjin Tomcat. Bekas Servlet - Enjin Tomcat, seterusnya, memproses permintaan yang diterima daripada pelanggan menggunakan komponen "Catalina", iaitu bekas servlet. Lihat dokumentasi Tomcat: " Gambaran Keseluruhan Seni Bina " untuk butiran lanjut. Terdapat pelayan web lain yang menyokong spesifikasi API Servlet. Contohnya, " Jeti " atau " Undertow ". Seni bina mereka adalah serupa, jadi memahami prinsip bekerja dengan satu bekas servlet, anda boleh beralih kepada bekerja dengan yang lain.

Aplikasi sesawang

Jadi, untuk kami menjalankan aplikasi web, kami memerlukan pelayan web yang menyokong API Servlet (iaitu, yang mempunyai komponen sambungan yang melaksanakan sokongan API Servlet untuk pelayan web). baiklah. Apakah aplikasi web pula? Menurut bab " 10 Aplikasi Web " spesifikasi API Servlet, aplikasi Web ialah koleksi servlet, halaman HTML, kelas dan sumber lain yang membentuk aplikasi akhir pada pelayan Web. Menurut bab " 10.6 Web Application Archive File ", aplikasi web boleh dibungkus dalam Web ARchive (arkib dengan sambungan WAR). Seperti yang dinyatakan pada halaman " Glosari-219 ":

Iaitu, WAR dibuat dan bukannya JAR untuk menunjukkan bahawa ini adalah aplikasi web. Fakta penting seterusnya: kita mesti mempunyai struktur direktori tertentu dalam arkib WAR kami. Dalam spesifikasi API Servlet dalam bab " 10.5 Struktur Direktori ". Bab ini mengatakan bahawa terdapat direktori khas yang dipanggil "WEB-INF". Direktori ini istimewa kerana ia tidak dapat dilihat oleh pelanggan dan tidak ditunjukkan secara langsung kepadanya, tetapi ia boleh diakses oleh kod servlet. Ia juga menyatakan perkara yang boleh mengandungi direktori WEB-INF:

Daripada keseluruhan senarai ini, kami kini tidak tahu dan tidak memahami item tentang beberapa fail web.xml yang dipanggil deployment descriptor . Apa itu? Bab " 14. Deskriptor Deployment " ditumpukan kepada deskriptor penempatan. Ringkasnya, deskriptor penempatan ialah fail xml yang menerangkan cara untuk menggunakan (iaitu, menjalankan) aplikasi web kami pada pelayan web. Sebagai contoh, deskriptor penempatan menunjukkan URL yang harus digunakan untuk mengakses aplikasi kami, tetapan keselamatan yang berkaitan dengan aplikasi kami, dll. ditunjukkan. Bab " 14.2 Peraturan untuk Memproses Penggunaan " mengatakan bahawa web.xml akan disahkan skema sebelum aplikasi kami dikonfigurasikan dan dilancarkan (iaitu, semakan akan dibuat bahawa kandungan web.xml ditulis dengan betul mengikut skema) . Dan dalam bab " 14.3 Deskriptor Deployment " ditunjukkan bahawa gambar rajah ada di sini: http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd Jika kita melihat kandungan fail, kita dapat melihat:

Apakah skema yang digunakan untuk fail XML? Skema menunjukkan cara mengisi dokumen XML dengan betul: elemen apa yang boleh digunakan, jenis data apa yang boleh ditentukan dalam elemen, mengikut urutan elemen harus pergi, elemen apa yang diperlukan, dsb. Anda boleh membandingkan skema dokumen XML dengan antara muka dalam Java, kerana skema dalam Java juga menentukan cara kelas yang memenuhi antara muka yang diberikan (iaitu, yang melaksanakan antara muka yang diberikan) harus ditulis. Jadi, kami dipersenjatai dengan pengetahuan rahsia dan bersedia untuk mencipta aplikasi web pertama kami!

Mencipta Aplikasi Web

Sukar untuk membayangkan bekerja dengan aplikasi Java moden tanpa menggunakan sistem binaan projek automatik. Beberapa sistem yang paling popular ialah Maven dan Gradle . Kami akan menggunakan Gradle untuk semakan ini. Pemasangan Gradle diterangkan di laman web rasmi . Untuk mencipta aplikasi baharu, kami memerlukan pemalam terbina dalam Gradle: " Bina Init Plugin ". Untuk membuat aplikasi Java, anda perlu menjalankan arahan berikut: gradle init --type java-application

Selepas mencipta projek, kami perlu mengedit fail build.gradle . Ini adalah apa yang dipanggil Skrip Binaan (untuk butiran lanjut, lihat dokumentasi Gradle: " Menulis Skrip Binaan "). Fail ini menerangkan cara memasang projek dan aspek lain untuk bekerja dengan projek Java. Blok pemalam menerangkan " Pemalam Gradle " yang harus digunakan untuk projek Gradle semasa. Pemalam mengembangkan keupayaan projek kami. Sebagai contoh, pemalam lalai ialah " java ". Plugin ini sentiasa digunakan jika kami memerlukan sokongan Java. Tetapi kami tidak memerlukan pemalam " aplikasi ", kerana... penerangannya menyatakan bahawa ia digunakan untuk mencipta "aplikasi JVM boleh laku", i.e. menjalankan aplikasi JVM. Kita perlu mencipta aplikasi Web dalam bentuk arkib WAR. Dan jika kita mencari perkataan WAR dalam dokumentasi Gradle, kita akan menemui " War Plugin ". Oleh itu, kami akan menentukan pemalam berikut:

plugins {
    id 'java'
    id 'war'
}

Juga dalam " War Plugin Default Settings " dikatakan bahawa direktori dengan semua kandungan aplikasi web harus "src/main/webapp", harus ada direktori WEB-INF yang sama di mana web.xml harus berada terletak. Mari buat fail sedemikian. Kami akan mengisinya sedikit kemudian, kerana... kami masih belum mempunyai maklumat yang mencukupi untuk ini. Dalam blok "dependensi" kami menunjukkan kebergantungan projek kami, iaitu perpustakaan/rangka kerja yang tanpanya aplikasi kami tidak boleh berfungsi. Dalam kes ini, kami sedang menulis aplikasi web, yang bermaksud kami tidak boleh berfungsi tanpa API Servlet:

dependencies {
    providedCompile 'javax.servlet:javax.servlet-api:3.1.0'
    testCompile 'junit:junit:4.12'
}

providedCompile bermakna bahawa kebergantungan tidak perlu dimasukkan ke dalam arkib WAR kami bagi aplikasi web: ia hanya diperlukan untuk penyusunan. Dan apabila dilaksanakan, kebergantungan ini akan disediakan oleh orang lain (iaitu, pelayan web). Nah, kami meninggalkan maklumat dalam skrip binaan tentang repositori kebergantungan yang ingin kami gunakan - semua kebergantungan yang ditentukan akan dimuat turun daripadanya:

repositories {
    jcenter()
}

Kami mengalih keluar semua yang lain daripada fail skrip binaan. Sekarang mari edit kelas src\main\java\App.java. Mari kita buat servlet daripadanya. Spesifikasi Servlet API dalam bab " BAB 2. Antara Muka Servlet " menyatakan bahawa Antara Muka Servlet mempunyai pelaksanaan asas HttpServlet , yang sepatutnya mencukupi dalam kebanyakan kes dan pembangun hanya perlu mewarisi daripadanya. Dan dalam bab " 2.1.1 Kaedah Pengendalian Permintaan Khusus HTTP " kaedah utama yang memproses permintaan masuk ditunjukkan. Oleh itu, mari kita tulis semula kelas App.java:

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
import java.io.IOException;

public class App extends HttpServlet {
    public String getGreeting() {
        return "Hello world.";
    }

    public void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 		// https://www.oracle.com/technetwork/java/servlet-142430.html
 		PrintWriter out = resp.getWriter();
 		out.println(this.getGreeting());
 		out.close();
 	}
}

Jadi, kami nampaknya sudah bersedia segala-galanya. Yang tinggal hanyalah menulis deskriptor penempatan dengan betul. Daripada rajah, salin teks berikut ke dalam web.xml:

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="..."
      version="3.1">
      ...
</web-app>

Dan juga laluan ke skema yang ditunjukkan di dalamnya: http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd Sekarang mari kita lihat contoh bagaimana web.xml sepatutnya kelihatan seperti dalam spesifikasi API Servlet. Contoh ini diberikan dalam bab " 14.5.1 Contoh Asas ". Mari gabungkan apa yang ditunjukkan dalam rajah dengan contoh yang ditunjukkan dalam spesifikasi. Kami mendapat perkara berikut:

<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">
      <display-name>A Simple Web Application</display-name>
      <servlet>
		<servlet-name>app</servlet-name>
		<servlet-class>App</servlet-class>
	  </servlet>
	  <servlet-mapping>
		<servlet-name>app</servlet-name>
		<url-pattern>/app</url-pattern>
	  </servlet-mapping>
</web-app>

Seperti yang anda lihat, kami menggunakan skema dan schemaLocation yang telah dinyatakan sebelum ini. Dan penerangan tentang unsur-unsur itu sendiri diambil daripada contoh daripada Bab 14.5.1. Jika kami melakukan semuanya dengan betul, kami akan melaksanakan tugas perang gradle tanpa ralat:

Melancarkan aplikasi web

Bagaimanakah aplikasi web dilancarkan? Mari kita berurusan dengan pilihan yang lebih kompleks terlebih dahulu. Kami sebelum ini mengatakan bahawa terdapat pelayan web Apache Tomcat yang menyokong API Servlet. Ini bermakna kami boleh menggunakan arkib perang kami yang dikumpul (mereka juga menyebut "mengerahkan") pada pelayan ini. Pada halaman " Muat Turun Tomcat ", muat turun jenis penghantaran "Teras" dalam format zip daripada bahagian "Pengagihan Binari". Dan bongkarkan arkib yang dimuat turun ke dalam beberapa direktori, contohnya dalam C:\apache-tomcat-9.0.14. Sebelum memulakan pelayan, mari buka fail untuk diedit conf\tomcat-users.xmldan tambah baris berikut padanya: <user username="tomcat" password="tomcat" roles="tomcat,manager-gui,admin-gui"/> Sekarang, pada baris arahan, pergi ke direktori bin dan jalankan catalina.bat start. Secara lalai, konsol pelayan akan tersedia di http://localhost:8080/manager. Log masuk dan kata laluan adalah sama yang kami tentukan dalam tomcat-users.xml. Tomcat mempunyai direktori "webapps", yang mengandungi aplikasi web. Jika kita mahu menggunakan kita sendiri, kita mesti menyalin arkib perang kita di sana. Apabila kami menjalankan perintah perang gradle sebelum ini, \build\libs\arkib perang telah dibuat dalam direktori. Ini yang perlu kita salin. Selepas menyalin, muat semula halaman http://localhost:8080/managerdan lihat:

Setelah selesai http://localhost:8080/javaweb/app, kami akan beralih kepada servlet kami, kerana Kami sebelum ini "memetakan" (iaitu, memetakan) permintaan /app ke servlet App. Terdapat cara yang lebih pantas untuk menyemak cara aplikasi berfungsi. Dan sistem pemasangan membantu kami dengan ini sekali lagi. Dalam skrip binaan projek Gradle kami, kami boleh menambah pemalam baharu " Gretty " pada bahagian pemalam: id "org.gretty" version "2.3.1" Dan kini kami boleh melaksanakan tugas gradle untuk menjalankan aplikasi kami:gradle appRun

Lihat " Tambah pemalam gretty dan jalankan apl " untuk butiran.

API Spring dan Servlet

Servlet adalah asas kepada segala-galanya. Malah Rangka Kerja Spring yang popular kini tidak lebih daripada tambahan kepada Servlet API. Sebagai permulaan, Rangka Kerja Spring ialah pergantungan baharu untuk projek kami. Oleh itu, mari kita tambahkannya pada skrip binaan dalam blok dependencies: compile 'org.springframework:spring-webmvc:5.1.3.RELEASE' Dalam dokumentasi Spring Framework terdapat bab " 1.1. DispatcherServlet ". Ia mengatakan bahawa Rangka Kerja Spring dibina pada corak "pengawal hadapan" - ini adalah apabila terdapat servlet pusat yang dipanggil " DispatcherServlet ". Semua permintaan datang ke servlet ini, dan ia mewakilkan panggilan kepada komponen yang diperlukan. Anda lihat, di sini pun terdapat servlet. Anda perlu menambah pendengar kepada deskriptor penggunaan:

<listener>
	&ltlistener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

Ini ialah pendengar acara konteks servlet. Iaitu, apabila Konteks Servlet bermula, konteks Spring (WebApplicationContext) juga bermula. Apakah Konteks Servlet? Ia diterangkan dalam spesifikasi API Servle dalam bab " BAB 4. Konteks Servlet ". Konteks servlet ialah "pandangan" servlet bagi aplikasi web di mana servlet sedang berjalan. Setiap aplikasi web mempunyai Konteks Servlet sendiri. Seterusnya, untuk mendayakan Rangka Kerja Spring, anda perlu menentukan konteks-param - parameter permulaan untuk konteks servlet.

<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>/WEB-INF/app-context.xml</param-value>
</context-param>

Dan definisi DispatcherServlet melengkapkan konfigurasi :

<servlet>
	<servlet-name>app</servlet-name>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	<init-param>
		<param-name>contextConfigLocation</param-name>
 		<param-value></param-value>
	</init-param>
	<load-on-startup>1</load-on-startup>
</servlet>

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

Dan sekarang kita hanya perlu mengisi fail yang dinyatakan dalam contextConfigLocation. Cara untuk melakukan ini diterangkan dalam dokumentasi Rangka Kerja Spring dalam bab "1.3.1. Deklarasi":

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <context:component-scan base-package="ru.javarush.javaweb"/>
    <mvc:annotation-driven/>
</beans>

Adalah penting di sini bukan sahaja untuk menunjukkan pakej mana yang hendak diimbas, tetapi juga bahawa kami mahu didorong oleh anotasi, iaitu, untuk mengawal anotasi tentang cara Spring akan berfungsi. Apa yang tinggal ialah mencipta pakej ru.javarush.javaweb dan letakkan kelas pengawal Spring di dalamnya:

package ru.javarush.javaweb;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class SpringController {

    @GetMapping("/app")
    @ResponseBody
    public String getGreeting() {
        return "Hello world.";
    }
}

Sekarang menjalankan gradle appRun dan pergi ke alamat, http://127.0.0.1:8080/javaweb/appkita akan mendapat Hello World yang sama. Seperti yang anda lihat, Rangka Kerja Spring berkait rapat dengan Servlet API dan menggunakannya untuk berfungsi di atasnya.

Anotasi

Seperti yang telah kita lihat, anotasi adalah mudah. Dan bukan kami sahaja yang berpendapat demikian. Oleh itu, dalam spesifikasi API Servlet, bermula dengan versi 3.0, bab " BAB 8 Anotasi dan kebolehpasangan " muncul, yang menyatakan bahawa bekas servlet mesti menyokong keupayaan untuk menentukan perkara yang dinyatakan sebelum ini dalam Deskriptor Deployment melalui anotasi. Oleh itu, web.xml boleh dialih keluar sepenuhnya daripada projek, dan di atas kelas servlet anda boleh menentukan anotasi @WebServlet dan menunjukkan laluan untuk memetakan servlet itu. Semuanya nampak jelas di sini. Tetapi bagaimana jika kami menyambungkan Spring ke projek, yang memerlukan tetapan yang lebih kompleks? Di sini semuanya lebih rumit. Pertama, dokumentasi Spring mengatakan bahawa untuk mengkonfigurasi Spring tanpa web.xml, anda perlu menggunakan kelas anda sendiri yang akan melaksanakan WebApplicationInitializer. Untuk butiran lanjut, lihat bab " 1.1. DispatcherServlet ". Ternyata ini adalah kelas Spring. Bagaimana pula Servlet API digunakan di sini? Malah, ServletContainerInitializer telah ditambahkan pada Servlet API 3.0 . Menggunakan mekanisme khas dalam Java (dipanggil SPI ), Spring menentukan pemula bekas servletnya dipanggil SpringServletContainerInitializer. Sebaliknya, ia sudah mencari pelaksanaan WebApplicationInitializer dan memanggil kaedah yang diperlukan dan melaksanakan tetapan yang diperlukan. Lihat " Cara bekas servlet mencari pelaksanaan WebApplicationInitializer " untuk butiran lanjut. Tetapan di atas boleh dilakukan seperti ini:

package ru.javarush.javaweb.config;

import org.springframework.web.WebApplicationInitializer;
import org.springframework.web.context.ContextLoaderListener;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRegistration;

public class AppInitializer implements WebApplicationInitializer {
    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        // регистрируем конфигурацию созданую высше
        ctx.register(AppConfig.class);
        // добавляем в контекст слушателя с нашей конфигурацией
        servletContext.addListener(new ContextLoaderListener(ctx));

        ctx.setServletContext(servletContext);

        // настраиваем маппинг Dispatcher Servlet-а
        ServletRegistration.Dynamic servlet =
                servletContext.addServlet("dispatcher", new DispatcherServlet(ctx));
        servlet.addMapping("/");
        servlet.setLoadOnStartup(1);
    }
}

Sekarang, menggunakan " konfigurasi berasaskan Java " kami akan menunjukkan pakej mana yang hendak diimbas + mendayakan anotasi:

package ru.javarush.javaweb.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;

@Configuration
@EnableWebMvc
@ComponentScan(basePackages = "ru.javarush.javaweb.controllers")
public class AppConfig {
}

Dan SpringController itu sendiri telah dipindahkan ke ru.javarush.javaweb.controllers, supaya apabila mengimbas, konfigurasi tidak akan menemui dirinya, tetapi hanya akan mencari pengawal.

Merumuskan

Saya harap gambaran keseluruhan ini telah memberi sedikit penerangan tentang cara aplikasi web berfungsi di Java. Ini hanyalah puncak gunung es, tetapi tanpa memahami asasnya, sukar untuk memahami bagaimana teknologi berdasarkan asas ini berfungsi. API Servlet ialah bahagian tengah mana-mana aplikasi web Java, dan kami telah melihat cara rangka kerja lain sesuai dengannya. Untuk meneruskan, anda boleh melihat bahan berikut:

#Viacheslav

Komen

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