javaの - どのようにジェネリック型T

Question

のインスタンスを作成するために、私は

public class Server<T extends RequestHandler> { 

    public void start() { 

     try{ 
      this.serverSocket = new ServerSocket(this.port, this.backLog); 
     } catch (IOException e) { 
      LOGGER.error("Could not listen on port " + this.port, e); 
      System.exit(-1); 
     } 

     while (!stopTheServer) { 
      socket = null; 
      try { 
       socket = serverSocket.accept(); 
       handleNewConnectionRequest(socket); 
      } catch (IOException e) { 
       LOGGER.warn("Accept failed at: " + this.port, e); 
       e.printStackTrace(); 
      } 
     } 

    } 

    protected void handleNewConnectionRequest(Socket socket) { 
     try { 
      executorService.submit(new T(socket)); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 
    } 
} 

以下のようにサーバーを書いています。しかし、それは実際にはクラスではないようhandleNewConnectionRequest(...)方法では、私はTのインスタンスを作成することはできません。また、私がsocketインスタンスを渡して、socketのリクエストハンドラがOutputStreamとInputStreamになるように、hereというメソッドを使用することはできません。

---

は、私は上記のような一般的なサーバーを作ることはできませんし、異なるプロトコルハンドラが

Server<HttpRequestHandler> httpServer = new Server<HttpRequestHandler>(); 
Server<FtpRequestHandler> ftpServer = new Server<FtpRequestHandler >(); 
Server<SmtpRequestHandler> smtpServer = new Server<SmtpRequestHandler >(); 

Answer 1

はたぶん、さまざまなハンドラのタイプにふさわしい異なるServerサブクラスを作ります。一つの例：

public class HttpServer extends Server<HttpRequestHandler> { 

    protected HttpRequestHandler wrapSocket(Socket socket) { 
     return new HttpRequestHandler(socket); 
    } 

} 

そしてそうのようにサーバーを適応：

public abstract class Server<T extends RequestHandler> { 

    protected abstract T wrapSocket(Socket socket); 

    protected void handleNewConnectionRequest(Socket socket) { 
     try { 
      executorService.submit(wrapSocket(socket)); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 
    } 

} 

だけの思考...

Answer 2

の下にあなたが直接それを行うことはできませんようにそれらを使用し、その後

public class HttpRequestHandler extends RequestHandler { 
    ... 
} 

public class FtpRequestHandler extends RequestHandler { 
    ... 
} 

public class SmtpRequestHandler extends RequestHandler { 
    ... 
} 

を例えばとしていますJavaのジェネリックスのように。 getClass()でRequestHandlerの実際のクラスオブジェクトを取得した場合、Reflectionを使用できます。あなたは、コンストラクタ内のアイテムのクラスを節約しようとし、このようにヘルパーメソッドを書くことができます：

Save the class object (in constructor for example): 
this.clazz = requestHandler.getClass() 

Then create new object of same class: 
E instantiate(Class<E> clazz) 
{ 
    return clazz.newInstance(); 
} 

Answer 3

あなたはクラスのインスタンスが必要になります。総称タイプTでは不十分です。だから、やる：

class Server <T extends RequestHandler> { 
    Class<T> clazz; 
    public Server(Class<T> clazz) { 
     this.clazz = clazz; 
    } 

    private T newRequest() { 
     return clazz.newInstance(); 
    } 
} 

Answer 4

あなたはしないでください。それは意味をなさない。この場合、私はおそらくジェネリックを避けるでしょう。プレーンな古いインターフェイスまたは抽象クラスは仕事をします。抽象ファクトリメソッドを使用して抽象サーバーを作成することができます。

abstract class Server { 
    abstract protected RequestHandler newRequest(Socket socket); 
    ... same as before 
} 

Answer 5

/* =================|Cassandra to Java Connection|===================== */ 
package demo_cassandra_connection; 

import com.datastax.driver.core.Cluster; 
import com.datastax.driver.core.Row; 
import com.datastax.driver.core.Session; 

public class java_to_cassandra_connection 
{ 
    public static void main(String[] args) 
    { 
     com.datastax.driver.core.Session ses; 
     Cluster cluster= 
     Cluster.builder().addContactPoints("54.191.46.102", 
     "54.149.32.12", "54.191.43.254") 
     .withPort(9042).withCredentials("cassandra","cassandra").build(); 
     ses = cluster.connect(); 
     Session session = (Session) cluster.connect(); 
     String cqlStatement = "SELECT * FROM testapp.user"; 
     for (Row row : ((com.datastax.driver.core.Session) 
     session).execute(cqlStatement)) 
     { 
      System.out.println(row.toString()); 
     } 

    } 
}