import com.google.bitcoin.utils.ListenerRegistration; //导入依赖的package包/类
private void processGetData(GetDataMessage getdata) {
    log.info("{}: Received getdata message: {}", getAddress(), getdata.toString());
    ArrayList<Message> items = new ArrayList<Message>();
    for (ListenerRegistration<PeerEventListener> registration : eventListeners) {
        if (registration.executor != Threading.SAME_THREAD) continue;
        List<Message> listenerItems = registration.listener.getData(this, getdata);
        if (listenerItems == null) continue;
        items.addAll(listenerItems);
    }
    if (items.size() == 0) {
        return;
    }
    log.info("{}: Sending {} items gathered from listeners to peer", getAddress(), items.size());
    for (Message item : items) {
        sendMessage(item);
    }
}
 

import com.google.bitcoin.utils.ListenerRegistration; //导入依赖的package包/类
/**
 * Returns true if any connected wallet considers any transaction in the block to be relevant.
 */
private boolean containsRelevantTransactions(Block block) {
    // Does not need to be locked.
    for (Transaction tx : block.transactions) {
        try {
            for (final ListenerRegistration<BlockChainListener> registration : listeners) {
                if (registration.executor != Threading.SAME_THREAD) continue;
                if (registration.listener.isTransactionRelevant(tx)) return true;
            }
        } catch (ScriptException e) {
            // We don't want scripts we don't understand to break the block chain so just note that this tx was
            // not scanned here and continue.
            log.warn("Failed to parse a script: " + e.toString());
        }
    }
    return false;
}
 

import com.google.bitcoin.utils.ListenerRegistration; //导入依赖的package包/类
/**
 * Starts an asynchronous download of the block chain. The chain download is deemed to be complete once we've
 * downloaded the same number of blocks that the peer advertised having in its version handshake message.
 */
public void startBlockChainDownload() {
    setDownloadData(true);
    // TODO: peer might still have blocks that we don't have, and even have a heavier
    // chain even if the chain block count is lower.
    final int blocksLeft = getPeerBlockHeightDifference();
    if (blocksLeft >= 0) {
        for (final ListenerRegistration<PeerEventListener> registration : eventListeners) {
            registration.executor.execute(new Runnable() {
                @Override
                public void run() {
                    registration.listener.onChainDownloadStarted(Peer.this, blocksLeft);
                }
            });
        }
        // When we just want as many blocks as possible, we can set the target hash to zero.
        lock.lock();
        try {
            blockChainDownloadLocked(Sha256Hash.ZERO_HASH);
        } finally {
            lock.unlock();
        }
    }
}
 

import com.google.bitcoin.utils.ListenerRegistration; //导入依赖的package包/类
private void queueOnTransactionConfidenceChanged(final Transaction tx) {
    checkState(lock.isHeldByCurrentThread());
    for (final ListenerRegistration<WalletEventListener> registration : eventListeners) {
        if (registration.executor == Threading.SAME_THREAD) {
            registration.listener.onTransactionConfidenceChanged(this, tx);
        } else {
            registration.executor.execute(new Runnable() {
                @Override
                public void run() {
                    registration.listener.onTransactionConfidenceChanged(Wallet.this, tx);
                }
            });
        }
    }
}
 

import com.google.bitcoin.utils.ListenerRegistration; //导入依赖的package包/类
private void maybeQueueOnWalletChanged() {
    // Don't invoke the callback in some circumstances, eg, whilst we are re-organizing or fiddling with
    // transactions due to a new block arriving. It will be called later instead.
    checkState(lock.isHeldByCurrentThread());
    checkState(onWalletChangedSuppressions >= 0);
    if (onWalletChangedSuppressions > 0) return;
    for (final ListenerRegistration<WalletEventListener> registration : eventListeners) {
        registration.executor.execute(new Runnable() {
            @Override
            public void run() {
                registration.listener.onWalletChanged(Wallet.this);
            }
        });
    }
}
 

import com.google.bitcoin.utils.ListenerRegistration; //导入依赖的package包/类
private void queueOnKeysAdded(final List<ECKey> keys) {
    checkState(lock.isHeldByCurrentThread());
    for (final ListenerRegistration<WalletEventListener> registration : eventListeners) {
        registration.executor.execute(new Runnable() {
            @Override
            public void run() {
                registration.listener.onKeysAdded(Wallet.this, keys);
            }
        });
    }
}
 

import com.google.bitcoin.utils.ListenerRegistration; //导入依赖的package包/类
private void queueOnCoinsSent(final Transaction tx, final BigInteger prevBalance, final BigInteger newBalance) {
    checkState(lock.isHeldByCurrentThread());
    for (final ListenerRegistration<WalletEventListener> registration : eventListeners) {
        registration.executor.execute(new Runnable() {
            @Override
            public void run() {
                registration.listener.onCoinsSent(Wallet.this, tx, prevBalance, newBalance);
            }
        });
    }
}
 

import com.google.bitcoin.utils.ListenerRegistration; //导入依赖的package包/类
private void queueOnScriptsAdded(final List<Script> scripts) {
    checkState(lock.isHeldByCurrentThread());
    for (final ListenerRegistration<WalletEventListener> registration : eventListeners) {
        registration.executor.execute(new Runnable() {
            @Override
            public void run() {
                registration.listener.onScriptsAdded(Wallet.this, scripts);
            }
        });
    }
}
 

import com.google.bitcoin.utils.ListenerRegistration; //导入依赖的package包/类
/**
 * Call this after adjusting the confidence, for cases where listeners should be notified. This has to be done
 * explicitly rather than being done automatically because sometimes complex changes to transaction states can
 * result in a series of confidence changes that are not really useful to see separately. By invoking listeners
 * explicitly, more precise control is available. Note that this will run the listeners on the user code thread.
 */
public void queueListeners(final Listener.ChangeReason reason) {
    for (final ListenerRegistration<Listener> registration : listeners) {
        registration.executor.execute(new Runnable() {
            @Override
            public void run() {
                registration.listener.onConfidenceChanged(transaction, reason);
            }
        });
    }
}
 

import com.google.bitcoin.utils.ListenerRegistration; //导入依赖的package包/类
/**
 * Constructs a BlockChain connected to the given list of listeners (eg, wallets) and a store.
 */
public AbstractBlockChain(NetworkParameters params, List<BlockChainListener> listeners,
                          BlockStore blockStore) throws BlockStoreException {
    this.blockStore = blockStore;
    chainHead = blockStore.getChainHead();
    log.info("chain head is at height {}:\n{}", chainHead.getHeight(), chainHead.getHeader());
    this.params = params;
    this.listeners = new CopyOnWriteArrayList<ListenerRegistration<BlockChainListener>>();
    for (BlockChainListener l : listeners) addListener(l, Threading.SAME_THREAD);
}
 

import com.google.bitcoin.utils.ListenerRegistration; //导入依赖的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.
 */
public PeerGroup(NetworkParameters params, @Nullable AbstractBlockChain chain, ClientConnectionManager connectionManager) {
    this.params = checkNotNull(params);
    this.chain = chain;
    this.fastCatchupTimeSecs = params.getGenesisBlock().getTimeSeconds();
    this.wallets = new CopyOnWriteArrayList<Wallet>();
    this.peerFilterProviders = new CopyOnWriteArrayList<PeerFilterProvider>();

    // 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
    this.maxConnections = 0;

    int height = chain == null ? 0 : chain.getBestChainHeight();
    // We never request that the remote node wait for a bloom filter yet, as we have no wallets
    this.versionMessage = new VersionMessage(params, height, 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>());
}
 

import com.google.bitcoin.utils.ListenerRegistration; //导入依赖的package包/类
/**
 * Creates a new, empty wallet with no keys and no transactions. If you want to restore a wallet from disk instead,
 * see loadFromFile.
 */
public Wallet(NetworkParameters params) {
    this.params = checkNotNull(params);
    keychain = new ArrayList<ECKey>();
    watchedScripts = Sets.newHashSet();
    unspent = new HashMap<Sha256Hash, Transaction>();
    spent = new HashMap<Sha256Hash, Transaction>();
    pending = new HashMap<Sha256Hash, Transaction>();
    dead = new HashMap<Sha256Hash, Transaction>();
    transactions = new HashMap<Sha256Hash, Transaction>();
    eventListeners = new CopyOnWriteArrayList<ListenerRegistration<WalletEventListener>>();
    extensions = new HashMap<String, WalletExtension>();
    confidenceChanged = new HashMap<Transaction, TransactionConfidence.Listener.ChangeReason>();
    createTransientState();
}
 

import com.google.bitcoin.utils.ListenerRegistration; //导入依赖的package包/类
private void invokeOnBlocksDownloaded(final Block m) {
    // It is possible for the peer block height difference to be negative when blocks have been solved and broadcast
    // since the time we first connected to the peer. However, it's weird and unexpected to receive a callback
    // with negative "blocks left" in this case, so we clamp to zero so the API user doesn't have to think about it.
    final int blocksLeft = Math.max(0, (int) vPeerVersionMessage.bestHeight - checkNotNull(blockChain).getBestChainHeight());
    for (final ListenerRegistration<PeerEventListener> registration : eventListeners) {
        registration.executor.execute(new Runnable() {
            @Override
            public void run() {
                registration.listener.onBlocksDownloaded(Peer.this, m, blocksLeft);
            }
        });
    }
}
 

import com.google.bitcoin.utils.ListenerRegistration; //导入依赖的package包/类
private void queueOnReorganize() {
    checkState(lock.isHeldByCurrentThread());
    checkState(insideReorg);
    for (final ListenerRegistration<WalletEventListener> registration : eventListeners) {
        registration.executor.execute(new Runnable() {
            @Override
            public void run() {
                registration.listener.onReorganize(Wallet.this);
            }
        });
    }
}
 

import com.google.bitcoin.utils.ListenerRegistration; //导入依赖的package包/类
/**
 * <p>Creates a PeerGroup for the given network and chain, using the provided Netty {@link ClientBootstrap} object.
 * </p>
 *
 * <p>A ClientBootstrap creates raw (TCP) connections to other nodes on the network. Normally you won't need to
 * provide one - use the other constructors. Providing your own bootstrap is useful if you want to control
 * details like how many network threads are used, the connection timeout value and so on. To do this, you can
 * use {@link PeerGroup#createClientBootstrap()} method and then customize the resulting object. Example:</p>
 *
 * <pre>
 *   ClientBootstrap bootstrap = PeerGroup.createClientBootstrap();
 *   bootstrap.setOption("connectTimeoutMillis", 3000);
 *   PeerGroup peerGroup = new PeerGroup(params, chain, bootstrap);
 * </pre>
 *
 * <p>The ClientBootstrap provided does not need a channel pipeline factory set. If one wasn't set, the provided
 * bootstrap will be modified to have one that sets up the pipelines correctly.</p>
 */
public PeerGroup(NetworkParameters params, @Nullable AbstractBlockChain chain, @Nullable ClientBootstrap bootstrap) {
    this.params = checkNotNull(params);
    this.chain = chain;
    this.fastCatchupTimeSecs = params.getGenesisBlock().getTimeSeconds();
    this.wallets = new CopyOnWriteArrayList<Wallet>();
    this.peerFilterProviders = new CopyOnWriteArrayList<PeerFilterProvider>();

    // 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
    this.maxConnections = 0;

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

    memoryPool = new MemoryPool();

    // Configure Netty. The "ClientBootstrap" creates connections to other nodes. It can be configured in various
    // ways to control the network.
    if (bootstrap == null) {
        this.bootstrap = createClientBootstrap();
        this.bootstrap.setPipelineFactory(makePipelineFactory(params, chain));
    } else {
        this.bootstrap = bootstrap;
    }

    inactives = new ArrayList<PeerAddress>();
    peers = new CopyOnWriteArrayList<Peer>();
    pendingPeers = new CopyOnWriteArrayList<Peer>();
    channels = new DefaultChannelGroup();
    peerDiscoverers = new CopyOnWriteArraySet<PeerDiscovery>(); 
    peerEventListeners = new CopyOnWriteArrayList<ListenerRegistration<PeerEventListener>>();
}