rife2

Bem-vindo

O RIFE2 é uma estrutura de pilha completa, sem declarações, para criar aplicativos da Web com rapidez e sem esforço com o Java moderno.

O RIFE2 é construído sobre as fundações da estrutura original da RIFE, popular de 2002-2010. Desde então, o mundo e o Java mudaram e muitas das APIs originais de Rife poderiam finalmente ser substituídas por java puro, no-xml, sem yaml, deixando apenas o código expressivo de tipo.

O Rife2 preserva a maioria dos recursos originais e adiciona novos, para uma fração da pegada e com uma produtividade ainda maior do desenvolvedor do que antes. O RIFE2 é criado por Geert Bevin, um dos primeiros campeões de Java e palestrante em muitas conferências de Java.

Dica: se você usar a Intellij Idea como seu IDE, considere instalar o plug-in da Idea Rife2.
Isso aumentará muito sua experiência de codificação.

Este é um tutorial rápido, a documentação completa contém muito mais informações.

Os Javadocs Rife2 complementam a documentação com muitos outros detalhes.

Por que rife2?

Uma pergunta frequente é: "Por que escolher o Rife2 em vez de outras estruturas populares"?

A resposta curta é que o Rife2 é diferente , foi projetado para criar aplicativos da Web rapidamente com pequenas equipes. Ele desafiou e sempre desafiará o status-quo. Não é para substituir estruturas de nível corporativo como Spring ou JEE, embora eu o tenha usado para aplicativos corporativos. O RIFE2 aproveita o poder da plataforma Java para aplicativos da Web que você normalmente escreveria com linguagens de script. A produtividade e a manutenção são fundamentais e você descobrirá que você recebe 90% do trabalho realizado por 10% do esforço e ainda pode se integrar a outras bibliotecas e estruturas Java onde você precisa.

O RIFE2 tem características que, após 20 anos, ainda não podem ser encontradas em outros lugares:
Continuações da Web, mecanismo de modelo bidirecional, sistema de metadados centrado em feijão, pilha completa sem dependências, construtores de SQL acionados por metadados, estrutura de gerenciamento de conteúdo, suporte completo de localização, abstração de recursos, agendamento de cron persistido, mecanismo de fluxo de trabalho baseado em contínuas.

A maioria desses recursos resistiu ao teste do tempo e, após 20 anos, ainda prova ser ótimas opções para o desenvolvimento de aplicativos da web. O Rife2 aprendeu com décadas de experiência e melhora esses recursos originais de várias maneiras.

O Rife2 também possui recursos que foram adotados por outros, mas que geralmente não têm a conveniência da integração rígida em uma pilha completa.

Por exemplo: os testes fora de containers podem analisar a estrutura dos modelos resultantes sem ter que analisar HTML, o sistema de autenticação é construído a partir de todas as outras peças da pilha completa e se integra perfeitamente ao seu aplicativo da Web, os URLs são gerados, a partir da configuração que você criou, sem o risco de se tornar o SALE, os modos de lógica são realmente puramente HTML, SVG, SQL), ... e muito mais.

Rife2 é a pílula vermelha , pronta para mostrar a profundidade da toca do coelho, se você estiver pronto para isso!

Investir rápido

Olá, exemplo do mundo

É assim que você começa com um site Hello World .

 public class HelloWorld extends Site {
    public void setup () {
        get ( "/hello" , c -> c . print ( "Hello World" ));
    }

    public static void main ( String [] args ) {
        new Server (). start ( new HelloWorld ());
    }
}

O método main gira o servidor Jetty incorporado integrado, para que você possa começar imediatamente a codificar. A mesma classe HelloWorld pode ser adicionada como um valor de parâmetro ao seu web.xml , exigindo alterações absolutas sem alterações entre o desenvolvimento e a produção.

O teste fora de contagem é um cidadão de primeira classe no RIFE2, interagindo diretamente com a classe Site para simular interações completas de solicitação-resposta, sem precisar aumentar um contêiner de servlet.

É assim que você pode testar o exemplo acima com o Junit 5:

 class HelloTest {
    @ Test void verifyHelloWorld () {
        var m = new MockConversation ( new HelloWorld ());
        assertEquals ( "Hello World" , m . doRequest ( "/hello" ). getText ());
    }
}

Links e URLs seguros de tipo

Um dos aspectos mais quebradiços do desenvolvimento de aplicativos da Web é digitar links e URLs como literais de texto, sem nada garantir que eles permaneçam corretos quando suas rotas mudam ou quando você implanta seu aplicativo em diferentes contextos de aplicativos da Web. A API de roteamento do RIFE2 permite que todos os links de aplicativos sejam gerados corretamente sem nenhum esforço em seu nome.

Vamos adicionar uma nova rota que contém um link HTML para a rota Hello World anterior.

Você pode ver que as rotas não precisam ser criadas dentro do método setup() , mas também podem ser criadas como parte da construção do seu Site , permitindo que as rotas sejam armazenadas nos campos.

 public class HelloLink extends Site {
    Route hello = get ( "/hello" , c -> c . print ( "Hello World" ));
    Route link = get ( "/link" , c -> c . print ( "<a href='" + c . urlFor ( hello ) + "'>Hello</a>" ));

    public static void main ( String [] args ) {
        new Server (). start ( new HelloLink ());
    }
}

Agora podemos testar isso como tal:

 class HelloTest {
    @ Test void verifyHelloLink () {
        var m = new MockConversation ( new HelloLink ());
        assertEquals ( "Hello World" , m . doRequest ( "/link" )
            . getParsedHtml (). getLinkWithText ( "Hello" )
            . follow (). getText ());
    }
}

Modelos sem lógica bidirecional

O principal impulso que me fez criar rife2 foi o mecanismo de modelo exclusivo da RIFE.

Os modelos da RIFE2 contêm dois conceitos principais:

• valores - que podem ser preenchidos com conteúdo e dados
• Blocos - que serão retirados e que fornecem trechos de conteúdo

Seu código Java comporá o layout final atribuindo e anexando blocos e colocando dados em valores. Vamos reescrever o exemplo HelloLink acima com um modelo.

Neste exemplo, ainda não há manipulação de modelo em Java.

Em vez disso, ele apresenta a tag {{v route:hello/}} , que será automaticamente substituída pelo URL da rota disponível com esse nome de campo no seu Site ativo.

 public class HelloTemplate extends Site {
    Route hello = get ( "/hello" , c -> c . print ( "Hello World" ));
    Route link = get ( "/link" , c -> c . print ( c . template ( "HelloTemplate" )));

    public static void main ( String [] args ) {
        new Server (). start ( new HelloTemplate ());
    }
}

Com HelloTemplate.html sendo:

 <!DOCTYPE html >
< html lang =" en " >
< body >
< a href =" {{v route:hello/}} " > Hello </ a >
</ body >
</ html >

Observe que o RIFE2 transforma internamente seus modelos em classes Java, gerando bytecode otimizado.

Isso acontece na voação durante o desenvolvimento. Para a produção, os modelos podem ser pré-compilados, tornando-os incrivelmente rápidos.

Manipulação de modelos

Vamos alterar o exemplo um pouco mais e criar uma única rota que possa responder às solicitações get e post .

• A solicitação get exibirá um formulário com um único botão para clicar.
• A solicitação post receberá o envio do formulário e exibirá Hello World .

 public class HelloForm extends Site {
    Route hello = route ( "/hello" , c -> {
        var t = c . template ( "HelloForm" );
        switch ( c . method ()) {
            case GET -> t . setBlock ( "content" , "form" );
            case POST -> t . setBlock ( "content" , "text" );
        }
        c . print ( t );
    });

    public static void main ( String [] args ) {
        new Server (). start ( new HelloForm ());
    }
}

Com HelloForm.html sendo:

 <!DOCTYPE html >
< html lang =" en " >
< body >
<!--v content/-->
<!--b form-->
< form action =" {{v route:action:hello/}} " method =" post " name =" hello " >
  <!--v route:inputs:hello/-->
  < input type =" submit " name =" Submit " >
</ form >
<!--/b-->
<!--b text--> < p id =" greeting " > Hello World </ p > <!--/b-->
</ body >
</ html >

Nota: que a tag route: Value do acima foi dividida na route:action: e route:inputs: gerando entrada de formulário HTML oculto para parâmetros em vez de parâmetros de sequência de consulta.

Você pode ver que o modelo contém todas as peças para criar as duas páginas:

• o valor chamado content
• o bloco nomeado form
• o bloco chamado text

Em Java, simplesmente atribuímos um bloco ao valor, dependendo do que queremos exibir.

Outro benefício é que as tags de modelo do Rife2 podem ser comentários em HTML, tornando -os completamente invisíveis. Isso permite que você trabalhe no seu design HTML como de costume e visualize o arquivo de modelo com um navegador comum.

Finalmente, vamos incluir um teste para esta funcionalidade:

 class HelloTest {
    @ Test void verifyHelloForm () {
        var m = new MockConversation ( new HelloForm ());
        var r = m . doRequest ( "/hello" ). getParsedHtml ()
            . getFormWithName ( "hello" ). submit ();
        assertEquals ( "Hello World" , r . getParsedHtml ()
            . getDocument (). body ()
            . getElementById ( "greeting" ). text ());
    }
}

Apenas o topo da toca do coelho

Obrigado pela leitura até o fim!

Esta foi apenas uma introdução rápida para o seu apetite, o Rife2 vem com um manual abrangente e fácil de ler, com muitos exemplos e explicações pragmáticas.

Se você tiver alguma dúvida, sugestão, idéias ou apenas quiser conversar, sinta -se à vontade para postar nos fóruns ou se juntar a nós no Discord.

Leia mais na documentação completa e rife2 javadocs.