Appeler l'API GitHub à partir de l'API Socket de Java, partie 2

Au début

Il s'agit d'une continuation de l'API Call Rest de GitHub à partir de l'API Java Socket. Essayez d'appeler l'API GitHub, qui valide les fichiers dans le référentiel pour GitHub, à partir de l'API Soceket de Java.

Notes de mise en œuvre

1. Que faire avant d'implémenter la logique Java

Afin d'apporter des modifications au référentiel GitHub, nous devons prendre en compte l'authentification lors de l'appel de l'API GitHub. Cette fois, nous émettrons un jeton d'accès personnel sur GitHub à l'avance pour nous authentifier avec l'authentification OAuth2. (Des informations détaillées sur la façon d'émettre un jeton d'accès personnel peuvent être trouvées sur le site de référence ci-dessous.)

2. À propos de la logique Java

Points ajoutés depuis l'implémentation précédente

Le traitement suivant a été ajouté à partir de Dernière implémentation.

• Ajout de la logique pour générer json pour générer les paramètres requis dans GitHub
• Ajout de la logique pour convertir les fichiers à valider sur GitHub au format Base64

Remarques sur les résultats d'exécution

• Une erreur 404 est renvoyée si aucun jeton d'authentification n'est défini
• Si vous spécifiez autre chose que PUT pour la méthode d'envoi, une erreur 404 sera renvoyée.
• Une erreur 422 est renvoyée si le paramètre json envoyé à GitHub est incorrect.
• Spécifiez que le chemin de destination doit inclure des fichiers Erreur 422 renvoyée lors de la spécification du répertoire

Site de référence

• J'ai essayé de résumer diverses choses sur l'API Github Il existe une description de l'authentification de base liée à l'API GitHub. C'est un site que vous devriez lire lors de la mise en œuvre de l'API GitHub.
• Contents
  Contient les spécifications de l'API Rest pour récupérer les informations du référentiel GitHub

La source

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 {
	//Ajouter des fichiers au référentiel de GitHub à l'aide de l'API REST v3 de GitHub
	//Le format de l'API REST v3 est
	// /repos/:owner/:repo/contents/:path
	//Devient
	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");

		//Validez le fichier image sur GitHub avec l'API Rest
		putContents(con,createJson());
		//Sortir les informations d'en-tête de la réponse de l'API Rest
		printHeaderFields(con);
		//Sortir le résultat de la réponse de l'API Rest
		printBody(con);
		con.disconnect();
	}
	
	//Écrire JSON dans le flux
	private static void putContents(HttpsURLConnection con,byte[] b) throws Exception{
		con.setDoOutput(true);
		OutputStream o = con.getOutputStream();
		o.write(b);
		o.flush();
	}
	
	//Convertit un fichier avec le chemin spécifié au format Base64
	public static String converToBase64(String path)throws Exception{
		return Base64.getEncoder()
				.encodeToString(
						Files.readAllBytes(Paths.get(path)));
	}
	
	//Générer HttpsURLConnection en spécifiant la méthode d'envoi HTTP
	private static HttpsURLConnection  createHttpsURLConnection (String path,String method) throws Exception{
		HttpsURLConnection con = createHttpsURLConnection (path);
		con.setRequestMethod(method);
		return con;
	}
	
	
	//Générer des données pour s'engager sur GitHub
	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);
	}
	
	
	//Générer URLConnection pour la connexion TLS(Version non vérifiée de la certification)
	//La méthode de demande est la méthode par défaut(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;
	}
	
	//Informations d'en-tête de sortie
	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);
	}
	
	//Informations sur le corps de sortie
	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;
	}
}