Créer une application Web avec Javalin

J'ai essayé un framework appelé Javalin, donc je vais le poster.

Ce framework contient peu d'informations telles que les livres de référence et les sites japonais, mais Docs et Tutorial sont très faciles à comprendre, en particulier dans Tutorial, des exemples de programmes sont publiés sur GitHUB, alors importez-les tels qu'ils sont dans Intellij. Vous pouvez le personnaliser, vous n'aurez donc pas beaucoup de mal à créer une application WEB.

environnement

1. Hello World

Créez simplement un nouveau projet Gradle et implémentez: Si Java est installé, Web Server démarre également. Vous n'avez même pas besoin de Tomcat.

HelloWorld.java

import io.javalin.Javalin;

public class HelloWorld {
    public static void main(String[] args) {
        Javalin app = Javalin.create().start(7000);
        app.get("/", ctx -> ctx.result("Hello World"));
    }
}

2. Tutorial(Basic website structure)

En pratique, une bonne approche serait de télécharger et de personnaliser l'exemple de programme Tutorial. Téléchargez la "Structure de site Web de base" tipsy / javalin-website-example et ouvrez-la dans Intellij.

project.tree

└─src
    └─main
        ├─java
        │  └─app
        │      │  Main.java
        │      ├─book
        │      │      Book.java
        │      │      BookController.java
        │      │      BookDao.java
        │      ├─index
        │      │      IndexController.java
        │      ├─login
        │      │      LoginController.java
        │      ├─user
        │      │      User.java
        │      │      UserController.java
        │      │      UserDao.java
        │      └─util
        │              Filters.java
        │              HerokuUtil.java
        │              MessageBundle.java
        │              Path.java
        │              RequestUtil.java
        │              ViewUtil.java
        └─resources
            ├─localization
            │      messages_de.properties
            │      messages_en.properties
            ├─public
            │  │  main.css
            │  └─img
            │          english.png
            │          favicon.png
            │          german.png
            │          logo.png
            ├─velocity
            │  │  layout.vm
            │  │  notFound.vm
            │  ├─book
            │  │      all.vm
            │  │      one.vm
            │  ├─index
            │  │      index.vm
            │  └─login
            │          login.vm
            └─velocityconfig
                    velocity_implicit.vm

Si vous exécutez Main, il fonctionnera tel quel. Tout ce que vous avez à faire est de convertir une classe telle que DAO en base de données pour créer un modèle de projet.

3. Thymeleaf

Le moteur de modèle du projet que vous venez d'importer est "vélocité". Si vous souhaitez utiliser Thymeleaf, vous devez le changer. Il semble que "javalin" supporte également thymeleaf par défaut, mais il ne semble pas prendre en charge le dialecte, donc personnalisons-le.

La racine de html est "/ public / templates". Créez un fichier avec la configuration suivante. Dans layout.html, utilisez layout-dialect pour standardiser la mise en page html.

└─src
    ├─main
    │  ├─java
    │  │  └─app
    │  │          AppThymeleafRenderer.java
    │  │          Main.java
    │  └─resources
    │      ├─public
    │      │  └─css
    │      │         main.css
    │      └─templates
    │          │  layout.html
    │          └─example
    │                  index.html

(1) Ajoutez ce qui suit à gradle.gradle.

• Le projet est réimprimé avec gradle

    compile group: 'org.thymeleaf', name: 'thymeleaf', version: '3.0.11.RELEASE'
    compile group: 'nz.net.ultraq.thymeleaf', name: 'thymeleaf-layout-dialect', version: '2.4.1'
    compile "org.webjars:jquery:3.4.1"

(2) ThymeleafRenderer

Thymeleaf doit créer son propre moteur de rendu lors de la personnalisation, par exemple lors de l'utilisation de "layout-dialect".

AppThymeleafRenderer.java

import io.javalin.http.Context;
import io.javalin.plugin.rendering.FileRenderer;
import nz.net.ultraq.thymeleaf.LayoutDialect;
import org.jetbrains.annotations.NotNull;
import org.thymeleaf.TemplateEngine;
import org.thymeleaf.context.WebContext;
import org.thymeleaf.templateresolver.ClassLoaderTemplateResolver;
import org.thymeleaf.templateresolver.ITemplateResolver;

import java.util.Map;

public class AppThymeleafRenderer implements FileRenderer {

    private final TemplateEngine templateEngine;

    public AppThymeleafRenderer() {
        templateEngine = templateEngine();
    }

    @Override
    public String render(@NotNull String filePath, @NotNull Map<String, Object> model, @NotNull Context ctx) {
        WebContext context =
                new WebContext(ctx.req, ctx.res, ctx.req.getServletContext(), ctx.req.getLocale());
        context.setVariables(model);
        return templateEngine.process(filePath, context);
    }

    private TemplateEngine templateEngine() {
        TemplateEngine templateEngine = new TemplateEngine();
        templateEngine.setTemplateResolver(templateResolver());
        //Ajoutez LayoutDialect.
        templateEngine.addDialect(new LayoutDialect());
        return templateEngine;
    }

    private ITemplateResolver templateResolver() {
        ClassLoaderTemplateResolver templateResolver = new ClassLoaderTemplateResolver();
        // /Racine le dossier des modèles.
        templateResolver.setPrefix("/templates/");
        return templateResolver;
    }

}

(3) Ajouté à Main.java

Dans la méthode Main, ajoutez la classe «AppThymeleafRenderer» créée précédemment à «JavalinRenderer». De plus, lorsque vous retournez du code HTML avec Router, utilisez "ctx.render".

Main.java

public class Main {
    public static void main(String[] args) {

//add
        JavalinRenderer.register(new AppThymeleafRenderer(), ".html");
//add end
        Javalin app = Javalin.create(config->{
            config.enableWebjars();
            config.addStaticFiles("/public");
        }).start(7000);
//add
        app.get("/template", ctx -> {
            Map<String, Object> model = new HashMap<>();
            model.put("hello", "hello world");
            ctx.render("/example/index.html", model);
        });
//add end

(4) layout.html

layout.html

<!DOCTYPE html>
<html lang="ja" xmlns="http://www.w3.org/1999/xhtml"
      xmlns:th="http://www.thymeleaf.org"
      xmlns:layout="http://www.ultraq.net.nz/thymeleaf/layout">
<head>
    <meta charset="UTF-8">
    <title>Spring Boot Sample Site</title>
    <meta name="description" content="common-meta">
    <script th:src="@{/webjars/jquery/3.4.1/jquery.min.js}"></script>
    <link rel="stylesheet" href="css/main.css">
</head>
<body>
<div class="container">
    <div class="inner">
        <div class="body header">
            <div class="apptitle">Example</div>
        </div>
        <div class="body main">
            <div layout:fragment="contents"></div>
        </div>
        <div class="body footer">
            <footer style="text-align:center;">Pied de page commun</footer>
        </div>
    </div>
</div>
</body>
</html>

index.html

<!DOCTYPE html>
<html
        xmlns:th="http://www.thymeleaf.org"
        xmlns:layout="http://www.ultraq.net.nz/thymeleaf/layout"
        layout:decorate="~{/layout.html}">
<head></head>
<body>
<div layout:fragment="contents">
    <div th:text="${hello}">hello</div>
</div>
</body>
</html>

Lorsque j'accède à [http: // localhost: 7000 / template](http: // localhost: 7000 / template), la mise en page est également sortie correctement.

4. Database

Après de nombreux problèmes, j'ai décidé d'utiliser "Apache commons-dbutils". La raison est simplement facile à comprendre. Utilisez "HikariCP" pour le pool de connexions et "postgresql" pour la base de données.

build.gradle

    compile "com.zaxxer:HikariCP:2.7.3"
    compile "org.postgresql:postgresql:42.2.8"
    compile "commons-dbutils:commons-dbutils:1.7"

PGDataSource.java

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import javax.sql.DataSource;

public class PGDataSource {
    private static HikariDataSource ds = null;
    public PGDataSource(){
        HikariConfig hikariconfig = new HikariConfig();
        hikariconfig.setUsername("testuser");
        hikariconfig.setPassword("************************");
        hikariconfig.setJdbcUrl("jdbc:postgresql://localhost:5432/javalindb");
        hikariconfig.setMaximumPoolSize(2);
        ds=new HikariDataSource(hikariconfig);
    }
    public DataSource getDataSource(){
        return ds;
    }
    public void close(){
        if (!ds.isClosed()) ds.close();
    }

}

User.java

import lombok.Data;

@Data
public class User {
    private String username;
    private String password;
    public User(){};
    public User(String username, String password){
        this.username=username;
        this.password=password;
    };
}

Main.java

public class Main {

//add
    private static PGDataSource ds;
    public static Connection getConnection() throws SQLException {
        Connection connection = ds.getDataSource().getConnection();
        return connection;
    }
//add end
    public static void main(String[] args) {
        JavalinRenderer.register(new AppThymeleafRenderer(), ".html");
//add
        ds = new PGDataSource();
//add end
//・ ・ ・ ・ ・ ・ ・
//add
        app.get("/user", ctx -> {
            QueryRunner runner = new QueryRunner();
            ResultSetHandler rsh = new BeanListHandler(User.class);
            List<User> users = (List<User>) runner.query(getConnection(),
                    "select username from public.users",rsh);
            ctx.json(users);
        });
//add end

Une fois que vous savez cela, vous pouvez créer une application WEB en consultant la documentation et le didacticiel.

5. Site de référence

Notes lors de l'examen Javalin Journal de nodchip - Apache Commons DbUtils