Neste pequeno artigo tentarei explicar por que criei esta biblioteca? e como é implementado?

por que criei esta biblioteca?

Trabalhei com o framework Java EE em muitos projetos e na maioria deles não havia limitação de recursos disponíveis para executar a aplicação, mas em alguns casos raros tínhamos recursos limitados, especialmente a memória para implantar a aplicação em um serviço de implantação , portanto, quando o aplicativo exceder o limite, o serviço de implantação tornará o aplicativo mais lento primeiro e, se continuar, o serviço o encerrará. Estávamos usando o framework Spring legado sem nem mesmo o Spring Boot, tentamos usar uma biblioteca diferente, mas a diferença era mínima e inútil, e foi aí que começou a ideia de criar uma alternativa Spring leve com foco na redução ao máximo do consumo de memória. .

havia apenas dois objetivos em minha mente quando comecei a projetar a biblioteca:
1 - reduzindo ao máximo o consumo de memória
2 - tente usar a API Java EE existente tanto quanto possível para facilitar a transição para a biblioteca do ponto de vista do aprendizado e da complexidade da transição em si.
e com esses 2 objetivos consegui reduzir o consumo de memória de uma de minhas aplicações em cerca de 40% e tornar a transição fácil e rápida, pois é semelhante às soluções existentes.

Como criei esta biblioteca?

Aqui está o repositório GitHub para que você possa verificar o código durante a leitura.

A biblioteca como um todo possui muitas partes (captura de tela abaixo), a maior parte da implementação no módulo principal que também é dividido em três tipos de módulos independentes: Core, JPA, Web. Os módulos App são principalmente para integração, o módulo Plugin é um plugin maven para ajudar a criar os arquivos necessários dentro do arquivo do pacote para que a biblioteca funcione corretamente

Módulo Principal

Portanto, começaremos com o módulo principal que, como o nome sugere, contém a funcionalidade principal da biblioteca que é a injeção de dependência ou a inversão de controle.
Para alcançar esta funcionalidade, primeiro comece examinando o caminho de classe do aplicativo durante a fase de compilação para todas as classes anotadas que a biblioteca deve gerenciar para criar definições de componentes para classes anotadas.

A definição do componente contém basicamente todas as informações que precisaremos para instanciar um objeto desta classe posteriormente, como as informações do construtor, se houver alguns setters com anotação inject (apenas injeção de construtor e setter são suportados) se a classe tiver alguma interface ou estender alguma outra classe, teremos todas as informações necessárias para criar um objeto a partir desta classe (captura de tela abaixo).
E então, depois de verificarmos todas as anotações do caminho de classe e criarmos todas as definições de componentes necessárias, iremos armazená-las no caminho de classe como arquivo JSON.

A segunda e principal funcionalidade do módulo principal é a injeção de dependência e inversão de controle que se baseia no padrão de design de fábrica, então temos a interface ApplicationContext que por si só estende o ComponentFactory interface e o método principal desta interface é o método getComponent que retornará o objeto do nome do componente.

Como você pode ver na imagem acima, primeiro tentamos verificar se o componente existe nos componentes Singleton já inicializados, se não, começamos obtendo a definição do componente do arquivo JSON e iniciamos o loop while para obtenha todas as dependências do componente antes de passar a definição do componente e suas dependências para o montador do componente para obter um objeto completo pronto para ser injetado.

Módulo JPA

A implementação do módulo JPA é muito semelhante ao Spring Data JPA, mas muito mínima, o motivo é muito semelhante porque usei Spring Data em muitos projetos e achei fácil de usar e como disse antes, queria a transição para o biblioteca para ser suave e exigir menos trabalho, tanto quanto possível, então implementar minha própria versão de dados de mini primavera foi a melhor escolha.

A implementação é em torno da interface JpaRepository que contém as operações mais comuns para banco de dados como salvar, excluir e localizar tudo... e para usar o módulo JPA você precisa estender esta interface e fornecer a entidade que esta interface deve gerenciar e é id, depois de estender a interface e anotar com a anotação Repository você pode definir seus métodos e anotá-los com a anotação Query e fornecer a consulta JPQL, e então a biblioteca na fase de compilação criará uma classe totalmente funcional que implementa esta interface.

A biblioteca também gerenciará a parte transacional do aplicativo, portanto, toda a interface do repositório e qualquer classe anotada com transacional serão gerenciadas pela biblioteca do ponto de vista da transação. portanto, para qualquer componente transacional, a biblioteca criará um proxy para gerenciar a transação com base na anotação Transactional e também gerenciará o ciclo de vida do gerenciador de entidade.

Módulo web

O modelo web é responsável por gerenciar toda a web part da aplicação e por design é um módulo independente, o que significa que pode ser usado independentemente do resto dos módulos da biblioteca, como de costume é muito semelhante em uso a alguns biblioteca Java EE familiar, como Spring web ou Jax-rs.

A implementação é baseada em anotação, você tem classes anotadas com a anotação Controller e dentro deste controlador você encontrará o método anotado com o PathMapping e esses métodos irão lidar com caminho específico ou específico solicitação com base em alguns critérios como o tipo de solicitação, o tipo de conteúdo...

Por fora será muito parecido com a outra biblioteca, mas por dentro é diferente porque a biblioteca mudará essas classes Controller em tempo de execução para fazer com que todas elas estendam o BaseHttpServlet , que também estende o HttpServlet e funcionará como um servlet normal.

Como você pode ver na imagem acima, primeiro inicializamos o componente no método init para injetar toda a dependência usando o WebApplicationContext, e então trataremos de toda a solicitação chegando a este controlador usando o método handleRequest, com esta abordagem usaremos a API do servlet existente para gerenciar os controladores, isso ajudará a manter o consumo de memória baixo e também reduzir a sobrecarga, já que a biblioteca funciona como um plugin para complementar o trabalho da API do servlet.

Primeiro, tentamos mapear a solicitação para o método correto e depois disso, tentamos injetar todas as informações solicitadas dentro do método, obtendo as informações do contexto ou do HttpServletRequest como a solicitação parâmetro ou cabeçalhos ou variável de caminho ou o corpo da solicitação...

Nós convertemos todas essas informações e então as injetamos como um parâmetro para o método quando ele é solicitado e então executamos o método e convertemos o resultado ou o resultado com base em PathMapping produz ou tipo de conteúdo (por o padrão é application/Json) e então escrevemos o conteúdo em HttpServletResponse.

Por último, se algo der errado no processo e um erro for lançado, pegamos esse erro ou a exceção e tentamos tratá-lo com base no tipo de exceção, temos um manipulador de exceção para lidar com diferentes tipos de exceção e o o usuário também pode fornecer mais manipuladores para lidar com qualquer exceção da maneira que desejar.

Plug-in Maven

A última e importante parte é o plugin maven que irá criar todos os arquivos necessários para que a aplicação funcione corretamente e também para construir o pacote jar ou war.
Primeiro o plugin irá verificar o caminho da classe e as dependências para pesquisar os arquivos component-definitions-json, a partir desses arquivos ele irá gerar:
lazy-application.json: contém todos os componentes e suas dependências para a aplicação

lazy-application.properties: contém a lista de controladores e entidades para que não precisemos verificar o caminho da classe em tempo de execução.
e por último se a embalagem for jar teremos a classe principal.

e por último construímos o arquivo do pacote que conterá o código do aplicativo com suas dependências e os arquivos que geramos na etapa anterior.

Tentei não me aprofundar em detalhes para manter os artigos curtos e não tão complicados de entender, claro que o código está disponível no GitHub para que você possa brincar com ele também. para respondê-las.