server HTTP sederhana di Java hanya menggunakan Java SE API

Apakah ada cara untuk membuat server HTTP yang sangat mendasar (hanya mendukung GET / POST) di Jawa hanya menggunakan Java SE API, tanpa menulis kode untuk mengurai permintaan HTTP secara manual dan memformat respons HTTP secara manual? Java SE API dengan baik merangkum fungsionalitas klien HTTP di HttpURLConnection, tetapi apakah ada analog untuk fungsionalitas server HTTP?

Untuk lebih jelasnya, masalah yang saya miliki dengan banyak contoh ServerSocket yang saya lihat online adalah bahwa mereka melakukan parsing / format respons permintaan sendiri dan penanganan kesalahan, yang membosankan, rawan kesalahan, dan tidak cenderung komprehensif, dan saya berusaha menghindarinya karena alasan itu.

Sebagai contoh manipulasi HTTP manual yang saya coba hindari:

http://java.sun.com/developer/technicalArticles/Networking/Webserver/WebServercode.html

Sejak Java SE 6, ada server HTTP bawaan di Sun Oracle JRE. The com.sun.net.httpserverRingkasan paket menguraikan kelas terlibat dan berisi contoh-contoh.

Berikut ini adalah contoh kickoff yang di- copypasted dari dokumen mereka (untuk semua orang yang mencoba mengeditnya, karena ini adalah kode yang jelek, tolong jangan, ini adalah copy paste, bukan milikku, apalagi Anda tidak boleh mengedit kutipan kecuali mereka telah mengubah dalam sumber aslinya). Anda bisa menyalin 'n'paste'n'run di Java 6+.

package com.stackoverflow.q3732109;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;

public class Test {

    public static void main(String[] args) throws Exception {
        HttpServer server = HttpServer.create(new InetSocketAddress(8000), 0);
        server.createContext("/test", new MyHandler());
        server.setExecutor(null); // creates a default executor
        server.start();
    }

    static class MyHandler implements HttpHandler {
        @Override
        public void handle(HttpExchange t) throws IOException {
            String response = "This is the response";
            t.sendResponseHeaders(200, response.length());
            OutputStream os = t.getResponseBody();
            os.write(response.getBytes());
            os.close();
        }
    }

}

Perlu dicatat bahwa response.length()bagian dalam contoh mereka buruk, seharusnya response.getBytes().length. Bahkan kemudian, getBytes()metode harus secara eksplisit menentukan charset yang kemudian Anda tentukan di header respons. Sayangnya, meskipun sesat untuk pemula, itu semua hanya contoh awal kickoff.

Jalankan dan buka http: // localhost: 8000 / test dan Anda akan melihat respons berikut:

Inilah jawabannya

Untuk menggunakan com.sun.*kelas, perlu dicatat bahwa ini bertentangan dengan apa yang dipikirkan beberapa pengembang, sama sekali tidak dilarang oleh FAQ yang terkenal. Mengapa Pengembang Tidak Harus Menulis Program yang Menyebut Paket 'sun' . FAQ itu menyangkut sun.*paket (seperti sun.misc.BASE64Encoder) untuk penggunaan internal oleh Oracle JRE (yang dengan demikian akan mematikan aplikasi Anda ketika Anda menjalankannya di JRE yang berbeda), bukan com.sun.*paket. Sun / Oracle juga hanya mengembangkan perangkat lunak di atas Java SE API sendiri seperti setiap perusahaan lain seperti Apache dan sebagainya. Menggunakan com.sun.*kelas hanya dianjurkan (tetapi tidak dilarang) ketika menyangkut implementasi API Java tertentu, seperti GlassFish (Java EE impl), Mojarra (JSF impl), Jersey (JAX-RS impl), dll.

Lihat NanoHttpd

"NanoHTTPD adalah server HTTP ringan yang dirancang untuk disematkan dalam aplikasi lain, dirilis di bawah lisensi BSD yang Dimodifikasi.

Ini sedang dikembangkan di Github dan menggunakan Apache Maven untuk pengujian unit & pengembangan "

The com.sun.net.httpserver solusi adalah tidak portabel di JRE. Lebih baik menggunakan API layanan web resmi di javax.xml.ws untuk mem -bootstrap server HTTP minimal ...

import java.io._
import javax.xml.ws._
import javax.xml.ws.http._
import javax.xml.transform._
import javax.xml.transform.stream._

@WebServiceProvider
@ServiceMode(value=Service.Mode.PAYLOAD) 
class P extends Provider[Source] {
  def invoke(source: Source) = new StreamSource( new StringReader("<p>Hello There!</p>"));
}

val address = "http://127.0.0.1:8080/"
Endpoint.create(HTTPBinding.HTTP_BINDING, new P()).publish(address)

println("Service running at "+address)
println("Type [CTRL]+[C] to quit!")

Thread.sleep(Long.MaxValue)

EDIT: ini benar-benar berfungsi! Kode di atas terlihat seperti Groovy atau sesuatu. Berikut ini adalah terjemahan ke Jawa yang saya uji:

import java.io.*;
import javax.xml.ws.*;
import javax.xml.ws.http.*;
import javax.xml.transform.*;
import javax.xml.transform.stream.*;

@WebServiceProvider
@ServiceMode(value = Service.Mode.PAYLOAD)
public class Server implements Provider<Source> {

    public Source invoke(Source request) {
        return  new StreamSource(new StringReader("<p>Hello There!</p>"));
    }

    public static void main(String[] args) throws InterruptedException {

        String address = "http://127.0.0.1:8080/";
        Endpoint.create(HTTPBinding.HTTP_BINDING, new Server()).publish(address);

        System.out.println("Service running at " + address);
        System.out.println("Type [CTRL]+[C] to quit!");

        Thread.sleep(Long.MAX_VALUE);
    }
}

Saya suka pertanyaan ini karena ini adalah area di mana ada inovasi terus menerus dan selalu ada kebutuhan untuk memiliki server yang ringan terutama ketika berbicara tentang server yang tertanam dalam perangkat kecil (er). Saya pikir jawaban terbagi dalam dua kelompok besar.

1. Thin-server : konten statis server-up dengan pemrosesan minimal, konteks atau pemrosesan sesi.
2. Small-server : seolah-olah memiliki banyak kualitas server seperti httpD dengan jejak sekecil yang Anda bisa lolos.

Sementara saya mungkin mempertimbangkan perpustakaan HTTP seperti: Jetty , Apache Http Components , Netty dan lainnya lebih seperti fasilitas pemrosesan HTTP mentah. Pelabelan sangat subyektif, dan tergantung pada jenis hal yang Anda panggil untuk situs kecil. Saya membuat perbedaan ini dalam semangat pertanyaan, terutama komentar tentang ...

• "... tanpa menulis kode untuk mem-parsing permintaan HTTP secara manual dan memformat respons HTTP secara manual ..."

Alat mentah ini memungkinkan Anda melakukan itu (seperti yang dijelaskan dalam jawaban lain). Mereka tidak benar-benar memberikan gaya siap pakai untuk membuat server yang ringan, tertanam atau mini. Mini-server adalah sesuatu yang dapat memberi Anda fungsionalitas yang mirip dengan server web yang berfungsi penuh (seperti katakanlah, Tomcat ) tanpa bel dan peluit, volume rendah, kinerja yang baik 99% dari waktu. Thin-server tampaknya lebih dekat dengan ungkapan asli hanya sedikit lebih banyak daripada mentah mungkin dengan fungsi subset terbatas, cukup untuk membuat Anda terlihat baik 90% dari waktu. Gagasan saya tentang mentah akan membuat saya terlihat bagus 75% - 89% dari waktu tanpa desain dan coding tambahan. Saya pikir jika / ketika Anda mencapai tingkat file WAR, kami telah meninggalkan "kecil" untuk server bonsi yang terlihat seperti semua server besar tidak lebih kecil.

Opsi server-tipis

• Grizzly
• UniRest (multi-bahasa)
• NanoHTTPD (hanya satu file)

Opsi mini-server:

• Spark Java ... Hal-hal baik dimungkinkan dengan banyak konstruksi pembantu seperti Filter, Templat, dll.
• MadVoc ... bertujuan untuk menjadi bonsai dan bisa juga ;-)

Di antara hal-hal lain yang perlu dipertimbangkan, saya akan menyertakan otentikasi, validasi, internasionalisasi, menggunakan sesuatu seperti FreeMaker atau alat template lain untuk membuat output halaman. Kalau tidak, mengelola pengeditan dan parameterisasi HTML kemungkinan akan membuat bekerja dengan HTTP terlihat seperti noughts-n-crosses. Secara alami itu semua tergantung pada seberapa fleksibel Anda perlu. Jika ini adalah mesin FAX yang digerakkan oleh menu, itu bisa sangat sederhana. Semakin banyak interaksi, semakin tebal kerangka kerja Anda. Pertanyaan bagus, semoga berhasil!

Lihatlah server web "Jetty" Jetty . Sepotong perangkat lunak Open Source yang luar biasa yang tampaknya memenuhi semua persyaratan Anda.

Jika Anda bersikeras untuk menggulirkan sendiri maka lihatlah kelas "httpMessage".

Sekali waktu saya sedang mencari sesuatu yang serupa - server HTTP ringan namun berfungsi penuh yang saya dapat dengan mudah menanamkan dan menyesuaikan. Saya menemukan dua jenis solusi potensial:

• Server lengkap yang tidak terlalu ringan atau sederhana (untuk definisi ekstrem ringan.)
• Server yang benar-benar ringan yang tidak cukup server HTTP, tetapi contoh ServerSocket dimuliakan yang bahkan tidak sesuai dengan RFC dan tidak mendukung fungsi dasar yang umum dibutuhkan.

Jadi ... Saya mulai menulis JLHTTP - Java HTTP Server yang Ringan .

Anda dapat menanamkannya dalam proyek apa pun sebagai file sumber tunggal (jika agak panjang), atau sebagai stoples ~ 50K (~ 35K dilucuti) tanpa ketergantungan. Itu berusaha untuk menjadi RFC-compliant dan mencakup dokumentasi yang luas dan banyak fitur berguna sambil menjaga mengasapi ke minimum.

Fitur termasuk: host virtual, penyajian file dari disk, pemetaan tipe mime melalui file mime.types standar, pembuatan indeks direktori, file sambutan, dukungan untuk semua metode HTTP, ETag bersyarat dan dukungan header If- *, penyandian transfer chunked, gzip / deflate kompresi, HTTPS dasar (seperti yang disediakan oleh JVM), konten parsial (kelanjutan unduhan), penanganan multi-bagian / formulir-data untuk unggahan file, penangan konteks berganda melalui API atau anotasi, penguraian parameter (string kueri atau x-www-form-urlencoded) tubuh), dll.

Saya harap orang lain merasakan manfaatnya :-)

Server web yang sangat mendasar yang ditulis dalam java dapat ditemukan di sini http://library.sourcerabbit.com/v/?id=19

Spark adalah yang paling sederhana, berikut ini panduan mulai cepat: http://sparkjava.com/

Dimungkinkan untuk membuat httpserver yang menyediakan dukungan dasar untuk servlet J2EE hanya dengan JDK dan api servlet hanya dalam beberapa baris kode.

Saya telah menemukan ini sangat berguna untuk servlets unit testing, karena mulai jauh lebih cepat daripada wadah ringan lainnya (kami menggunakan dermaga untuk produksi).

Httpserver yang paling ringan tidak memberikan dukungan untuk servlet, tetapi kami membutuhkannya, jadi saya pikir saya akan membagikannya.

Contoh di bawah ini memberikan dukungan servlet dasar, atau melempar dan UnsupportedOperationException untuk hal-hal yang belum diimplementasikan. Ia menggunakan com.sun.net.httpserver.HttpServer untuk dukungan http dasar.

import java.io.*;
import java.lang.reflect.*;
import java.net.InetSocketAddress;
import java.util.*;

import javax.servlet.*;
import javax.servlet.http.*;

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;

@SuppressWarnings("deprecation")
public class VerySimpleServletHttpServer {
    HttpServer server;
    private String contextPath;
    private HttpHandler httpHandler;

    public VerySimpleServletHttpServer(String contextPath, HttpServlet servlet) {
        this.contextPath = contextPath;
        httpHandler = new HttpHandlerWithServletSupport(servlet);
    }

    public void start(int port) throws IOException {
        InetSocketAddress inetSocketAddress = new InetSocketAddress(port);
        server = HttpServer.create(inetSocketAddress, 0);
        server.createContext(contextPath, httpHandler);
        server.setExecutor(null);
        server.start();
    }

    public void stop(int secondsDelay) {
        server.stop(secondsDelay);
    }

    public int getServerPort() {
        return server.getAddress().getPort();
    }

}

final class HttpHandlerWithServletSupport implements HttpHandler {

    private HttpServlet servlet;

    private final class RequestWrapper extends HttpServletRequestWrapper {
        private final HttpExchange ex;
        private final Map<String, String[]> postData;
        private final ServletInputStream is;
        private final Map<String, Object> attributes = new HashMap<>();

        private RequestWrapper(HttpServletRequest request, HttpExchange ex, Map<String, String[]> postData, ServletInputStream is) {
            super(request);
            this.ex = ex;
            this.postData = postData;
            this.is = is;
        }

        @Override
        public String getHeader(String name) {
            return ex.getRequestHeaders().getFirst(name);
        }

        @Override
        public Enumeration<String> getHeaders(String name) {
            return new Vector<String>(ex.getRequestHeaders().get(name)).elements();
        }

        @Override
        public Enumeration<String> getHeaderNames() {
            return new Vector<String>(ex.getRequestHeaders().keySet()).elements();
        }

        @Override
        public Object getAttribute(String name) {
            return attributes.get(name);
        }

        @Override
        public void setAttribute(String name, Object o) {
            this.attributes.put(name, o);
        }

        @Override
        public Enumeration<String> getAttributeNames() {
            return new Vector<String>(attributes.keySet()).elements();
        }

        @Override
        public String getMethod() {
            return ex.getRequestMethod();
        }

        @Override
        public ServletInputStream getInputStream() throws IOException {
            return is;
        }

        @Override
        public BufferedReader getReader() throws IOException {
            return new BufferedReader(new InputStreamReader(getInputStream()));
        }

        @Override
        public String getPathInfo() {
            return ex.getRequestURI().getPath();
        }

        @Override
        public String getParameter(String name) {
            String[] arr = postData.get(name);
            return arr != null ? (arr.length > 1 ? Arrays.toString(arr) : arr[0]) : null;
        }

        @Override
        public Map<String, String[]> getParameterMap() {
            return postData;
        }

        @Override
        public Enumeration<String> getParameterNames() {
            return new Vector<String>(postData.keySet()).elements();
        }
    }

    private final class ResponseWrapper extends HttpServletResponseWrapper {
        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        final ServletOutputStream servletOutputStream = new ServletOutputStream() {

            @Override
            public void write(int b) throws IOException {
                outputStream.write(b);
            }
        };

        private final HttpExchange ex;
        private final PrintWriter printWriter;
        private int status = HttpServletResponse.SC_OK;

        private ResponseWrapper(HttpServletResponse response, HttpExchange ex) {
            super(response);
            this.ex = ex;
            printWriter = new PrintWriter(servletOutputStream);
        }

        @Override
        public void setContentType(String type) {
            ex.getResponseHeaders().add("Content-Type", type);
        }

        @Override
        public void setHeader(String name, String value) {
            ex.getResponseHeaders().add(name, value);
        }

        @Override
        public javax.servlet.ServletOutputStream getOutputStream() throws IOException {
            return servletOutputStream;
        }

        @Override
        public void setContentLength(int len) {
            ex.getResponseHeaders().add("Content-Length", len + "");
        }

        @Override
        public void setStatus(int status) {
            this.status = status;
        }

        @Override
        public void sendError(int sc, String msg) throws IOException {
            this.status = sc;
            if (msg != null) {
                printWriter.write(msg);
            }
        }

        @Override
        public void sendError(int sc) throws IOException {
            sendError(sc, null);
        }

        @Override
        public PrintWriter getWriter() throws IOException {
            return printWriter;
        }

        public void complete() throws IOException {
            try {
                printWriter.flush();
                ex.sendResponseHeaders(status, outputStream.size());
                if (outputStream.size() > 0) {
                    ex.getResponseBody().write(outputStream.toByteArray());
                }
                ex.getResponseBody().flush();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                ex.close();
            }
        }
    }

    public HttpHandlerWithServletSupport(HttpServlet servlet) {
        this.servlet = servlet;
    }

    @SuppressWarnings("deprecation")
    @Override
    public void handle(final HttpExchange ex) throws IOException {
        byte[] inBytes = getBytes(ex.getRequestBody());
        ex.getRequestBody().close();
        final ByteArrayInputStream newInput = new ByteArrayInputStream(inBytes);
        final ServletInputStream is = new ServletInputStream() {

            @Override
            public int read() throws IOException {
                return newInput.read();
            }
        };

        Map<String, String[]> parsePostData = new HashMap<>();

        try {
            parsePostData.putAll(HttpUtils.parseQueryString(ex.getRequestURI().getQuery()));

            // check if any postdata to parse
            parsePostData.putAll(HttpUtils.parsePostData(inBytes.length, is));
        } catch (IllegalArgumentException e) {
            // no postData - just reset inputstream
            newInput.reset();
        }
        final Map<String, String[]> postData = parsePostData;

        RequestWrapper req = new RequestWrapper(createUnimplementAdapter(HttpServletRequest.class), ex, postData, is);

        ResponseWrapper resp = new ResponseWrapper(createUnimplementAdapter(HttpServletResponse.class), ex);

        try {
            servlet.service(req, resp);
            resp.complete();
        } catch (ServletException e) {
            throw new IOException(e);
        }
    }

    private static byte[] getBytes(InputStream in) throws IOException {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        while (true) {
            int r = in.read(buffer);
            if (r == -1)
                break;
            out.write(buffer, 0, r);
        }
        return out.toByteArray();
    }

    @SuppressWarnings("unchecked")
    private static <T> T createUnimplementAdapter(Class<T> httpServletApi) {
        class UnimplementedHandler implements InvocationHandler {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                throw new UnsupportedOperationException("Not implemented: " + method + ", args=" + Arrays.toString(args));
            }
        }

        return (T) Proxy.newProxyInstance(UnimplementedHandler.class.getClassLoader(),
                new Class<?>[] { httpServletApi },
                new UnimplementedHandler());
    }
}

Saya sangat merekomendasikan melihat ke dalam Simple , terutama jika Anda tidak memerlukan kemampuan Servlet tetapi hanya akses ke objek permintaan / tanggapan. Jika Anda memerlukan REST, Anda dapat menempatkan Jersey di atasnya, jika Anda perlu menampilkan HTML atau yang serupa ada Freemarker. Saya benar-benar menyukai apa yang dapat Anda lakukan dengan kombinasi ini, dan ada relatif sedikit API untuk dipelajari.

Kode ini lebih baik dari kita, Anda hanya perlu menambahkan 2 lib : javax.servelet.jar dan org.mortbay.jetty.jar .

Dermaga Kelas:

package jetty;

import java.util.logging.Level;
import java.util.logging.Logger;
import org.mortbay.http.SocketListener;
import org.mortbay.jetty.Server;
import org.mortbay.jetty.servlet.ServletHttpContext;

public class Jetty {

    public static void main(String[] args) {
        try {
            Server server = new Server();
            SocketListener listener = new SocketListener();      

            System.out.println("Max Thread :" + listener.getMaxThreads() + " Min Thread :" + listener.getMinThreads());

            listener.setHost("localhost");
            listener.setPort(8070);
            listener.setMinThreads(5);
            listener.setMaxThreads(250);
            server.addListener(listener);            

            ServletHttpContext context = (ServletHttpContext) server.getContext("/");
            context.addServlet("/MO", "jetty.HelloWorldServlet");

            server.start();
            server.join();

        /*//We will create our server running at http://localhost:8070
        Server server = new Server();
        server.addListener(":8070");

        //We will deploy our servlet to the server at the path '/'
        //it will be available at http://localhost:8070
        ServletHttpContext context = (ServletHttpContext) server.getContext("/");
        context.addServlet("/MO", "jetty.HelloWorldServlet");

        server.start();
        */

        } catch (Exception ex) {
            Logger.getLogger(Jetty.class.getName()).log(Level.SEVERE, null, ex);
        }

    }
} 

Kelas Servlet:

package jetty;

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

public class HelloWorldServlet extends HttpServlet
{
    @Override
    protected void doGet(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws ServletException, IOException
    {
        String appid = httpServletRequest.getParameter("appid");
        String conta = httpServletRequest.getParameter("conta");

        System.out.println("Appid : "+appid);
        System.out.println("Conta : "+conta);

        httpServletResponse.setContentType("text/plain");
        PrintWriter out = httpServletResponse.getWriter();
        out.println("Hello World!");
        out.close();
    }
}

Anda juga dapat melihat beberapa kerangka kerja aplikasi NIO seperti:

1. Netty: http://jboss.org/netty
2. Apache Mina: http://mina.apache.org/ atau proyeknya AsyncWeb: http://mina.apache.org/asyncweb/

Semua jawaban di atas merinci tentang Handler Permintaan Utama berulir tunggal.

pengaturan:

 server.setExecutor(java.util.concurrent.Executors.newCachedThreadPool());

Mengizinkan beberapa permintaan ditayangkan melalui beberapa utas menggunakan layanan pelaksana.

Jadi kode akhirnya akan seperti di bawah ini:

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;
public class App {
    public static void main(String[] args) throws Exception {
        HttpServer server = HttpServer.create(new InetSocketAddress(8000), 0);
        server.createContext("/test", new MyHandler());
        //Thread control is given to executor service.
        server.setExecutor(java.util.concurrent.Executors.newCachedThreadPool());
        server.start();
    }
    static class MyHandler implements HttpHandler {
        @Override
        public void handle(HttpExchange t) throws IOException {
            String response = "This is the response";
            long threadId = Thread.currentThread().getId();
            System.out.println("I am thread " + threadId );
            response = response + "Thread Id = "+threadId;
            t.sendResponseHeaders(200, response.length());
            OutputStream os = t.getResponseBody();
            os.write(response.getBytes());
            os.close();
        }
    }
}

checkout Sederhana . ini adalah server embeddable yang cukup sederhana dengan dukungan bawaan untuk beragam operasi. Saya sangat suka model threading-nya ..

Luar biasa!

Lihat takes. Lihatlah https://github.com/yegor256/takes untuk info cepat

Bagaimana dengan proyek Apache Commons HttpCore ?

Dari situs web: ... HttpCore Goals

• Implementasi aspek transportasi HTTP yang paling mendasar
• Seimbangkan antara kinerja yang baik dan kejelasan & ekspresi API
• Jejak memori kecil (dapat diprediksi)
• Pustaka mandiri (tidak ada dependensi eksternal di luar JRE)

Coba ini https://github.com/devashish234073/Java-Socket-Http-Server/blob/master/README.md

API ini telah membuat server HTTP menggunakan soket.

1. Itu mendapat permintaan dari browser sebagai teks
2. Parsing untuk mengambil info URL, metode, atribut, dll.
3. Membuat respons dinamis menggunakan pemetaan URL yang ditentukan
4. Mengirim respons ke browser.

Sebagai contoh, inilah cara konstruktor di Response.javakelas mengubah respons mentah menjadi respons http:

public Response(String resp){
    Date date = new Date();
    String start = "HTTP/1.1 200 OK\r\n";
    String header = "Date: "+date.toString()+"\r\n";
    header+= "Content-Type: text/html\r\n";
    header+= "Content-length: "+resp.length()+"\r\n";
    header+="\r\n";
    this.resp=start+header+resp;
}

Anda dapat menulis server Jetty Java tertanam yang cukup sederhana .

Embedded Jetty berarti bahwa server (Jetty) dikirimkan bersama dengan aplikasi sebagai lawan dari penerapan aplikasi pada server Jetty eksternal.

Jadi jika dalam pendekatan non-embedded webapp Anda dibangun ke dalam file WAR yang digunakan untuk beberapa server eksternal ( Tomcat / Jetty / etc), di Jetty tertanam, Anda menulis webapp dan instantiate server dermaga di basis kode yang sama.

Contoh untuk server Jetty Java tertanam, Anda dapat menggunakan clone dan menggunakan: https://github.com/stas-slu/embedded-jetty-java-server-example