Erstellen Sie eine Webanwendung mit Javalin

Ich habe ein Framework namens Javalin ausprobiert, daher werde ich es veröffentlichen.

Dieses Framework enthält nur wenige Informationen wie Nachschlagewerke und japanische Websites. Dokumente und Lernprogramme sind jedoch sehr einfach zu verstehen, insbesondere in Lernprogrammen werden Beispielprogramme auf GitHUB veröffentlicht. Importieren Sie sie daher so, wie sie in Intellij sind. Sie können es anpassen, sodass Sie keine großen Probleme beim Erstellen einer WEB-Anwendung haben.

Umgebung

1. Hello World

Erstellen Sie einfach ein neues Gradle-Projekt und implementieren Sie: Wenn Java installiert ist, wird auch der Webserver gestartet. Du brauchst nicht einmal 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)

In der Praxis wäre es ein guter Ansatz, das Tutorial-Beispielprogramm herunterzuladen und anzupassen. Laden Sie die "Grundlegende Website-Struktur" tipsy / javalin-website-example herunter und öffnen Sie sie in 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

Wenn Sie Main ausführen, funktioniert es so wie es ist. Sie müssen lediglich eine Klasse wie DAO in eine Datenbank konvertieren, um eine Projektvorlage zu erstellen.

3. Thymeleaf

Die Vorlagen-Engine des gerade importierten Projekts ist "Geschwindigkeit". Wenn Sie Thymeleaf verwenden möchten, müssen Sie es ändern. "Javalin" scheint standardmäßig Thymeleaf zu unterstützen, aber es scheint keinen Dialekt zu unterstützen, also lasst es uns anpassen.

Das Stammverzeichnis von HTML ist "/ public / templates". Erstellen Sie eine Datei mit der folgenden Konfiguration. Verwenden Sie in layout.html den Layout-Dialekt, um das HTML-Layout zu standardisieren.

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

(1) Fügen Sie gradle.gradle Folgendes hinzu.

• Projekt wird mit gradle nachgedruckt

    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 muss beim Anpassen einen eigenen Renderer erstellen, z. B. bei Verwendung des "Layout-Dialekts".

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());
        //Fügen Sie LayoutDialect hinzu.
        templateEngine.addDialect(new LayoutDialect());
        return templateEngine;
    }

    private ITemplateResolver templateResolver() {
        ClassLoaderTemplateResolver templateResolver = new ClassLoaderTemplateResolver();
        // /Rooten Sie den Vorlagenordner.
        templateResolver.setPrefix("/templates/");
        return templateResolver;
    }

}

(3) Zu Main.java hinzugefügt

Fügen Sie in der Main-Methode die zuvor erstellte Klasse "AppThymeleafRenderer" zu "JavalinRenderer" hinzu. Wenn Sie HTML mit Router zurückgeben, verwenden Sie außerdem "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;">Gemeinsame Fußzeile</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>

Wenn ich auf [http: // localhost: 7000 / template](http: // localhost: 7000 / template) zugreife, wird das Layout ebenfalls korrekt ausgegeben.

4. Database

Nach vielen Schwierigkeiten entschied ich mich für "Apache commons-dbutils". Der Grund ist einfach leicht zu verstehen. Verwenden Sie "HikariCP" für den Verbindungspool und "postgresql" für die Datenbank.

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

Sobald Sie dies wissen, können Sie eine WEB-Anwendung erstellen, indem Sie sich Docs and Tutorial ansehen.

5. Referenzseite

Hinweise bei der Untersuchung von Javalin Nodchips Tagebuch-Apache Commons DbUtils