Aplicativo Web MVC sem estruturas e servlets

Escreveremos um pequeno aplicativo da Web, sem o uso de estruturas da Web, bibliotecas externas e um servidor de aplicativos.

O objetivo deste artigo é mostrar a essência geral do que está acontecendo nos bastidores de um serviço da Web, usando Java como exemplo. Então vamos lá. Não devemos usar bibliotecas de terceiros, nem um servlet. Portanto, o projeto será montado pelo Maven, mas sem dependências.

O que acontece quando um usuário digita um determinado endereço IP (ou DNS que se transforma em um endereço IP) na barra de endereços do navegador? É feita uma solicitação ao ServerSocket do host especificado, na porta especificada.

Organizamos em nosso host local, soquete em uma porta livre aleatória (por exemplo, 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; } } 

Não esqueça que o ouvinte na porta, como um objeto, é desejável para nós em uma única cópia, portanto singleton (não necessariamente verifique duas vezes, mas pode ser).

Agora, em nosso host-e (localhost) na porta 9001, existe um ouvinte que recebe o que o usuário digita como um fluxo de bytes.

Se você subtrair o byte [] do soquete no DataInputStream e convertê-lo em uma string, obterá algo como isto:

 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 

Solicitação HTTP padrão com todos os cabeçalhos necessários.

Para a análise, criaremos uma pequena interface utilitária com métodos padrão. Na minha opinião, é bastante conveniente para esses fins (além disso, se ainda for o Spring, reduzimos o número de dependências na classe).

 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<>(); } } } 

Este utilitário pode analisar o tipo de solicitação, a URL e uma lista de parâmetros para as solicitações GET e POST.

No processo de análise, formamos o modelo de solicitação, com o URL de destino e o Mapa com os parâmetros de solicitação.

O controlador para o nosso serviço é uma pequena abstração da biblioteca na qual podemos adicionar livros (nesta implementação, apenas à Lista), excluir livros e retornar uma lista de todos os livros.

1. Controlador

 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); } } 

Também temos um controlador singleton.

Registramos o RequestMapping. Pare, fazemos isso sem uma estrutura, o que RequestMapping? Teremos que escrever esta anotação nós mesmos.

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

Também foi possível adicionar a anotação do Controlador sobre a classe e, na inicialização do aplicativo, coletar todas as classes marcadas com esta anotação e seus métodos e adicioná-las a um determinado Mapa com URL de mapeamento. Mas na implementação atual, nos limitaremos a um controlador.

Antes do controlador, teremos um certo pré-processador, que formará o modelo de solicitação compreensível para o programa e mapeará para os métodos do controlador.

 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. Modelo

Como modelo, teremos um livro de classe

 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 + '\''; } } 

e serviço

 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 } } 

que coletará uma coleção de livros e inserirá os dados do Modelo (alguns Mapas) recebidos do serviço.

3. Ver

Como uma visualização, criaremos um modelo html e o colocaremos em um diretório separado de recursos / páginas, aumentando o nível da apresentação.

 <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> 

Escrevemos nosso próprio mecanismo de modelo, a classe deve poder avaliar a resposta recebida do serviço e gerar o cabeçalho http necessário (no nosso caso, OK ou BAD REQUEST), substituir as variáveis ​​necessárias no documento HTML pelos valores do modelo e finalmente renderizar o HTML completo que o navegador e o usuário podem entender.

 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 ""; } } 

Como teste do aplicativo para desempenho, adicionamos alguns livros ao nosso aplicativo:



Obrigado por ler até o final, o artigo é apenas para orientação, espero que tenha sido um pouco interessante e um pouco útil.