वेब एमवीसी एप्लीकेशन बिना फ्रेमवर्क और सर्वलेट्स के

हम वेब फ्रेमवर्क, बाहरी पुस्तकालयों और एक एप्लिकेशन सर्वर का उपयोग किए बिना एक छोटा वेब एप्लिकेशन लिखेंगे।

इस लेख का उद्देश्य एक वेब सेवा के हुड के तहत जो कुछ भी हो रहा है, उसके सामान्य सार को एक उदाहरण के रूप में जावा का उपयोग करके दिखाना है। तो चलिए चलते हैं। हमें तीसरे पक्ष के पुस्तकालयों, साथ ही एक सर्वलेट का उपयोग नहीं करना चाहिए। इसलिए, इस परियोजना को मावेन द्वारा इकट्ठा किया जाएगा, लेकिन निर्भरता के बिना।

जब उपयोगकर्ता ब्राउज़र के एड्रेस बार में एक निश्चित आईपी-एड्रेस (या एक आईपी एड्रेस में बदल जाता है) में प्रवेश करता है, तो क्या होता है? निर्दिष्ट पोर्ट पर, निर्दिष्ट होस्ट के ServerSocket के लिए एक अनुरोध किया गया है।

हम अपनी लोकलहोस्ट पर व्यवस्थित करते हैं, एक यादृच्छिक मुक्त बंदरगाह पर सॉकेट (उदाहरण के लिए 9001)।

public class HttpRequestSocket { private static volatile Socket socket; private HttpRequestSocket() { } public static Socket getInstance() throws IOException { if (socket == null) { synchronized (HttpRequestSocket.class) { if (socket == null) { socket = new ServerSocket(9001).accept(); } } } return socket; } } 

यह मत भूलो कि बंदरगाह पर श्रोता, एक वस्तु के रूप में, एक ही प्रति में हमारे लिए वांछनीय है, इसलिए सिंगलटन (जरूरी नहीं कि डबल-चेक हो, लेकिन ऐसा हो सकता है)।

पोर्ट 9001 पर हमारे होस्ट-ए (लोकलहोस्ट) पर, एक श्रोता है जो उपयोगकर्ता को बाइट्स की एक धारा के रूप में दर्ज करता है।

यदि आप DataInputStream में सॉकेट से बाइट [] घटाते हैं और इसे स्ट्रिंग में परिवर्तित करते हैं, तो आपको कुछ इस तरह मिलता है:

 GET /index HTTP/1.1 Host: localhost:9001 Connection: keep-alive Cache-Control: no-cache Content-Type: application/x-www-form-urlencoded User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.142 Safari/537.36 Postman-Token: 838f4680-a363-731d-aa74-10ee46b9a87a Accept: */* Accept-Encoding: gzip, deflate, br Accept-Language: ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7 

सभी आवश्यक हेडर के साथ मानक Http अनुरोध।

पार्सिंग के लिए, हम डिफ़ॉल्ट तरीकों से एक छोटा सा उपयोग-इंटरफ़ेस बनाते हैं, मेरी राय में यह इस तरह के उद्देश्यों के लिए काफी सुविधाजनक है (इसके अलावा, यदि यह अभी भी स्प्रिंग है, तो हम कक्षा में निर्भरता की संख्या कम कर देते हैं)।

 public interface InputStringUtil { default String parseRequestMapping(final String inputData) { return inputData.split((" "))[1]; } default RequestType parseRequestType(final String source) { return valueOf(source.split(("/"))[0].trim()); } default Map<String, String> parseRequestParameter(final String source) { if (parseRequestType(source) == GET) { return parseGetRequestParameter(source); } else { return parsePostRequestParameter(source); } } @SuppressWarnings("unused") class ParameterParser { static Map<String, String> parseGetRequestParameter(final String source) { final Map<String, String> parameterMap = new HashMap<>(); if(source.contains("?")){ final String parameterBlock = source.substring(source.indexOf("?") + 1, source.indexOf("HTTP")).trim(); for (final String s : parameterBlock.split(Pattern.quote("&"))) { parameterMap.put(s.split(Pattern.quote("="))[0], s.split(Pattern.quote("="))[1]); } } return parameterMap; } static Map<String, String> parsePostRequestParameter(final String source) { //todo task #2 return new HashMap<>(); } } } 

यह उपयोग GET और POST दोनों अनुरोधों के लिए अनुरोध प्रकार, url और मापदंडों की सूची को पार्स कर सकता है।

पार्सिंग की प्रक्रिया में, हम अनुरोध पैरामीटर के साथ लक्ष्य यूआरएल और मानचित्र के साथ अनुरोध मॉडल बनाते हैं।

हमारी सेवा का नियंत्रक पुस्तकालय के लिए एक छोटा सा अमूर्त हिस्सा है जिसमें हम किताबें जोड़ सकते हैं (इस कार्यान्वयन में, बस सूची में), पुस्तकों को हटा दें और सभी पुस्तकों की सूची वापस कर दें।

1. नियंत्रक

 public class BookController { private static volatile BookController bookController; private BookController() { } public static BookController getInstance() { if (bookController == null) { synchronized (BookController.class) { if (bookController == null) { bookController = new BookController(); } } } return bookController; } @RequestMapping(path = "/index") @SuppressWarnings("unused") public void index(final Map<String, String> paramMap) { final Map<String, List<DomainBook>> map = new HashMap<>(); map.put("book", DefaultBookService.getInstance().getCollection()); HtmlMarker.getInstance().makeTemplate("index", map); } @RequestMapping(path = "/add") @SuppressWarnings("unused") public void addBook(final Map<String, String> paramMap) { DefaultBookService.getInstance().addBook(paramMap); final Map<String, List<DomainBook>> map = new HashMap<>(); map.put("book", DefaultBookService.getInstance().getCollection()); HtmlMarker.getInstance().makeTemplate("index", map); } } 

हमारे पास एक सिंगलटन कंट्रोलर भी है।

हम RequestMapping रजिस्टर करते हैं। बंद करो, हम इसे एक ढांचे के बिना करते हैं, क्या RequestMapping? यह एनोटेशन हमें खुद लिखना होगा।

 @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @interface RequestMapping { String path() default "/"; } 

यह भी संभव था कि कंट्रोलर एनोटेशन को क्लास में जोड़ा जाए और, एप्लीकेशन स्टार्टअप पर, इस एनोटेशन और उनके तरीकों से चिह्नित सभी क्लासेस को इकट्ठा करें, और उन्हें यूआरएल मैपिंग से एक निश्चित मैप में जोड़ें। लेकिन वर्तमान कार्यान्वयन में हम खुद को एक नियंत्रक तक सीमित कर लेंगे।

नियंत्रक से पहले, हमारे पास एक निश्चित प्रीप्रोसेसर होगा, जो प्रोग्राम के मॉडल को समझने के लिए अनुरोध मॉडल को बनाएगा और नियंत्रक विधियों को मैप करेगा।

 public class HttpRequestPreProcessor implements InputStringUtil { private final byte[] BYTE_BUFFER = new byte[1024]; public void doRequest() { try { while (true) { System.out.println("Socket open"); final Socket socket = HttpRequestSocket.getInstance(); final DataInputStream in = new DataInputStream(new BufferedInputStream(socket.getInputStream())); final String inputUrl = new String(BYTE_BUFFER, 0, in.read(BYTE_BUFFER)); processRequest(inputUrl); System.out.println("send request " + inputUrl); } } catch (final IOException e) { e.printStackTrace(); } } private void processRequest(final String inputData) { final String urlMapping = parseRequestMapping(inputData); final Map<String, String> paramMap = parseRequestParameter(inputData); final Method[] methods = BookController.getInstance().getClass().getMethods(); for (final Method method : methods) { if (method.isAnnotationPresent(RequestMapping.class) && urlMapping.contains(method.getAnnotation(RequestMapping.class).path())) { try { method.invoke(BookController.getInstance(), paramMap); return; } catch (IllegalAccessException | InvocationTargetException e) { e.printStackTrace(); } } } HtmlMarker.getInstance().makeTemplate("error", emptyMap()); } 

2. मॉडल

एक मॉडल के रूप में हमारे पास एक क्लास बुक होगी

 public class DomainBook { private String id; private String author; private String title; public DomainBook(String id, String author, String title) { this.id = id; this.author = author; this.title = title; } public String getId() { return id; } public String getAuthor() { return author; } public String getTitle() { return title; } @Override public String toString() { return "id=" + id + " author='" + author + '\'' + " title='" + title + '\''; } } 

और सेवा

 public class DefaultBookService implements BookService { private static volatile BookService bookService; private List<DomainBook> bookList = new ArrayList<>(); private DefaultBookService() { } public static BookService getInstance() { if (bookService == null) { synchronized (DefaultBookService.class) { if (bookService == null) { bookService = new DefaultBookService(); } } } return bookService; } @Override public List<DomainBook> getCollection() { System.out.println("get collection " + bookList); return bookList; } @Override public void addBook(Map<String, String> paramMap) { final DomainBook domainBook = new DomainBook(paramMap.get("id"), paramMap.get("author"), paramMap.get("title")); bookList.add(domainBook); System.out.println("add book " + domainBook); } @Override public void deleteBookById(long id) { //todo #1 } } 

जो पुस्तकों का एक संग्रह एकत्र करेगा, और सेवा से प्राप्त मॉडल (कुछ मानचित्र) डेटा में डाल देगा।

3. दृश्य

एक दृश्य के रूप में, हम एक HTML टेम्पलेट बनाएंगे, और इसे एक अलग संसाधनों / पृष्ठों की निर्देशिका में रखेंगे, जिससे प्रस्तुति का स्तर आगे बढ़ेगा।

 <html> <head> <title>Example</title> </head> <br> <table> <td>${book.id}</td><td>${book.author}</td><td>${book.title}</td> </table> </br> </br> </br> <form method="get" action="/add"> <p>Number<input type="text" name="id"></p> <p>Author<input type="text" name="author"></p> <p>Title<input type="text" name="title"></p> <p><input type="submit" value="Send"></p> </form> </body> </html> 

हम अपना स्वयं का टेम्पलेट इंजन लिखते हैं, वर्ग को सेवा से प्राप्त प्रतिक्रिया का मूल्यांकन करने में सक्षम होना चाहिए, और आवश्यक http हैडर उत्पन्न करना चाहिए (हमारे मामले में, OK या BAD REQUEST), HTML दस्तावेज़ में आवश्यक चर को मॉडल से मानों के साथ बदलें, और अंत में पूर्ण एचटीएमएल प्रस्तुत करें जिसे ब्राउज़र और उपयोगकर्ता समझ सकते हैं।

 public class HtmlMarker { private static volatile HtmlMarker htmlMarker; private HtmlMarker() { } public static HtmlMarker getInstance() { if (htmlMarker == null) { synchronized (HtmlMarker.class) { if (htmlMarker == null) { htmlMarker = new HtmlMarker(); } } } return htmlMarker; } public void makeTemplate(final String fileName, Map<String, List<DomainBook>> param) { try { final BufferedWriter bufferedWriter = new BufferedWriter( new OutputStreamWriter( new BufferedOutputStream(HttpRequestSocket.getInstance().getOutputStream()), StandardCharsets.UTF_8)); if (fileName.equals("error")) { bufferedWriter.write(ERROR + ERROR_MESSAGE.length() + OUTPUT_END_OF_HEADERS + readFile(fileName, param)); bufferedWriter.flush(); } else { bufferedWriter.write(SUCCESS + readFile(fileName, param).length() + OUTPUT_END_OF_HEADERS + readFile(fileName, param)); bufferedWriter.flush(); } } catch (IOException e) { e.printStackTrace(); } } private String readFile(final String fileName, Map<String, List<DomainBook>> param) { final StringBuilder builder = new StringBuilder(); final String path = "src\\resources\\pages\\" + fileName + ".html"; try (BufferedReader br = Files.newBufferedReader(Paths.get(path))) { String line; while ((line = br.readLine()) != null) { if (line.contains("${")) { final String key = line.substring(line.indexOf("{") + 1, line.indexOf("}")); final String keyPrefix = key.split(Pattern.quote("."))[0]; for (final DomainBook domainBook : param.get(keyPrefix)) { builder.append("<tr>"); builder.append( line.replace("${book.id}", domainBook.getId()) .replace("${book.author}", domainBook.getAuthor()) .replace("${book.title}", domainBook.getTitle()) ).append("</tr>"); } if(param.get(keyPrefix).isEmpty()){ builder.append(line.replace("${book.id}</td><td>${book.author}</td><td>${book.title}", "<p>library is EMPTY</p>")); } continue; } builder.append(line).append("\n"); } return builder.toString(); } catch (IOException e) { e.printStackTrace(); } return ""; } } 

प्रदर्शन के लिए आवेदन के परीक्षण के रूप में, हम अपने आवेदन में कुछ पुस्तकों को जोड़ते हैं:



अंत तक पढ़ने के लिए धन्यवाद, लेख केवल मार्गदर्शन के लिए है, मुझे उम्मीद है कि यह थोड़ा दिलचस्प और थोड़ा उपयोगी था।