StandardSocketFactory.java
上传用户:sxlinghang
上传日期:2022-07-20
资源大小:1405k
文件大小:6k
源码类别:

数据库编程

开发平台:

Java

  1. /*
  2.    Copyright (C) 2002 MySQL AB
  3.       This program is free software; you can redistribute it and/or modify
  4.       it under the terms of the GNU General Public License as published by
  5.       the Free Software Foundation; either version 2 of the License, or
  6.       (at your option) any later version.
  7.       This program is distributed in the hope that it will be useful,
  8.       but WITHOUT ANY WARRANTY; without even the implied warranty of
  9.       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10.       GNU General Public License for more details.
  11.       You should have received a copy of the GNU General Public License
  12.       along with this program; if not, write to the Free Software
  13.       Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  14.  */
  15. package com.mysql.jdbc;
  16. import java.io.IOException;
  17. import java.lang.reflect.Constructor;
  18. import java.lang.reflect.Method;
  19. import java.net.Socket;
  20. import java.net.SocketException;
  21. import java.util.Properties;
  22. /**
  23.  * Socket factory for vanilla TCP/IP sockets (the standard)
  24.  *
  25.  * @author Mark Matthews
  26.  */
  27. public class StandardSocketFactory implements SocketFactory {
  28.     /** The underlying TCP/IP socket to use */
  29.     protected Socket rawSocket = null;
  30.     /** The hostname to connect to */
  31.     protected String host = null;
  32.     /** The port number to connect to */
  33.     protected int port = 3306;
  34.     /**
  35.      * Called by the driver after issuing the MySQL protocol handshake and
  36.      * reading the results of the handshake.
  37.      *
  38.      * @throws SocketException if a socket error occurs
  39.      * @throws IOException if an I/O error occurs
  40.      *
  41.      * @return The socket to use after the handshake
  42.      */
  43.     public Socket afterHandshake() throws SocketException, IOException {
  44.         return rawSocket;
  45.     }
  46.     /**
  47.      * Called by the driver before issuing the MySQL protocol handshake.
  48.      * Should return the socket instance that should be used during
  49.      * the handshake.
  50.      *
  51.      * @throws SocketException if a socket error occurs
  52.      * @throws IOException if an I/O error occurs
  53.      *
  54.      * @return the socket to use before the handshake
  55.      */
  56.     public Socket beforeHandshake() throws SocketException, IOException {
  57.         return rawSocket;
  58.     }
  59.     /**
  60.      * @see com.mysql.jdbc.SocketFactory#createSocket(Properties)
  61.      */
  62.     public Socket connect(String host, Properties props)
  63.         throws SocketException, IOException {
  64.         if (props != null) {
  65.             this.host = host;
  66.             String portStr = props.getProperty("PORT");
  67.             if (portStr != null) {
  68.                 port = Integer.parseInt(portStr);
  69.             }
  70.             boolean hasConnectTimeoutMethod = false;
  71.             Method connectWithTimeoutMethod = null;
  72.             try {
  73.                 // Have to do this with reflection, otherwise older JVMs croak
  74.                 Class socketAddressClass = Class.forName(
  75.                         "java.net.SocketAddress");
  76.                 connectWithTimeoutMethod = Socket.class.getMethod("connect",
  77.                         new Class[] { socketAddressClass, Integer.TYPE });
  78.                 hasConnectTimeoutMethod = true;
  79.             } catch (NoClassDefFoundError noClassDefFound) {
  80.                 hasConnectTimeoutMethod = false;
  81.             } catch (NoSuchMethodException noSuchMethodEx) {
  82.                 hasConnectTimeoutMethod = false;
  83.             } catch (Throwable catchAll) {
  84.                 hasConnectTimeoutMethod = false;
  85.             }
  86.             int connectTimeout = 0;
  87.             String connectTimeoutStr = props.getProperty("connectTimeout");
  88.             if (connectTimeoutStr != null) {
  89.                 try {
  90.                     connectTimeout = Integer.parseInt(connectTimeoutStr);
  91.                 } catch (NumberFormatException nfe) {
  92.                     throw new SocketException("Illegal value '"
  93.                         + connectTimeoutStr + "' for connectTimeout");
  94.                 }
  95.             }
  96.             if (this.host != null) {
  97.                 if (!hasConnectTimeoutMethod || (connectTimeout == 0)) {
  98.                     rawSocket = new Socket(this.host, port);
  99.                 } else {
  100.                     // must explicitly state this due to classloader issues
  101.                     // when running on older JVMs :(
  102.                     try {
  103.                         Class inetSocketAddressClass = Class.forName(
  104.                                 "java.net.InetSocketAddress");
  105.                         Constructor addrConstructor = inetSocketAddressClass
  106.                             .getConstructor(new Class[] {
  107.                                     String.class, Integer.TYPE
  108.                                 });
  109.                         Object sockAddr = addrConstructor.newInstance(new Object[] {
  110.                                     this.host, new Integer(port)
  111.                                 });
  112.                         rawSocket = new Socket();
  113.                         connectWithTimeoutMethod.invoke(rawSocket,
  114.                             new Object[] { sockAddr, new Integer(connectTimeout) });
  115.                     } catch (Throwable t) {
  116.                         throw new SocketException(t.toString());
  117.                     }
  118.                 }
  119.                 try {
  120.                     rawSocket.setTcpNoDelay(true);
  121.                 } catch (Exception ex) {
  122.                     /* Ignore */
  123.                 }
  124.                 return rawSocket;
  125.             }
  126.         }
  127.         throw new SocketException("Unable to create socket");
  128.     }
  129. }