Rufen Sie die GitHub-API über Javas Socket-API Teil2 auf

Am Anfang

Es ist eine Fortsetzung der Call Rest API von GitHub von der Java Socket API. Versuchen Sie, die GitHub-API, die Dateien für GitHub in das Repository festschreibt, über die Soceket-API von Java aufzurufen.

Implementierungshinweise

1. Was ist vor der Implementierung der Java-Logik zu tun?

Um Änderungen am GitHub-Repository vorzunehmen, müssen wir beim Aufrufen der GitHub-API die Authentifizierung berücksichtigen. Dieses Mal stellen wir im Voraus ein persönliches Zugriffstoken auf GitHub aus, um uns mit der OAuth2-Authentifizierung zu authentifizieren. (Detaillierte Informationen zum Ausstellen eines persönlichen Zugriffstokens finden Sie auf der folgenden Referenzseite.)

2. Informationen zur Java-Logik

Punkte aus der vorherigen Implementierung hinzugefügt

Die folgende Verarbeitung wurde aus Letzte Implementierung hinzugefügt.

• Logik zum Generieren von json hinzugefügt, um die erforderlichen Parameter in GitHub zu generieren
• Logik hinzugefügt, um Dateien, die in GitHub festgeschrieben werden sollen, in das Base64-Format zu konvertieren

Hinweise zu den Ausführungsergebnissen

• Ein 404-Fehler wird zurückgegeben, wenn kein Authentifizierungstoken gesetzt ist
• Wenn Sie für die Sendemethode etwas anderes als PUT angeben, wird ein 404-Fehler zurückgegeben.
• Ein 422-Fehler wird zurückgegeben, wenn der an GitHub gesendete json-Parameter falsch ist.
• Geben Sie an, dass der Zielpfad Dateien enthalten muss 422 Fehler beim Angeben des Verzeichnisses zurückgegeben

Referenzseite

• Ich habe versucht, verschiedene Dinge über die Github-API zusammenzufassen Es gibt eine Beschreibung der grundlegenden Authentifizierung in Bezug auf die GitHub-API. Dies ist eine Site, die Sie bei der Implementierung der GitHub-API lesen sollten.
• Contents
  Enthält die Rest-API-Spezifikationen zum Abrufen von GitHub-Repository-Informationen

Quelle

Test.java

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.Base64;
import java.util.LinkedHashMap;
import java.util.Map;

import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.X509TrustManager;


import com.fasterxml.jackson.databind.ObjectMapper;


public class Test {
	//Fügen Sie Dateien mit der REST-API v3 von GitHub zum Repository von GitHub hinzu
	//Das Format der REST-API v3 lautet
	// /repos/:owner/:repo/contents/:path
	//Wird
	private static final String ACCESS_KEY ="＊＊＊＊＊＊＊＊＊";
	private static final String GITHUB_RESTAPI_PATH = "https://api.github.com/repos/triple4649/images/contents/img/mypicture.png?access_token=%s";
	public static void main(String[] args) throws Exception {

		HttpsURLConnection con = createHttpsURLConnection(String.format(GITHUB_RESTAPI_PATH, ACCESS_KEY)
				,"PUT");

		//Übernehmen Sie die Image-Datei mit der Rest-API in GitHub
		putContents(con,createJson());
		//Geben Sie die Header-Informationen der Rest-API-Antwort aus
		printHeaderFields(con);
		//Geben Sie das Ergebnis der Rest-API-Antwort aus
		printBody(con);
		con.disconnect();
	}
	
	//Schreiben Sie JSON in Stream
	private static void putContents(HttpsURLConnection con,byte[] b) throws Exception{
		con.setDoOutput(true);
		OutputStream o = con.getOutputStream();
		o.write(b);
		o.flush();
	}
	
	//Konvertiert eine Datei mit dem angegebenen Pfad in das Base64-Format
	public static String converToBase64(String path)throws Exception{
		return Base64.getEncoder()
				.encodeToString(
						Files.readAllBytes(Paths.get(path)));
	}
	
	//Generieren Sie HttpsURLConnection, indem Sie die HTTP-Sendemethode angeben
	private static HttpsURLConnection  createHttpsURLConnection (String path,String method) throws Exception{
		HttpsURLConnection con = createHttpsURLConnection (path);
		con.setRequestMethod(method);
		return con;
	}
	
	
	//Generieren Sie Daten für CommHub
	private static byte[] createJson() throws Exception{
		Map <String,Object> map = new LinkedHashMap<String,Object>();
		Map <String,String> nestmap=new LinkedHashMap<String,String>();
		nestmap.put("name", "triple");
		nestmap.put("email", "[email protected]");
		map.put("committer",nestmap);
		map.put("message","GitHub API");
		map.put("content",converToBase64("./CA390046.JPG"));
		return new ObjectMapper()
		.writeValueAsBytes(map);
	}
	
	
	//Generieren Sie URLConnection für TLS-Verbindung(Nicht überprüfte Version der Zertifizierung)
	//Die Anforderungsmethode ist die Standardeinstellung(Get)
	private static HttpsURLConnection  createHttpsURLConnection (String path) throws Exception{
		SSLSocketFactory factory = null;
		SSLContext ctx = SSLContext.getInstance("TLS");
		ctx.init(null, new NonAuthentication[] { new NonAuthentication() },
				null);
		factory = ctx.getSocketFactory();

		URL url = new URL(path);
		HttpsURLConnection con = (HttpsURLConnection) url.openConnection();
		con.setSSLSocketFactory(factory);
		return con;
	}
	
	//Header-Informationen ausgeben
	private static void printHeaderFields(HttpsURLConnection con){
		con.getHeaderFields()
		.entrySet()
		.stream()
		.map(e->String.format("key:%s value:%s", e.getKey(),e.getValue()))
		.forEach(System.out::println);
	}
	
	//Informationen zum Ausgabekörper
	private static void printBody(HttpsURLConnection con) throws Exception{
		new BufferedReader(new InputStreamReader(
				con.getInputStream()))
		.lines()
		.forEach(System.out::println);

	}
}

class NonAuthentication implements X509TrustManager {
	@Override
	public void checkClientTrusted(X509Certificate[] chain, String authType)
			throws CertificateException {
	}

	@Override
	public void checkServerTrusted(X509Certificate[] chain, String authType)
			throws CertificateException {
	}

	@Override
	public X509Certificate[] getAcceptedIssuers() {
		return null;
	}
}