import org.bitcoinj.net.discovery.PeerDiscovery; //导入依赖的package包/类
/**
 * Add addresses from a discovery source to the list of potential peers to connect to. If max connections has not
 * been configured, or set to zero, then it's set to the default at this point.
 */
public void addPeerDiscovery(PeerDiscovery peerDiscovery) {
    lock.lock();
    try {
        if (getMaxConnections() == 0)
            setMaxConnections(DEFAULT_CONNECTIONS);
        peerDiscoverers.add(peerDiscovery);
    } finally {
        lock.unlock();
    }
}
 

import org.bitcoinj.net.discovery.PeerDiscovery; //导入依赖的package包/类
@Override
protected void shutDown() throws Exception {
    // This is run on a separate thread by the Service implementation.
    vPingTimer.cancel();
    // Blocking close of all sockets.
    channels.stopAsync();
    channels.awaitTerminated();
    for (PeerDiscovery peerDiscovery : peerDiscoverers) {
        peerDiscovery.shutdown();
    }
    if (torClient != null) {
        torClient.stop();
    }
}
 

import org.bitcoinj.net.discovery.PeerDiscovery; //导入依赖的package包/类
@Test
public void peerDiscoveryPolling() throws InterruptedException {
    // Check that if peer discovery fails, we keep trying until we have some nodes to talk with.
    final CountDownLatch latch = new CountDownLatch(1);
    final AtomicBoolean result = new AtomicBoolean();
    peerGroup.addPeerDiscovery(new PeerDiscovery() {
        @Override
        public InetSocketAddress[] getPeers(long unused, TimeUnit unused2) throws PeerDiscoveryException {
            if (!result.getAndSet(true)) {
                // Pretend we are not connected to the internet.
                throw new PeerDiscoveryException("test failure");
            } else {
                // Return a bogus address.
                latch.countDown();
                return new InetSocketAddress[]{new InetSocketAddress("localhost", 1)};
            }
        }
        @Override
        public void shutdown() {
        }
    });
    peerGroup.startAsync();
    peerGroup.awaitRunning();
    latch.await();
    // Check that we did indeed throw an exception. If we got here it means we threw and then PeerGroup tried
    // again a bit later.
    assertTrue(result.get());
}
 

import org.bitcoinj.net.discovery.PeerDiscovery; //导入依赖的package包/类
@Inject
public PeerGroupService(NetworkParameters params,
                   PeerDiscovery peerDiscovery) {
    this.netParams = params;
    this.peerGroup = new PeerGroup(params);
    peerGroup.setUserAgent(userAgentName, appVersion);
    peerGroup.addPeerDiscovery(peerDiscovery);
}
 

import org.bitcoinj.net.discovery.PeerDiscovery; //导入依赖的package包/类
@Inject
public PeerService(NetworkParameters params,
                   PeerDiscovery peerDiscovery,
                   SimpMessageSendingOperations messagingTemplate) {
    super(params, peerDiscovery);
    this.messagingTemplate = messagingTemplate;
}
 

import org.bitcoinj.net.discovery.PeerDiscovery; //导入依赖的package包/类
private PeerDiscovery createPeerDiscovery(int nrOfAddressesWanted, int port) {
    final InetSocketAddress[] addresses = new InetSocketAddress[nrOfAddressesWanted];
    for (int addressNr = 0; addressNr < nrOfAddressesWanted; addressNr++) {
        // make each address unique by using the counter to increment the port.
        addresses[addressNr] = new InetSocketAddress("localhost", port + addressNr);
    }
    return new PeerDiscovery() {
        public InetSocketAddress[] getPeers(long unused, TimeUnit unused2) throws PeerDiscoveryException {
            return addresses;
        }
        public void shutdown() {
        }
    };
}
 

import org.bitcoinj.net.discovery.PeerDiscovery; //导入依赖的package包/类
private static List<PeerDiscovery> buildDiscoveries(Socks5Proxy proxy, NetworkParameters params, String[] seeds) {
    List<PeerDiscovery> discoveries = new ArrayList<>(seeds.length);
    for (String seed : seeds)
        discoveries.add(new Socks5DnsSeedDiscovery(proxy, params, seed));

    return discoveries;
}
 

import org.bitcoinj.net.discovery.PeerDiscovery; //导入依赖的package包/类
/**
 * Returns an array containing all the Bitcoin nodes that have been discovered.
 */
@Override
public InetSocketAddress[] getPeers(long services, long timeoutValue, TimeUnit timeoutUnit) throws PeerDiscoveryException {
    ArrayList<InetSocketAddress> list = new ArrayList<>();
    for (PeerDiscovery discovery : discoveryList) {
        list.addAll(Arrays.asList(discovery.getPeers(services, timeoutValue, timeoutUnit)));
    }

    return list.toArray(new InetSocketAddress[list.size()]);
}
 

import org.bitcoinj.net.discovery.PeerDiscovery; //导入依赖的package包/类
/**
 * Creates a new PeerGroup allowing you to specify the {@link ClientConnectionManager} which is used to create new
 * connections and keep track of existing ones.
 */
private PeerGroup(NetworkParameters params, @Nullable AbstractBlockChain chain, ClientConnectionManager connectionManager, @Nullable TorClient torClient) {
    this.params = checkNotNull(params);
    this.chain = chain;
    fastCatchupTimeSecs = params.getGenesisBlock().getTimeSeconds();
    wallets = new CopyOnWriteArrayList<Wallet>();
    peerFilterProviders = new CopyOnWriteArrayList<PeerFilterProvider>();
    this.torClient = torClient;

    // This default sentinel value will be overridden by one of two actions:
    //   - adding a peer discovery source sets it to the default
    //   - using connectTo() will increment it by one
    maxConnections = 0;

    int height = chain == null ? 0 : chain.getBestChainHeight();
    versionMessage = new VersionMessage(params, height);
    // We never request that the remote node wait for a bloom filter yet, as we have no wallets
    versionMessage.relayTxesBeforeFilter = true;

    downloadTxDependencies = true;

    memoryPool = new MemoryPool();

    inactives = new PriorityQueue<PeerAddress>(1, new Comparator<PeerAddress>() {
        @Override
        public int compare(PeerAddress a, PeerAddress b) {
            int result = backoffMap.get(a).compareTo(backoffMap.get(b));
            // Sort by port if otherwise equals - for testing
            if (result == 0)
                result = Ints.compare(a.getPort(), b.getPort());
            return result;
        }
    });
    backoffMap = new HashMap<PeerAddress, ExponentialBackoff>();
    peers = new CopyOnWriteArrayList<Peer>();
    pendingPeers = new CopyOnWriteArrayList<Peer>();
    channels = connectionManager;
    peerDiscoverers = new CopyOnWriteArraySet<PeerDiscovery>();
    peerEventListeners = new CopyOnWriteArrayList<ListenerRegistration<PeerEventListener>>();
    runningBroadcasts = Collections.synchronizedSet(new HashSet<TransactionBroadcast>());
    bloomFilterMerger = new FilterMerger(DEFAULT_BLOOM_FILTER_FP_RATE);
}
 

import org.bitcoinj.net.discovery.PeerDiscovery; //导入依赖的package包/类
@Test
public void peerPriority() throws Exception {
    final List<InetSocketAddress> addresses = Lists.newArrayList(
            new InetSocketAddress("localhost", 2000),
            new InetSocketAddress("localhost", 2001),
            new InetSocketAddress("localhost", 2002)
    );
    peerGroup.addEventListener(listener);
    peerGroup.addPeerDiscovery(new PeerDiscovery() {
        @Override
        public InetSocketAddress[] getPeers(long unused, TimeUnit unused2) throws PeerDiscoveryException {
            return addresses.toArray(new InetSocketAddress[addresses.size()]);
        }

        @Override
        public void shutdown() {
        }
    });
    peerGroup.setMaxConnections(3);
    Utils.setMockSleep(true);
    peerGroup.startAsync();
    peerGroup.awaitRunning();

    handleConnectToPeer(0);
    handleConnectToPeer(1);
    handleConnectToPeer(2);
    connectedPeers.take();
    connectedPeers.take();
    connectedPeers.take();
    addresses.clear();
    addresses.addAll(Lists.newArrayList(new InetSocketAddress("localhost", 2003)));
    stopPeerServer(2);
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort()); // peer died

    // discovers, connects to new peer
    handleConnectToPeer(3);
    assertEquals(2003, connectedPeers.take().getAddress().getPort());

    stopPeerServer(1);
    assertEquals(2001, disconnectedPeers.take().getAddress().getPort()); // peer died

    // Alternates trying two offline peers
    Utils.passMockSleep();
    assertEquals(2001, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2001, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2001, disconnectedPeers.take().getAddress().getPort());

    // Peer 2 comes online
    startPeerServer(2);
    Utils.passMockSleep();
    handleConnectToPeer(2);
    assertEquals(2002, connectedPeers.take().getAddress().getPort());

    stopPeerServer(2);
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort()); // peer died

    // Peer 2 is tried before peer 1, since it has a lower backoff due to recent success
    Utils.passMockSleep();
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2001, disconnectedPeers.take().getAddress().getPort());
}
 

import org.bitcoinj.net.discovery.PeerDiscovery; //导入依赖的package包/类
@Bean
public PeerGroupService peerGroupService(NetworkParameters params, PeerDiscovery peerDiscovery) {
    return new PeerGroupService(params, peerDiscovery);
}
 

import org.bitcoinj.net.discovery.PeerDiscovery; //导入依赖的package包/类
/**
 * Sets the peer discovery class to use. If none is provided then DNS is used, which is a reasonable default.
 */
public WalletConfig setDiscovery(@Nullable PeerDiscovery discovery) {
    this.discovery = discovery;
    return this;
}