[Java] Stellen Sie eine mit Eclipse + Maven + Ontology mit Heroku erstellte Webanwendung bereit

Einführung

Fassen Sie den Prozess der Bereitstellung einer mit Eclipse + Maven + Ontology erstellten Webanwendung auf Heroku zusammen In Bezug auf den Einsatz von Heroku habe ich auf die folgende Site verwiesen

Vier Dinge, auf die Heroku-Anfänger bei der Bereitstellung von von Java erstellten Webanwendungen mit GitHub-Integration gestoßen sind

Bitte beachten Sie, dass diese Methode nur ein Beispiel ist.

Der Quellcode ist unten https://github.com/YasufumiNakama/heroku-java-practice

Inhalt

• Erstellen Sie eine Webanwendung mit Eclipse + Maven + Ontology
• In Heroku bereitstellen

Erstellen Sie eine Webanwendung mit Eclipse + Maven + Ontology

Erstellen eines Maven-Projekts

Ich werde die Installation von Eclipse usw. weglassen. Wählen Sie zuerst das Maven-Projekt aus Eclipse aus Geben Sie die Gruppen-ID und die Artefakt-ID ein Anschließend wird das Verzeichnis wie folgt konfiguriert. Schreiben Sie also den Code von hier aus

Vorbereitung der Ressourcen

Dieses Mal werde ich als Ressource eine Eulendatei verwenden, die die (Ramen-) Ontologie beschreibt (weil es eine gab, die bereits erstellt wurde und einfach und leicht war). Als einfaches Beispiel versuchen wir, eine Unterklasse der "Ramen" -Klasse abzurufen, indem wir eine Abfrage auslösen und in HTML ausgeben (es war wirklich interessant, etwas für die Benutzereingabe abzurufen). Da der Zweck jedoch darin besteht, es für Heroku bereitzustellen, werde ich es überspringen.

Vorbereitung von pom.xml

Da Ressourcen mithilfe der Ontologie ausgetauscht werden, werden Jena, Jersey und Gson zusätzlich zu dem für den Test verwendeten Junit als \ <Abhängigkeiten > verwendet.

• junit
• jena
• jersey
• gson

Außerdem wird \ offiziell erklärt, also von hier Verwenden Sie den Code so wie er ist Weitere Informationen finden Sie im Quellcode, da wir andere Änderungen vorgenommen haben.

Web.xml vorbereiten

Erstellen Sie src / main / webapp / WEB-INF / web.xml und legen Sie das Trikot fest Details entsprechen dem Quellcode

Java-Quellcode

Da ich die Gruppen-ID auf com.heroku-java-Practice gesetzt habe, schreibe ich den Java-Quellcode unter src / main / java / com / heroku_java_practice (Test unter src / test / java / heroku_java_practice) Zuerst habe ich ein Programm namens ramen.java geschrieben, das Unterklassen der Klasse "ramen" aus einer Eulendatei abfragt und abruft, die die (Ramen-) Ontologie als Ressourcen beschreibt.

ramen.java

package com.heroku_java_practice;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.*;

import com.hp.hpl.jena.rdf.model.*;
import com.hp.hpl.jena.util.*;
import com.hp.hpl.jena.query.*;

public class ramen {
	
	public static String path = new File(".").getAbsoluteFile().getParent();
	public static String Resources = path + "/src/main/resources/";

    public static HashSet<String> get_ramen() throws FileNotFoundException {
        //Eulendatei lesen
        Model model = FileManager.get().loadModel(Resources + "owl/ramen.owl");
        // query
        String queryString = "PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n" +
        		             "SELECT ?y\n" +
                			 "WHERE{\n" +
                             "?y rdfs:subClassOf <http://www.semanticweb.org/nakamayasufumi/ontologies/2019/5/untitled-ontology-30#Ramen>\n" +
                             "}";
        // result
        HashSet<String> result = new HashSet<>();
        //Laden von SPARQL-Abfragen
        Query query = QueryFactory.create(queryString);
        //Führen Sie die SPARQL-Abfrage aus
        QueryExecution qexec = QueryExecutionFactory.create(query, model);
        try {
            ResultSet results = qexec.execSelect();
            for (; results.hasNext(); ) {
                QuerySolution soln = results.nextSolution();
                Resource y = soln.getResource("y");
                result.add(y.toString().split("#")[y.toString().split("#").length-1]);
            }
        } finally {
            qexec.close();
        }
        return result;
    }
}

Lassen Sie uns nun mit einem Test prüfen, ob sich ramen.java wie erwartet verhält.

RamenTest.java

package heroku_java_practice;

import static org.junit.Assert.*;
import org.junit.Test;

import com.heroku_java_practice.*;

public class RamenTest {
	
	@Test
	public void test() {
		try {
			ramen status = new ramen();
			System.out.println(status.get_ramen());
		} catch(Exception e) {
			e.printStackTrace();
			fail(e.toString());
		}
	}
	
}

Wenn RamenTest.java im JUnit-Test ausgeführt wurde, war das Ausgabeergebnis wie folgt und es wurde bestätigt, dass es sich wie erwartet verhält. Zum Schluss schreiben wir main.java, um dieses Ausgabeergebnis im Web wiederzugeben. Trikot ist bequem

main.java

package com.heroku_java_practice;

import java.io.FileNotFoundException;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

@Path("webmethods")
public class main {

	@Path("/ramen")
	@GET
	@Produces(MediaType.APPLICATION_JSON)
	public String return_ramen() throws FileNotFoundException {
		ramen status = new ramen();
		Gson gson = new GsonBuilder().serializeNulls().create();
		String output = gson.toJson(status.get_ramen());
		return output;
	}

}

Lassen Sie uns auch das Verhalten von main.java überprüfen

RamenTest.java

package heroku_java_practice;

import static org.junit.Assert.*;
import org.junit.Test;

import com.heroku_java_practice.*;

public class RamenTest {
	
	/*
	@Test
	public void test() {
		try {
			ramen status = new ramen();
			System.out.println(status.get_ramen());
		} catch(Exception e) {
			e.printStackTrace();
			fail(e.toString());
		}
	}
	*/
	
	@Test
	public void test() {
		try {
			main status = new main();
			System.out.println(status.return_ramen());
		} catch(Exception e) {
			e.printStackTrace();
			fail(e.toString());
		}
	}
	
}

HTML und JavaScript

Erstellen Sie HTML und JavaScript unter src / main / webapp /

index.html

<!DOCTYPE html>
<html lang="ja">
<head>
<meta charset="UTF-8">
<title>project-ramen</title>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.4/jquery.min.js"></script>
<script src="index.js"></script>
</head>
<body>
    <h2>Ramen</h2>
    <table id="ramen"></table>
    <hr style="border-style:dashed">
</body>
</html>

index.js

const MethodURI =  "https://heroku-java-practice.herokuapp.com/webapi/webmethods/";

function gebi(id) {
    return document.getElementById(id);
}

window.onload = function(){
	var uri = MethodURI+'ramen';
	$.getJSON(uri,
	    function(data){
            for(var i=0; i<data.length; i++){
	            var table = gebi("ramen");
	            $(table).append("<tr></tr>").find("tr:last").append("<td>"+"・"+data[i]+"</td>")
	        }
        }
	);
}

Mit diesem js können Sie die Ausgabe in einem Tabellenformat anordnen In Bezug auf MethodURI ist es übrigens besser, den App-Namen auf der Heroku-Seite vor dem Schreiben zu sichern. In Bezug auf webapi / webmethods / wird dies in web.xml bzw. main.java festgelegt.

In Heroku bereitstellen

Create App Sichern Sie einen App-Namen für die Bereitstellung

Vor der Bereitstellung

Vor der Bereitstellung sind einige Dateien für die Bereitstellung erforderlich

• Procfile
• system.properties

Bereiten wir die obigen Dateien vor

Schieben Sie zu Github

Drücken Sie nach dem Hinzufügen der oben genannten Dateien den Quellcode, den Sie für Github bereitstellen möchten.

Bereitstellen

Hier werden wir versuchen, von Github aus bereitzustellen Klicken Sie auf das Github-Symbol Es ist in Ordnung, wenn Sie eine Verknüpfung mit dem Github-Repository herstellen, das Sie bereitstellen möchten Entweder die automatische Bereitstellung oder die manuelle Bereitstellung reicht aus. Klicken Sie zum Bereitstellen auf

Dateistruktur der bereitgestellten Anwendung

Sie können die Dateistruktur der bereitgestellten Anwendung wie folgt überprüfen.

$ heroku login
$ heroku run bash -a <appName>
$ pwd
/app
$ ls

Referenz: [Anzeigen von Dateien und Dateistrukturen in einer bereitgestellten Heroku-App](https://stackoverflow.com/questions/38924458/how-to-see-files-and-file-structure-on-a-deployed-heroku] -app)

abschließend

Derzeit ist die Bereitstellung der mit [Java] Eclipse + Maven + Ontology erstellten Webanwendung mit Heroku abgeschlossen. Wenn es noch etwas gibt, kann ich es hinzufügen (2019/8/9)