在src/internet/helper/internet-stack-helper.cc源文件中有install方法，对所有节点安装必备的协议。
install方法的源代码如下：
void
InternetStackHelper::Install (Ptr<Node> node) const
{
// InternetStackHelper::Install->1 name=ns3::Node
// InternetStackHelper::Install->1 name=ns3::ConstantPositionMobilityModel
if (m_ipv4Enabled)
{
if (node->GetObject<Ipv4> () != 0)//这里的Ipv4指的就是ns3::Ipv4L3Protocol
{
NS_FATAL_ERROR ("InternetStackHelper::Install (): Aggregating "
"an InternetStack to a node with an existing Ipv4 object");
return;
}
CreateAndAggregateObjectFromTypeId (node, "ns3::ArpL3Protocol");
CreateAndAggregateObjectFromTypeId (node, "ns3::Ipv4L3Protocol");
CreateAndAggregateObjectFromTypeId (node, "ns3::Icmpv4L4Protocol");
if (m_ipv4ArpJitterEnabled == false)
{
Ptr<ArpL3Protocol> arp = node->GetObject<ArpL3Protocol> ();
NS_ASSERT (arp);
arp->SetAttribute ("RequestJitter", StringValue ("ns3::ConstantRandomVariable[Constant=0.0]"));
}
// Set routing
Ptr<Ipv4> ipv4 = node->GetObject<Ipv4> ();
Ptr<Ipv4RoutingProtocol> ipv4Routing = m_routing->Create (node);
ipv4->SetRoutingProtocol (ipv4Routing);
}
if (m_ipv4Enabled || m_ipv6Enabled)
{
CreateAndAggregateObjectFromTypeId (node, "ns3::TrafficControlLayer");
CreateAndAggregateObjectFromTypeId (node, "ns3::UdpL4Protocol");
node->AggregateObject (m_tcpFactory.Create<Object> ());//该类初始化方法中，设置值为ns3::TcpL4Protocol
Ptr<PacketSocketFactory> factory = CreateObject<PacketSocketFactory> ();
node->AggregateObject (factory);
}
}
其中的几行代码如下：
CreateAndAggregateObjectFromTypeId (node, "ns3::ArpL3Protocol");
CreateAndAggregateObjectFromTypeId (node, "ns3::Ipv4L3Protocol");
CreateAndAggregateObjectFromTypeId (node, "ns3::Icmpv4L4Protocol");
CreateAndAggregateObjectFromTypeId (node, "ns3::TrafficControlLayer");
CreateAndAggregateObjectFromTypeId (node, "ns3::UdpL4Protocol");
node->AggregateObject (m_tcpFactory.Create<Object> ());//该类初始化方法中，设置值为ns3::TcpL4Protocol
Ptr<PacketSocketFactory> factory = CreateObject<PacketSocketFactory> ();
node->AggregateObject (factory);
这几行代码是关键的代码，也是代码运行过程中核心。
为什么这么说呢？
从internet-stack-helper.cc的文件的名字可以看出，这个类完成的功能就是完成协议安装，就是将必要的协议安装到节点上。
从互联网七层模型：
应用层
表示层
会话层
传输层
网络层
数据链路层
物理层
其中这个internet-stack-helper.cc完成的就是上面的前五层，其中应用层、表示层、会话层统一为应用层。
上面的代码明显在节点上安装了ARP IP UPD TCP ICMP等协议。
packet在上面的几个协议上发送和被接收。
上面的代码完成了将协议安装到节点的功能，以及将各个对象聚合到节点上。
那么如何获取节点上聚合的对象呢？
下面的代码就可以实现：
/**
* 以下代码用于输出一个Node节点经过install()方法的安装后，
* 已经聚合的所有对象
*/
Node::AggregateIterator iterator = node->GetAggregateIterator();
while(iterator.HasNext()){
Ptr<const Object> obj = iterator.Next();
NS_LOG_LOGIC("InternetStackHelper::Install name="<<obj->GetInstanceTypeId().GetName());
}
输出：
name=ns3::Ipv4L3Protocol
name=ns3::Node
name=ns3::GlobalRouter
name=ns3::TrafficControlLayer
name=ns3::ArpL3Protocol
name=ns3::ConstantPositionMobilityModel
name=ns3::UdpSocketFactory
name=ns3::Icmpv4L4Protocol
name=ns3::Ipv4RawSocketFactory
name=ns3::UdpL4Protocol
name=ns3::TcpL4Protocol
name=ns3::TcpSocketFactory
name=ns3::PacketSocketFactory
通过以上代码的输出，可以确定node节点经过上面的代码后，已经聚合的全部对象：
1、
name=ns3::Node
该对象的聚合是在节点被创建的时候就实现的。可参考Object类的构造器代码实现。
2、
name=ns3::ConstantPositionMobilityModel
该对象的聚合是在install方法之前就已经实现。
3、
name=ns3::ArpL3Protocol
name=ns3::Ipv4L3Protocol
name=ns3::Icmpv4L4Protocol
这三个对象的聚合是在install方法中明确实现的。
4、
name=ns3::GlobalRouter
这个对象的聚合是在install方法中明确实现的。
5、
name=ns3::Ipv4RawSocketFactory
该对向的聚合是在node与ns3::Icmpv4L4Protocol对象聚合的时候，调用NotifyNewAggregate ()方法时，聚合的。
可参看NotifyNewAggregate ()的代码可知。
6、
name=ns3::TrafficControlLayer
name=ns3::UdpL4Protocol
name=ns3::TcpL4Protocol
name=ns3::PacketSocketFactory
这四个对象的聚合是在install方法中明确实现的。
7、
name=ns3::UdpSocketFactory
name=ns3::TcpSocketFactory
以上两个对象的聚合，分别是在name=ns3::UdpL4Protocol,name=ns3::TcpL4Protocol
这两个对象聚合完成时实现的。可参看name=ns3::UdpL4Protocol，name=ns3::TcpL4Protocol
这两个类的NotifyNewAggregate ()代码。
以上所有Node所聚合的对象，代码调用过程可以解释Socket的创建过程。
聚合对象有什么用？
这些聚合的对象我们可以方便的通过一个Node对象获取到。并且这些对象之间都是相互聚合的。通过一个Node对象，可以获取到该对象上面聚合的所有对象。也可以通过Node上面聚合的对象获取到Node对象和Node对象中聚合的其他对象。
为什么能够实现对象之间的相互聚合呢？
可以查看Object类的源代码：
void
Object::AggregateObject (Ptr<Object> o)
{
NS_LOG_FUNCTION (this << o);
NS_ASSERT (!m_disposed);
NS_ASSERT (!o->m_disposed);
NS_ASSERT (CheckLoose ());
NS_ASSERT (o->CheckLoose ());
Object *other = PeekPointer (o);
// first create the new aggregate buffer.
uint32_t total = m_aggregates->n + other->m_aggregates->n;
struct Aggregates *aggregates =
(struct Aggregates *)std::malloc (sizeof(struct Aggregates)+(total-1)*sizeof(Object*));
aggregates->n = total;
// copy our buffer to the new buffer
std::memcpy (&aggregates->buffer[0],
&m_aggregates->buffer[0],
m_aggregates->n*sizeof(Object*));
// append the other buffer into the new buffer too
for (uint32_t i = 0; i < other->m_aggregates->n; i++)
{
aggregates->buffer[m_aggregates->n+i] = other->m_aggregates->buffer[i];
const TypeId typeId = other->m_aggregates->buffer[i]->GetInstanceTypeId ();
if (DoGetObject (typeId))
{
NS_FATAL_ERROR ("Object::AggregateObject(): "
"Multiple aggregation of objects of type " <<
other->GetInstanceTypeId () <<
" on objects of type " << typeId);
//在typeId类型的对象上对other->GetInstanceTypeId ()类型的对象进行多次聚合
}
UpdateSortedArray (aggregates, m_aggregates->n + i);//对最后一位进行排序
/**
* 这是尝试“缓存”此查找的结果。 这个想法是，如果我们对该对象执行
* 一个TypeId的查找，我们可能以后执行相同的查找，所以我们确保聚
* 合数组按照对每个对象的访问次数排序。
*/
}
// keep track of the old aggregate buffers for the iteration
// of NotifyNewAggregates
struct Aggregates *a = m_aggregates;
struct Aggregates *b = other->m_aggregates;
// Then, assign the new aggregation buffer to every object
// 为每个对象分配新的聚合缓冲区
uint32_t n = aggregates->n;
for (uint32_t i = 0; i < n; i++)
{
Object *current = aggregates->buffer[i];
current->m_aggregates = aggregates;
}
/**
* 最后，对所有对象调用NotifyNewAggregate聚合在一起。 我们希望使用
* 旧的聚合缓冲区来遍历对象，因为这允许我们假设它们不会从我们的脚下
* 改变，即使我们的用户从他们的NotifyNewAggregate方法中调用AggregateObject。
*/
for (uint32_t i = 0; i < a->n; i++)
{
Object *current = a->buffer[i];
current->NotifyNewAggregate ();
}
for (uint32_t i = 0; i < b->n; i++)
{
Object *current = b->buffer[i];
current->NotifyNewAggregate ();
}
// Now that we are done with them, we can free our old aggregate buffers
std::free (a);
std::free (b);
}
Object::AggregateObject方法实现了对象之间聚合对象之间的聚合。
