Liferay 启动过程分析3-处理启动事件（第三部分）

在配置完2个模板引擎之后，它就开始注册索引器：

(7)注册索引器：

// Indexers

IndexerRegistryUtil.register(new MBIndexer());
IndexerRegistryUtil.register(new PluginPackageIndexer());

这里看出，这里注册两种索引器，一个是为MessageBoard注册索引器，一个是为所有的PluginPackage（portlet,layout-template,theme)注册索引器，他们都实现了Indexer接口，所以它必须能完成大多数Indexer的基本操作，比如查询，排序，重建索引，删除等，因为比较简单，就不说了。

(8)数据库升级器：

// Upgrade

if (_log.isDebugEnabled()) {
_log.debug("Upgrade database");
}

DBUpgrader.upgrade();

它会让DBUpgrader执行升级的动作，在DBUpgrader的upgrade()方法中。

首先，它禁用数据库的缓存：

// Disable database caching before upgrade

if (_log.isDebugEnabled()) {
_log.debug("Disable cache registry");
}

CacheRegistryUtil.setActive(false);

CacheRegistryUtil的setActive()方法，最终会调用CacheRegistryImpl的setActive()方法：

public void setActive(boolean active) {
_active = active;

if (!active) {
clear();
}
}

当传入false值时，它会调用CacheRegistryImpl的clear()方法：

public void clear() {
for (Map.Entry<String, CacheRegistryItem> entry :
_cacheRegistryItems.entrySet()) {

CacheRegistryItem cacheRegistryItem = entry.getValue();

if (_log.isDebugEnabled()) {
_log.debug(
"Invalidating " + cacheRegistryItem.getRegistryName());
}

cacheRegistryItem.invalidate();
}
}

可以看出，禁用数据库缓存的本质是是调用所有cacheRegistryItem的invalidate()方法。

当禁用完数据库缓存之后，我们可以正式开始升级数据库，我们回到DBUpgrader类的

upgrader中，它首先获取buildNumber号：

int buildNumber = ReleaseLocalServiceUtil.getBuildNumberOrCreate();

这个版本号，ReleaseLocalServiceUtil中进行了调用封装，最终来自ReleaseLocalServiceImpl类的getBuildNumberOrCreate()方法,它会从数据库中取得buildNumber:

public int getBuildNumberOrCreate()
throws PortalException, SystemException {

// Get release build number

..
try {
con = DataAccess.getConnection();

ps = con.prepareStatement(_GET_BUILD_NUMBER);

ps.setLong(1, ReleaseConstants.DEFAULT_ID);

rs = ps.executeQuery();

if (rs.next()) {
int buildNumber = rs.getInt("buildNumber");

if (_log.isDebugEnabled()) {
_log.debug("Build number " + buildNumber);
}

testSupportsStringCaseSensitiveQuery();

return buildNumber;
}
}
catch (Exception e) {
if (_log.isWarnEnabled()) {
_log.warn(e.getMessage());
}
}
finally {
DataAccess.cleanUp(con, ps, rs);
}

// Create tables and populate with default data

if (GetterUtil.getBoolean(
PropsUtil.get(PropsKeys.SCHEMA_RUN_ENABLED))) {

releaseLocalService.createTablesAndPopulate();

testSupportsStringCaseSensitiveQuery();

Release release = getRelease(
ReleaseConstants.DEFAULT_SERVLET_CONTEXT_NAME,
ReleaseInfo.getBuildNumber());

return release.getBuildNumber();
}
else {
throw new NoSuchReleaseException(
"The database needs to be populated");
}
}

然后它会吧这个buildNumber和服务器的releaseNumber还有5.0.0进行比较，确保数据库的版本高于5.0.0，并且不高于服务器的版本号：

if (buildNumber > ReleaseInfo.getBuildNumber()) {
..
else if (buildNumber < ReleaseInfo.RELEASE_5_0_0_BUILD_NUMBER) {
String msg = "You must first upgrade to Liferay Portal 5.0.0";
}

一旦数据库版本号满足 5.0.0<=DB版本号<=服务器版本号，则DB就可以进行升级了。它先重新加载SQL语句：

// Reload SQL

CustomSQLUtil.reloadCustomSQL();
SQLTransformer.reloadSQLTransformer();

这2个语句对应的内容都会先判断db的方言，然后选用正确的语句执行，第二个语句，主要执行的是Hibernate的HQL和JPA的JPQL之间的转换。

然后，它还会做一系列的数据库升级动作，就不一一展开了。

（9）初始化消息总线：

// Messaging

if (_log.isDebugEnabled()) {
_log.debug("Initialize message bus");
}

MessageBus messageBus = (MessageBus)PortalBeanLocatorUtil.locate(
MessageBus.class.getName());
MessageSender messageSender =
(MessageSender)PortalBeanLocatorUtil.locate(
MessageSender.class.getName());
SynchronousMessageSender synchronousMessageSender =
(SynchronousMessageSender)PortalBeanLocatorUtil.locate(
SynchronousMessageSender.class.getName());

MessageBusUtil.init(
messageBus, messageSender, synchronousMessageSender);

它会向ClassLoader所要MessageBus 和 MessageSender的对象：然后执行初始化动作。

（10）初始化ClusterExecutor，其实是初始化自身的集群节点信息（因为它不能假定自己是否在一个集群环境中，所以还是吧自己的节点信息初始化之）

// Cluster executor

ClusterExecutorUtil.initialize();

它最终会调用ClusterExecutorImpl的initialize()方法：

public void initialize() {
if (!isEnabled()) {
return;
}

PortalUtil.addPortalPortEventListener(this);

_localAddress = new AddressImpl(_controlChannel.getLocalAddress());

try {
initLocalClusterNode();
}
catch (SystemException se) {
_log.error("Unable to determine local network address", se);
}

ObjectValuePair<Address, ClusterNode> localInstance =
new ObjectValuePair<Address, ClusterNode>(
_localAddress, _localClusterNode);

_liveInstances.put(localInstance, Long.MAX_VALUE);

_clusterNodeAddresses.put(
_localClusterNode.getClusterNodeId(), _localAddress);

_clusterRequestReceiver.initialize();

_scheduledExecutorService = Executors.newScheduledThreadPool(
1,
new NamedThreadFactory(
ClusterExecutorImpl.class.getName(), Thread.NORM_PRIORITY,
Thread.currentThread().getContextClassLoader()));

_scheduledExecutorService.scheduleWithFixedDelay(
new HeartbeatTask(), 0,
PropsValues.CLUSTER_EXECUTOR_HEARTBEAT_INTERVAL,
TimeUnit.MILLISECONDS);
}

就不往下展开了。

（11）初始化定时器：

// Scheduler

if (_log.isDebugEnabled()) {
_log.debug("Initialize scheduler engine lifecycle");
}

SchedulerEngineUtil.initialize();

它会调用SchedulerEngineUtil的initialize()方法：

public static void initialize() throws SchedulerException {
_instance._initialize();

SchedulerLifecycle schedulerLifecycle = new SchedulerLifecycle();

schedulerLifecycle.registerPortalLifecycle(PortalLifecycle.METHOD_INIT);
}

从第02行跟踪下去，会发现它仍然是和集群相关的，它会去调用ClusterSchedulerEngine的initialize()方法，进而调用initMemoryClusteredJobs()方法,这里就不展开了：

protected void initMemoryClusteredJobs() throws Exception {
List<SchedulerResponse> schedulerResponses =
(List<SchedulerResponse>)callMaster(
_getScheduledJobsMethodKey3, StorageType.MEMORY_CLUSTERED);

for (SchedulerResponse schedulerResponse : schedulerResponses) {
Trigger oldTrigger = schedulerResponse.getTrigger();

String jobName = schedulerResponse.getJobName();
String groupName = SchedulerEngineUtil.namespaceGroupName(
schedulerResponse.getGroupName(), StorageType.MEMORY_CLUSTERED);

Trigger newTrigger = TriggerFactoryUtil.buildTrigger(
oldTrigger.getTriggerType(), jobName, groupName,
oldTrigger.getStartDate(), oldTrigger.getEndDate(),
oldTrigger.getTriggerContent());

schedulerResponse.setTrigger(newTrigger);

TriggerState triggerState = SchedulerEngineUtil.getJobState(
schedulerResponse);

Message message = schedulerResponse.getMessage();

message.remove(JOB_STATE);

_memoryClusteredJobs.put(
getFullName(jobName, groupName),
new ObjectValuePair<SchedulerResponse, TriggerState>(
schedulerResponse, triggerState));
}
}