Richten Sie einen lokalen Server mit Go-File-Upload ein.

zunaechst

Richten Sie WebServer in Go ein und laden Sie Dateien von der Android-App hoch

Umgebung

PC Windows10 Android Studio 4.0 Kotlin 1.3.72 Android Terminal Emulator (API Level 29) Go 1.11.1

Diagramm

Senden Sie eine Datei von der Android-App, speichern Sie sie auf der Serverseite und geben Sie den Statuscode vom Server an die App zurück

Implementierung

Lokaler Server

Server.go

package controllers

import (
	"fmt"
	"net/http"
	"io/ioutil"
	"os"
)

func apiSampleHandler(w http.ResponseWriter, r *http.Request) {
	switch(r.Method) {
		case "POST":
			fmt.Println("POST")
            //Holen Sie sich hochgeladene Dateien und Header
			file, fileHeader, _ := r.FormFile ("upload_file")　
			fileName := fileHeader.Filename //Dateinamen aus dem Header abrufen
			defer file.Close()              //Schließen Sie die Datei am Ende
			data, _ := ioutil.ReadAll(file) //Datei lesen
			saveFile, _ := os.Create(fileName) //Generieren Sie eine Datei zum Speichern
			defer saveFile.Close()          //Schließen Sie die Datei zum Speichern am Ende
			_, err = saveFile.Write(data)   //In Datei schreiben
			if err != nil {
				fmt.Println("can not write file")
				w.WriteHeader(http.StatusBadRequest)
				return
			}
		case "GET":
			fmt.Println("GET")
	}
    // 200:Gibt OK zurück
	w.WriteHeader(http.StatusOK)
}

// main.Rufen Sie von go an, um den Server zu starten
func StartWebServer() error {
	http.HandleFunc("/", apiSampleHandler)
	return http.ListenAndServe(":8080", nil)
}

Führen Sie main.go aus und starten Sie den Server Gehen Sie zu http: // localhost: 8080 und stellen Sie sicher, dass der Server aktiv ist

Android App

1．Androidmanifest.xml

Definieren Sie die Berechtigung zum Zugriff auf das Internet

AndroidManifest.xml

<uses-permission android:name="android.permission.INTERNET" />

Da die http-Kommunikationseinstellung von Android 9.0 deaktiviert ist, setzen Sie `` `usedCleartextTrafic``` auf true

AndroidManifest.xml

<application
Kürzung
    android:usesCleartextTraffic="true">
    <activity android:name=".MainActivity">
Kürzung
    </activity>
</application>

2. Datei generieren

Generieren Sie eine Textdatei im anwendungsspezifischen Bereich des Android-Geräts (unter `` `/ data / data / {Paketname} / files```).

File.kt

const val FILE_EXPAND = ".txt"

class File {
    fun makeTxtFile(context: Context, fileName: String, str: String) {
        try {
            context.openFileOutput(fileName + FILE_EXPAND, Context.MODE_PRIVATE).use {
                it.write(str.toByteArray())
            }
        } catch (e: IOException) {
            Log.e("File", "#makeTxtFile $e")
        }
    }
}

Bestätigen Sie die Dateierzeugung Zeigen Sie Dateien auf dem Gerät mit dem Gerätedateie-Explorer an (https://developer.android.com/studio/debug/device-file-explorer?hl=ja) )

3. 3. Serverzugriff

Lesen Sie die Datei und senden Sie sie per http-Kommunikation

Net.kt

 fun startConnection(context: Context, requestUrl: String, requestMethod: String, fileName: String): Pair<Int, String> {
        val url = URL(requestUrl)                      //Generierung von URL-Objekten
        //UrlConnection-Objekterstellung
        val urlConnection = url.openConnection() as HttpURLConnection 
        var result = ""
        var responseCode = 0
        try {
            val boundary = "--------------------------" 
            urlConnection.requestMethod = requestMethod // POST,GET etc.
            urlConnection.doOutput = true               //Anfragetext senden
            urlConnection.doInput = true                //Antwortkörper empfangen
            urlConnection.useCaches = false             //Verwendung des Cache
            // multipart/form-Daten: Mehrere Daten senden, Grenze: Trennung zwischen mehreren Daten
            urlConnection.setRequestProperty(
                "Content-Type",
                "multipart/form-data; boundary=$boundary" 
            )
            val filePath = context.filesDir             //App-spezifischer Bereichspfad
            val file = File("$filePath/$fileName$FILE_EXPAND") //Dateiobjekt erstellen
            FileInputStream(file).use { fileInputStream ->
                urlConnection.connect()                 //Stellen Sie eine Verbindung her
                DataOutputStream(urlConnection.outputStream).use {
                   it.writeBytes(                       //Kopfzeile setzen
                       TWO_HYPHEN + boundary + LINE_END +
                               "Content-Disposition: form-data; name=\"upload_file\"; " +
                               "filename=\"$fileName$FILE_EXPAND\"$LINE_END" +
                               "Content-Type: application/octet-stream$LINE_END$LINE_END"
                   )
                   //Datei schreiben
                   val buffer = ByteArray(BUFFER_SIZE)
                   var bytesRead: Int
                   do {
                       bytesRead = fileInputStream.read(buffer)
                       if (bytesRead == -1) break
                       it.write(buffer, 0, bytesRead)
                   } while (true)
                   it.writeBytes(                       //Fußzeileneinstellungen
                        LINE_END + TWO_HYPHEN + boundary + TWO_HYPHEN + LINE_END
                   )
                   it.flush()
                }
            }
            responseCode = urlConnection.responseCode   //Antwortcode abrufen
 
            BufferedReader(InputStreamReader(urlConnection.inputStream)).use {
                val sb = StringBuffer()
                for (line in it.readLines()) {
                    line.let { sb.append(line) }
                }
                result = sb.toString()
            }
        } catch (e: Exception) {
            Log.e("Net", "#startConnection$e")
        } finally {
            urlConnection.disconnect()
        }
        return responseCode to result
    }
}

Vier. Bestätigung der IP-Adresse

Bestätigen Sie die IP-Adresse des Servers (PCs), auf den Sie zugreifen möchten, indem Sie an der Eingabeaufforderung Folgendes ausführen

>ipconfig

Fünf. Verbinden Sie PC und Android-Gerät mit derselben Netzwerkumgebung

6. Verbinde dich mit Android

Setzen Sie http: // {bestätigte IP-Adresse}: 8080 in requestUrl von Net # startConnection und führen Sie die Anwendung aus

Bestätigen Sie das Hochladen der Datei

Überprüfen Sie das gleiche Verzeichnis wie main.go auf Ihrem PC Schließen Sie ab, wenn die Datei erstellt wurde

Schließlich

Die gesamte Quelle ist hier Das Zugriffsziel, RequestMethod und der Dateiname können in der App dynamisch geändert werden.

Verweise

Gehen Sie zur Serverseite

Datei in Go-Sprache hochladen

Android App Seite

[Android] Dateien in der App FileOutputStream, FileInputStream speichern Upload File To Server - Android Example [Android] while-FileInputStream.read-Fehler in Kotlin [Kotlin] Ich möchte mehrere Werte zurückgeben!