import org.apache.cassandra.service.WriteResponseHandler; //导入依赖的package包/类
public <T> AbstractWriteResponseHandler<T> getWriteResponseHandler(Collection<InetAddress> naturalEndpoints,
                                                            Collection<InetAddress> pendingEndpoints,
                                                            ConsistencyLevel consistency_level,
                                                            Runnable callback,
                                                            WriteType writeType)
{
    if (consistency_level.isDatacenterLocal())
    {
        // block for in this context will be localnodes block.
        return new DatacenterWriteResponseHandler<T>(naturalEndpoints, pendingEndpoints, consistency_level, getKeyspace(), callback, writeType);
    }
    else if (consistency_level == ConsistencyLevel.EACH_QUORUM && (this instanceof NetworkTopologyStrategy))
    {
        return new DatacenterSyncWriteResponseHandler<T>(naturalEndpoints, pendingEndpoints, consistency_level, getKeyspace(), callback, writeType);
    }
    return new WriteResponseHandler<T>(naturalEndpoints, pendingEndpoints, consistency_level, getKeyspace(), callback, writeType);
}
 

import org.apache.cassandra.service.WriteResponseHandler; //导入依赖的package包/类
public static void asyncRemoveFromBatchlog(Collection<InetAddress> endpoints, UUID uuid)
{
    AbstractWriteResponseHandler<IMutation> handler = new WriteResponseHandler<>(endpoints,
                                                                                 Collections.<InetAddress>emptyList(),
                                                                                 ConsistencyLevel.ANY,
                                                                                 Keyspace.open(SystemKeyspace.NAME),
                                                                                 null,
                                                                                 WriteType.SIMPLE);
    Mutation mutation = getRemoveMutation(uuid);

    for (InetAddress target : endpoints)
    {
        logger.trace("Sending legacy batchlog remove request {} to {}", uuid, target);
        MessagingService.instance().sendRR(mutation.createMessage(MessagingService.Verb.MUTATION), target, handler, false);
    }
}
 

import org.apache.cassandra.service.WriteResponseHandler; //导入依赖的package包/类
public AbstractWriteResponseHandler getWriteResponseHandler(Collection<InetAddress> naturalEndpoints, Collection<InetAddress> pendingEndpoints, ConsistencyLevel consistency_level, Runnable callback, WriteType writeType)
{
    if (consistency_level.isDatacenterLocal())
    {
        // block for in this context will be localnodes block.
        return new DatacenterWriteResponseHandler(naturalEndpoints, pendingEndpoints, consistency_level, getKeyspace(), callback, writeType);
    }
    else if (consistency_level == ConsistencyLevel.EACH_QUORUM && (this instanceof NetworkTopologyStrategy))
    {
        return new DatacenterSyncWriteResponseHandler(naturalEndpoints, pendingEndpoints, consistency_level, getKeyspace(), callback, writeType);
    }
    return new WriteResponseHandler(naturalEndpoints, pendingEndpoints, consistency_level, getKeyspace(), callback, writeType);
}
 

import org.apache.cassandra.service.WriteResponseHandler; //导入依赖的package包/类
public AbstractWriteResponseHandler getWriteResponseHandler(Collection<InetAddress> naturalEndpoints, Collection<InetAddress> pendingEndpoints, ConsistencyLevel consistency_level, Runnable callback, WriteType writeType)
{
    if (consistency_level == ConsistencyLevel.LOCAL_QUORUM)
    {
        // block for in this context will be localnodes block.
        return new DatacenterWriteResponseHandler(naturalEndpoints, pendingEndpoints, consistency_level, getKeyspace(), callback, writeType);
    }
    else if (consistency_level == ConsistencyLevel.EACH_QUORUM)
    {
        return new DatacenterSyncWriteResponseHandler(naturalEndpoints, pendingEndpoints, consistency_level, getKeyspace(), callback, writeType);
    }
    return new WriteResponseHandler(naturalEndpoints, pendingEndpoints, consistency_level, getKeyspace(), callback, writeType);
}
 

import org.apache.cassandra.service.WriteResponseHandler; //导入依赖的package包/类
public static void syncWriteToBatchlog(WriteResponseHandler<?> handler, Batch batch, Collection<InetAddress> endpoints)
throws WriteTimeoutException, WriteFailureException
{
    for (InetAddress target : endpoints)
    {
        logger.trace("Sending legacy batchlog store request {} to {} for {} mutations", batch.id, target, batch.size());

        int targetVersion = MessagingService.instance().getVersion(target);
        MessagingService.instance().sendRR(getStoreMutation(batch, targetVersion).createMessage(MessagingService.Verb.MUTATION),
                                           target,
                                           handler,
                                           false);
    }
}
 

import org.apache.cassandra.service.WriteResponseHandler; //导入依赖的package包/类
public AbstractWriteResponseHandler getWriteResponseHandler(Collection<InetAddress> naturalEndpoints, Collection<InetAddress> pendingEndpoints, ConsistencyLevel consistency_level, Runnable callback, WriteType writeType)
{
    if (consistency_level == ConsistencyLevel.LOCAL_QUORUM)
    {
        // block for in this context will be localnodes block.
        return new DatacenterWriteResponseHandler(naturalEndpoints, pendingEndpoints, consistency_level, getTable(), callback, writeType);
    }
    else if (consistency_level == ConsistencyLevel.EACH_QUORUM)
    {
        return new DatacenterSyncWriteResponseHandler(naturalEndpoints, pendingEndpoints, consistency_level, getTable(), callback, writeType);
    }
    return new WriteResponseHandler(naturalEndpoints, pendingEndpoints, consistency_level, getTable(), callback, writeType);
}
 

import org.apache.cassandra.service.WriteResponseHandler; //导入依赖的package包/类
public AbstractWriteResponseHandler getWriteResponseHandler(Collection<InetAddress> naturalEndpoints, Collection<InetAddress> pendingEndpoints, ConsistencyLevel consistency_level, Runnable callback, WriteType writeType)
{
    if (consistency_level.isDatacenterLocal())
    {
        // block for in this context will be localnodes block.
        return new DatacenterWriteResponseHandler(naturalEndpoints, pendingEndpoints, consistency_level, getTable(), callback, writeType);
    }
    else if (consistency_level == ConsistencyLevel.EACH_QUORUM)
    {
        return new DatacenterSyncWriteResponseHandler(naturalEndpoints, pendingEndpoints, consistency_level, getTable(), callback, writeType);
    }
    return new WriteResponseHandler(naturalEndpoints, pendingEndpoints, consistency_level, getTable(), callback, writeType);
}
 

import org.apache.cassandra.service.WriteResponseHandler; //导入依赖的package包/类
public AbstractWriteResponseHandler getWriteResponseHandler(Collection<InetAddress> naturalEndpoints, Collection<InetAddress> pendingEndpoints, ConsistencyLevel consistency_level, Runnable callback, WriteType writeType)
{
    if (consistency_level.isDatacenterLocal())
    {
        // block for in this context will be localnodes block.
        return new DatacenterWriteResponseHandler(naturalEndpoints, pendingEndpoints, consistency_level, getTable(), callback, writeType);
    }
    else if (consistency_level == ConsistencyLevel.EACH_QUORUM && (this instanceof NetworkTopologyStrategy))
    {
        return new DatacenterSyncWriteResponseHandler(naturalEndpoints, pendingEndpoints, consistency_level, getTable(), callback, writeType);
    }
    return new WriteResponseHandler(naturalEndpoints, pendingEndpoints, consistency_level, getTable(), callback, writeType);
}