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 。

---

我不能像上面那樣制作通用服務器，並且有不同的協議處理程序，例如

public class HttpRequestHandler extends RequestHandler {
    ...
}

public class FtpRequestHandler extends RequestHandler {
    ...
}

public class SmtpRequestHandler extends RequestHandler {
    ...
}

然后像下面一樣使用它們

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

Answer 1

你需要一個類的實例。 通用類型T是不夠的。 所以你會這樣做：

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

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

Answer 2

也許使不同的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 3

你沒有。 這沒有意義。 在這種情況下，我可能會避免使用泛型。 普通的舊接口或抽象類可以完成工作。 您可以使用抽象工廠方法創建抽象服務器。

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

Answer 4

/* =================|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());
        }

    }
}

Answer 5

你不能像Java中的泛型一樣直接這樣做。 如果使用getClass()獲取RequestHandler的實際類對象，則可以使用Reflection。 你可以嘗試在構造函數中保存項的類，然后編寫如下的helper方法：

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();
}