DefaultHostnameVerifier should be using slf4j, not jul, close AsyncHttpClient#779

Author: Stephane Landelle

src/main/java/com/ning/http/util/DefaultHostnameVerifier.java

@@ -6,16 +6,18 @@
  */
 package com.ning.http.util;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import javax.net.ssl.HostnameVerifier;
 import javax.net.ssl.SSLPeerUnverifiedException;
 import javax.net.ssl.SSLSession;
 import javax.security.auth.kerberos.KerberosPrincipal;
+
 import java.security.Principal;
 import java.security.cert.Certificate;
 import java.security.cert.CertificateException;
 import java.security.cert.X509Certificate;
-import java.util.logging.Level;
-import java.util.logging.Logger;
 
 /**
  * Uses the internal HostnameChecker to verify the server's hostname matches with the
@@ -36,7 +38,7 @@ public class DefaultHostnameVerifier implements HostnameVerifier {
     private HostnameVerifier extraHostnameVerifier;
 
     // Logger to log exceptions.
-    private static final Logger log = Logger.getLogger(DefaultHostnameVerifier.class.getName());
+    private static final Logger log = LoggerFactory.getLogger(DefaultHostnameVerifier.class.getName());
 
     /**
      * A hostname verifier that uses the {{sun.security.util.HostnameChecker}} under the hood.
@@ -83,42 +85,42 @@ public DefaultHostnameVerifier(HostnameChecker checker, HostnameVerifier extraHo
      * @return true if the hostname matches, false otherwise.
      */
     private boolean hostnameMatches(String hostname, SSLSession session) {
-        log.log(Level.FINE, "hostname = {0}, session = {1}", new Object[] { hostname, Base64.encode(session.getId()) });
+        log.debug("hostname = {}, session = {}",hostname, Base64.encode(session.getId()));
 
         try {
             final Certificate[] peerCertificates = session.getPeerCertificates();
             if (peerCertificates.length == 0) {
-                log.log(Level.FINE, "No peer certificates");
+                log.debug("No peer certificates");
                 return false;
             }
 
             if (peerCertificates[0] instanceof X509Certificate) {
                 X509Certificate peerCertificate = (X509Certificate) peerCertificates[0];
-                log.log(Level.FINE, "peerCertificate = {0}", peerCertificate);
+                log.debug("peerCertificate = {0}", peerCertificate);
                 try {
                     checker.match(hostname, peerCertificate);
                     // Certificate matches hostname if no exception is thrown.
                     return true;
                 } catch (CertificateException ex) {
-                    log.log(Level.FINE, "Certificate does not match hostname", ex);
+                    log.debug("Certificate does not match hostname", ex);
                 }
             } else {
-                log.log(Level.FINE, "Peer does not have any certificates or they aren't X.509");
+                log.debug("Peer does not have any certificates or they aren't X.509");
             }
             return false;
         } catch (SSLPeerUnverifiedException ex) {
-            log.log(Level.FINE, "Not using certificates for peers, try verifying the principal");
+            log.debug("Not using certificates for peers, try verifying the principal");
             try {
                 Principal peerPrincipal = session.getPeerPrincipal();
-                log.log(Level.FINE, "peerPrincipal = {0}", peerPrincipal);
+                log.debug("peerPrincipal = {0}", peerPrincipal);
                 if (peerPrincipal instanceof KerberosPrincipal) {
                     return checker.match(hostname, (KerberosPrincipal) peerPrincipal);
                 } else {
-                    log.log(Level.FINE, "Can't verify principal, not Kerberos");
+                    log.debug("Can't verify principal, not Kerberos");
                 }
             } catch (SSLPeerUnverifiedException ex2) {
                 // Can't verify principal, no principal
-                log.log(Level.FINE, "Can't verify principal, no principal", ex2);
+                log.debug("Can't verify principal, no principal", ex2);
             }
             return false;
         }