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

你不能像 Java 中的泛型那样直接做到这一点。如果您使用 getClass() 获取 RequestHandler 的实际类对象，则可以使用反射。您可以尝试在构造函数中保存该项目的类，然后编写如下辅助方法：

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

    }
}