tomcat 整体架构
Server：代表整个服务，也能够了解为 tomcat。
service: 代表一个服务，它将若干个 connector 和 contain 连接起来。
connector：连接器，解决用户的 web 申请，反对三种协定：
AJP
HTTP
HTTPS
Container：容器，能够看做 servelet 容器。
engine：servelet 引擎，一个 container 只能有一个 engine，engine 也能够看做是 container 自身。
host：虚拟主机，比方 www.baidu.com，localhost，一个 engine 能够有多个 host。
context：代表一个利用，比方订单服务 order，url 就为 localhost/order, 用户服务 user，url 就为 localhost/user。一个 host 能够有多个 context
Wrapper：servelet，比方订单信息，url 就为 localhost/order/detail/1，一个 context 能够有多个 wrapper。
从配置文件 server.xml 更能感触分层构造：
tomcat 初始化流程
启动流程：
BootStrap.main->
BootStrap.load->Catalina.load->Server.init->Service.init->engine.init->connector.init->
BootStrap.start->Server.start->service-start->engine.start->host.start（被 engine 异步启动）->context.start(被 host 异步启动)->connector.start
能够看到，次要分两步 BootStrap 的 load 和 start 办法，这两个办法里都是逐级调用下一级的 init 或 start 办法。
从咱们启动 tomcat 的命令：./start.sh 动手：
#!/bin/sh
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# -----------------------------------------------------------------------------
# Start Script for the CATALINA Server
# -----------------------------------------------------------------------------
# Better OS/400 detection: see Bugzilla 31132
os400=false
case "`uname`" in
OS400*) os400=true;;
esac
# resolve links - $0 may be a softlink
PRG="$0"
while [-h "$PRG"] ; do
ls=`ls -ld "$PRG"`
link=`expr "$ls" : '.*-> \(.*\)$'`
if expr "$link" : '/.*' > /dev/null; then
PRG="$link"
else
PRG=`dirname "$PRG"`/"$link"
fi
done
PRGDIR=`dirname "$PRG"`
#通过 catalina.sh 来执行
EXECUTABLE=catalina.sh
# Check that target executable exists
if $os400; then
# -x will Only work on the os400 if the files are:
# 1. owned by the user
# 2. owned by the PRIMARY group of the user
# this will not work if the user belongs in secondary groups
eval
else
if [! -x "$PRGDIR"/"$EXECUTABLE"]; then
echo "Cannot find $PRGDIR/$EXECUTABLE"
echo "The file is absent or does not have execute permission"
echo "This file is needed to run this program"
exit 1
fi
fi
exec "$PRGDIR"/"$EXECUTABLE" start "[email protected]"
看看 catalina.sh 文件，代码太长，咱们间接看启动局部：
if ["$1" = "-security"] ; then
if [$have_tty -eq 1]; then
echo "Using Security Manager"
fi
shift
eval $_NOHUP "\"$_RUNJAVA\"""\"$CATALINA_LOGGING_CONFIG\""$LOGGING_MANAGER"$JAVA_OPTS""$CATALINA_OPTS" \
-D$ENDORSED_PROP="\"$JAVA_ENDORSED_DIRS\"" \
-classpath "\"$CLASSPATH\"" \
-Djava.security.manager \
-Djava.security.policy=="\"$CATALINA_BASE/conf/catalina.policy\"" \
-Dcatalina.base="\"$CATALINA_BASE\"" \
-Dcatalina.home="\"$CATALINA_HOME\"" \
-Djava.io.tmpdir="\"$CATALINA_TMPDIR\"" \
# 启动 Bootstrap 类，并将 start 作为参数传进去
org.apache.catalina.startup.Bootstrap "[email protected]" start \
>> "$CATALINA_OUT" 2>&1 "&"当初进入 java 代码，BootStrap 类：
public static void main(String args[]) {synchronized (daemonLock) {if (daemon == null) {// Don't set daemon until init() has completed
Bootstrap bootstrap = new Bootstrap();
try {
// 初始化 Bootstrap
bootstrap.init();} catch (Throwable t) {handleThrowable(t);
t.printStackTrace();
return;
}
// 初始化实现后再赋值给 daemon
daemon = bootstrap;
} else {
// When running as a service the call to stop will be on a new
// thread so make sure the correct class loader is used to
// prevent a range of class not found exceptions.
Thread.currentThread().setContextClassLoader(daemon.catalinaLoader);
}
}
try {
String command = "start";
if (args.length > 0) {command = args[args.length - 1];
}
if (command.equals("startd")) {args[args.length - 1] = "start";
daemon.load(args);
daemon.start();} else if (command.equals("stopd")) {args[args.length - 1] = "stop";
daemon.stop();}
// 启动时走这里
else if (command.equals("start")) {daemon.setAwait(true);
// load 并且 start
daemon.load(args);
daemon.start();
if (null == daemon.getServer()) {System.exit(1);
}
} else if (command.equals("stop")) {daemon.stopServer(args);
} else if (command.equals("configtest")) {daemon.load(args);
if (null == daemon.getServer()) {System.exit(1);
}
System.exit(0);
} else {log.warn("Bootstrap: command \"" + command + "\" does not exist.");
}
} catch (Throwable t) {
// Unwrap the Exception for clearer error reporting
if (t instanceof InvocationTargetException &&
t.getCause() != null) {t = t.getCause();
}
handleThrowable(t);
t.printStackTrace();
System.exit(1);
}
}
首先初始化 Bootstrap 类，而后依据传入的参数执行不同操作，启动就是执行 load 和 start 办法，先看 init 办法做了什么：
public void init() throws Exception {
// 初始化类加载器
initClassLoaders();
Thread.currentThread().setContextClassLoader(catalinaLoader);
SecurityClassLoad.securityClassLoad(catalinaLoader);
// Load our startup class and call its process() method
if (log.isDebugEnabled()) {log.debug("Loading startup class");
}
Class<?> startupClass = catalinaLoader.loadClass("org.apache.catalina.startup.Catalina");
Object startupInstance = startupClass.getConstructor().newInstance();
// Set the shared extensions class loader
if (log.isDebugEnabled()) {log.debug("Setting startup class properties");
}
String methodName = "setParentClassLoader";
Class<?> paramTypes[] = new Class[1];
// 指定
paramTypes[0] = Class.forName("java.lang.ClassLoader");
Object paramValues[] = new Object[1];
paramValues[0] = sharedLoader;
Method method =
startupInstance.getClass().getMethod(methodName, paramTypes);
// Catalina 的父类加载器设为 sharedLoader
method.invoke(startupInstance, paramValues);
catalinaDaemon = startupInstance; //Catalina 实例
}initClassLoaders（）：
private void initClassLoaders() {
try {
// 初始化 common 类加载器
commonLoader = createClassLoader("common", null);
if (commonLoader == null) {
// no config file, default to this loader - we might be in a 'single' env.
commonLoader = this.getClass().getClassLoader();
}
// 父类加载器为 commonLoader
catalinaLoader = createClassLoader("server", commonLoader);
sharedLoader = createClassLoader("shared", commonLoader);
} catch (Throwable t) {handleThrowable(t);
log.error("Class loader creation threw exception", t);
System.exit(1);
}
}
private ClassLoader createClassLoader(String name, ClassLoader parent)
throws Exception {
// catalinaLoader 和 sharedLoader 的加门路为空，所以应用父类加载器
String value = CatalinaProperties.getProperty(name + ".loader");
if ((value == null) || (value.equals(""))) {return parent;}
value = replace(value);
List<Repository> repositories = new ArrayList<>();
String[] repositoryPaths = getPaths(value);
for (String repository : repositoryPaths) {
// Check for a JAR URL repository
try {@SuppressWarnings("unused")
URL url = new URL(repository);
repositories.add(new Repository(repository, RepositoryType.URL));
continue;
} catch (MalformedURLException e) {// Ignore}
// 遍历指定目录下的 jar 包
// Local repository
if (repository.endsWith("*.jar")) {
repository = repository.substring
(0, repository.length() - "*.jar".length());
repositories.add(new Repository(repository, RepositoryType.GLOB));
} else if (repository.endsWith(".jar")) {repositories.add(new Repository(repository, RepositoryType.JAR));
} else {repositories.add(new Repository(repository, RepositoryType.DIR));
}
}
return ClassLoaderFactory.createClassLoader(repositories, parent);
}
initClassLoaders 办法初始化了三个类加载器：commonLoader，catalinaLoader，sharedLoader，并将 catalinaLoader，sharedLoader 的父类加载器指定为 commonLoader，初始化类加载器后又实例化了 catalina 实例，init 办法完结，再看 load 办法：
/**
* Load daemon.
*/
private void load(String[] arguments) throws Exception {// Call the load() method
String methodName = "load";
Object param[];
Class<?> paramTypes[];
if (arguments==null || arguments.length==0) {
paramTypes = null;
param = null;
} else {paramTypes = new Class[1];
paramTypes[0] = arguments.getClass();
param = new Object[1];
param[0] = arguments;
}
Method method =
catalinaDaemon.getClass().getMethod(methodName, paramTypes);
if (log.isDebugEnabled()) {log.debug("Calling startup class" + method);
}
// 调用了 catalina 的 load 办法
method.invoke(catalinaDaemon, param);
}
其实就是调用了 Catalina 的 load 办法:
public void load() {if (loaded) {return;}
loaded = true;
long t1 = System.nanoTime();
initDirs();
// Before digester - it may be needed
initNaming();
// Create and execute our Digester
//xml 文件解析器，比方解析 server.xml
Digester digester = createStartDigester();
InputSource inputSource = null;
InputStream inputStream = null;
File file = null;
try {
try {file = configFile();
inputStream = new FileInputStream(file);
inputSource = new InputSource(file.toURI().toURL().toString());
} catch (Exception e) {if (log.isDebugEnabled()) {log.debug(sm.getString("catalina.configFail", file), e);
}
}
if (inputStream == null) {
try {inputStream = getClass().getClassLoader()
.getResourceAsStream(getConfigFile());
inputSource = new InputSource
(getClass().getClassLoader()
.getResource(getConfigFile()).toString());
} catch (Exception e) {if (log.isDebugEnabled()) {
log.debug(sm.getString("catalina.configFail",
getConfigFile()), e);
}
}
}
// This should be included in catalina.jar
// Alternative: don't bother with xml, just create it manually.
if (inputStream == null) {
try {inputStream = getClass().getClassLoader()
.getResourceAsStream("server-embed.xml");
inputSource = new InputSource
(getClass().getClassLoader()
.getResource("server-embed.xml").toString());
} catch (Exception e) {if (log.isDebugEnabled()) {
log.debug(sm.getString("catalina.configFail",
"server-embed.xml"), e);
}
}
}
if (inputStream == null || inputSource == null) {if (file == null) {
log.warn(sm.getString("catalina.configFail",
getConfigFile() + "] or [server-embed.xml]"));
} else {
log.warn(sm.getString("catalina.configFail",
file.getAbsolutePath()));
if (file.exists() && !file.canRead()) {log.warn("Permissions incorrect, read permission is not allowed on the file.");
}
}
return;
}
try {inputSource.setByteStream(inputStream);
digester.push(this);
digester.parse(inputSource);
} catch (SAXParseException spe) {log.warn("Catalina.start using" + getConfigFile() + ":" +
spe.getMessage());
return;
} catch (Exception e) {log.warn("Catalina.start using" + getConfigFile() + ":" , e);
return;
}
} finally {if (inputStream != null) {
try {inputStream.close();
} catch (IOException e) {// Ignore}
}
}
getServer().setCatalina(this);
getServer().setCatalinaHome(Bootstrap.getCatalinaHomeFile());
getServer().setCatalinaBase(Bootstrap.getCatalinaBaseFile());
// Stream redirection
initStreams();
// Start the new server
try {
// 重点看 init 办法
getServer().init();
} catch (LifecycleException e) {if (Boolean.getBoolean("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE")) {throw new java.lang.Error(e);
} else {log.error("Catalina.start", e);
}
}
long t2 = System.nanoTime();
if(log.isInfoEnabled()) {log.info("Initialization processed in" + ((t2 - t1) / 1000000) + "ms");
}
}getServer().init() 会调用 LifeCycleBase 的 init 办法，LifeCycle 是一个治理 tomcat 生命周期的接口，LifeCycleBase 是它的实现类：
@Override
public final synchronized void init() throws LifecycleException {if (!state.equals(LifecycleState.NEW)) {invalidTransition(Lifecycle.BEFORE_INIT_EVENT);
}
try {setStateInternal(LifecycleState.INITIALIZING, null, false);
// 进入这里
initInternal();
setStateInternal(LifecycleState.INITIALIZED, null, false);
} catch (Throwable t) {handleSubClassException(t, "lifecycleBase.initFail", toString());
}
}initInternal() 是个形象办法，由 StandServer 实现：
@Override
protected void initInternal() throws LifecycleException {super.initInternal();
// Register global String cache
// Note although the cache is global, if there are multiple Servers
// present in the JVM (may happen when embedding) then the same cache
// will be registered under multiple names
onameStringCache = register(new StringCache(), "type=StringCache");
// Register the MBeanFactory
MBeanFactory factory = new MBeanFactory();
factory.setContainer(this);
onameMBeanFactory = register(factory, "type=MBeanFactory");
// Register the naming resources
globalNamingResources.init();
// Populate the extension validator with JARs from common and shared
// class loaders
if (getCatalina() != null) {ClassLoader cl = getCatalina().getParentClassLoader();
// Walk the class loader hierarchy. Stop at the system class loader.
// This will add the shared (if present) and common class loaders
while (cl != null && cl != ClassLoader.getSystemClassLoader()) {if (cl instanceof URLClassLoader) {URL[] urls = ((URLClassLoader) cl).getURLs();
for (URL url : urls) {if (url.getProtocol().equals("file")) {
try {File f = new File (url.toURI());
if (f.isFile() &&
f.getName().endsWith(".jar")) {ExtensionValidator.addSystemResource(f);
}
} catch (URISyntaxException | IOException e) {// Ignore}
}
}
}
cl = cl.getParent();}
}
// Initialize our defined Services
for (Service service : services) {
// 进入这里
service.init();}
}
service 是 StandService，但它的 init 是父类 LifeCycleBase 的办法，又一次运行了这个办法：
@Override
public final synchronized void init() throws LifecycleException {if (!state.equals(LifecycleState.NEW)) {invalidTransition(Lifecycle.BEFORE_INIT_EVENT);
}
try {setStateInternal(LifecycleState.INITIALIZING, null, false);
// 进入这里，这里由 StandService 实现
initInternal();
setStateInternal(LifecycleState.INITIALIZED, null, false);
} catch (Throwable t) {handleSubClassException(t, "lifecycleBase.initFail", toString());
}
}
@Override
protected void initInternal() throws LifecycleException {super.initInternal();
if (engine != null) {
// 初始化 engine
engine.init();}
// Initialize any Executors
for (Executor executor : findExecutors()) {if (executor instanceof JmxEnabled) {((JmxEnabled) executor).setDomain(getDomain());
}
// 初始化 executor
executor.init();}
// Initialize mapper listener
// 初始化 mapperListener
mapperListener.init();
// Initialize our defined Connectors
synchronized (connectorsLock) {for (Connector connector : connectors) {
try {
// 初始化 connector
connector.init();} catch (Exception e) {
String message = sm.getString("standardService.connector.initFailed", connector);
log.error(message, e);
if (Boolean.getBoolean("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE")) {throw new LifecycleException(message);
}
}
}
}
}
又一次调用了 LifeCycleBase 的 init 办法：
@Override
public final synchronized void init() throws LifecycleException {if (!state.equals(LifecycleState.NEW)) {invalidTransition(Lifecycle.BEFORE_INIT_EVENT);
}
try {setStateInternal(LifecycleState.INITIALIZING, null, false);
// 进入这里，这次由 Connect 实现
initInternal();
setStateInternal(LifecycleState.INITIALIZED, null, false);
} catch (Throwable t) {handleSubClassException(t, "lifecycleBase.initFail", toString());
}
} @Override
protected void initInternal() throws LifecycleException {super.initInternal();
// Initialize adapter
adapter = new CoyoteAdapter(this);
protocolHandler.setAdapter(adapter);
// Make sure parseBodyMethodsSet has a default
if (null == parseBodyMethodsSet) {setParseBodyMethods(getParseBodyMethods());
}
if (protocolHandler.isAprRequired() && !AprLifecycleListener.isInstanceCreated()) {
throw new LifecycleException(sm.getString("coyoteConnector.protocolHandlerNoAprListener",
getProtocolHandlerClassName()));
}
if (protocolHandler.isAprRequired() && !AprLifecycleListener.isAprAvailable()) {
throw new LifecycleException(sm.getString("coyoteConnector.protocolHandlerNoAprLibrary",
getProtocolHandlerClassName()));
}
if (AprLifecycleListener.isAprAvailable() && AprLifecycleListener.getUseOpenSSL() &&
protocolHandler instanceof AbstractHttp11JsseProtocol) {
AbstractHttp11JsseProtocol<?> jsseProtocolHandler =
(AbstractHttp11JsseProtocol<?>) protocolHandler;
if (jsseProtocolHandler.isSSLEnabled() &&
jsseProtocolHandler.getSslImplementationName() == null) {
// OpenSSL is compatible with the JSSE configuration, so use it if APR is available
jsseProtocolHandler.setSslImplementationName(OpenSSLImplementation.class.getName());
}
}
try {
// 初始化 ProtocolHandler
protocolHandler.init();} catch (Exception e) {
throw new LifecycleException(sm.getString("coyoteConnector.protocolHandlerInitializationFailed"), e);
}
}protocolHandler.init() 由 AbstractProtocol 实现：
@Override
public void init() throws Exception {if (getLog().isInfoEnabled()) {getLog().info(sm.getString("abstractProtocolHandler.init", getName()));
logPortOffset();}
if (oname == null) {
// Component not pre-registered so register it
oname = createObjectName();
if (oname != null) {Registry.getRegistry(null, null).registerComponent(this, oname, null);
}
}
if (this.domain != null) {ObjectName rgOname = new ObjectName(domain + ":type=GlobalRequestProcessor,name=" + getName());
this.rgOname = rgOname;
Registry.getRegistry(null, null).registerComponent(getHandler().getGlobal(), rgOname, null);
}
String endpointName = getName();
endpoint.setName(endpointName.substring(1, endpointName.length()-1));
endpoint.setDomain(domain);
// 初始化 endPoint
endpoint.init();}endpoint.init() 由 AbstractEndPoint 实现：
public void init() throws Exception {if (bindOnInit) {
// 重点在这里
bindWithCleanup();
bindState = BindState.BOUND_ON_INIT;
}
if (this.domain != null) {// Register endpoint (as ThreadPool - historical name)
oname = new ObjectName(domain + ":type=ThreadPool,name=\"" + getName() + "\"");
Registry.getRegistry(null, null).registerComponent(this, oname, null);
ObjectName socketPropertiesOname = new ObjectName(domain +
":type=SocketProperties,name=\"" + getName() + "\"");
socketProperties.setObjectName(socketPropertiesOname);
Registry.getRegistry(null, null).registerComponent(socketProperties, socketPropertiesOname, null);
for (SSLHostConfig sslHostConfig : findSslHostConfigs()) {registerJmx(sslHostConfig);
}
}
}
private void bindWithCleanup() throws Exception {
try {bind();
} catch (Throwable t) {
// Ensure open sockets etc. are cleaned up if something goes
// wrong during bind
ExceptionUtils.handleThrowable(t);
unbind();
throw t;
}
}进入 NioEndPoint：
/**
* Initialize the endpoint.
*/
@Override
public void bind() throws Exception {
// 初始化 ServerSocket
initServerSocket();
setStopLatch(new CountDownLatch(1));
// Initialize SSL if needed
initialiseSsl();}
// Separated out to make it easier for folks that extend NioEndpoint to
// implement custom [server]sockets
protected void initServerSocket() throws Exception {if (getUseInheritedChannel()) {
// Retrieve the channel provided by the OS
Channel ic = System.inheritedChannel();
if (ic instanceof ServerSocketChannel) {serverSock = (ServerSocketChannel) ic;
}
if (serverSock == null) {throw new IllegalArgumentException(sm.getString("endpoint.init.bind.inherited"));
}
} else {serverSock = ServerSocketChannel.open();
socketProperties.setProperties(serverSock.socket());
InetSocketAddress addr = new InetSocketAddress(getAddress(), getPortWithOffset());
serverSock.socket().bind(addr,getAcceptCount());
}
serverSock.configureBlocking(true); //mimic APR behavior
}BootStrap 的 load 办法实现，就是初始化了一些组件。
再来看 start 办法：
/**
* Start the Catalina daemon.
* @throws Exception Fatal start error
*/
public void start() throws Exception {if (catalinaDaemon == null) {init();
}
Method method = catalinaDaemon.getClass().getMethod("start", (Class [])null);
// 调用 Catalina 的 start 办法
method.invoke(catalinaDaemon, (Object [])null);
}
/**
* Start a new server instance.
*/
public void start() {if (getServer() == null) {load();
}
if (getServer() == null) {log.fatal("Cannot start server. Server instance is not configured.");
return;
}
long t1 = System.nanoTime();
// Start the new server
try {
// start
getServer().start();
} catch (LifecycleException e) {log.fatal(sm.getString("catalina.serverStartFail"), e);
try {getServer().destroy();} catch (LifecycleException e1) {log.debug("destroy() failed for failed Server", e1);
}
return;
}
long t2 = System.nanoTime();
if(log.isInfoEnabled()) {log.info("Server startup in" + ((t2 - t1) / 1000000) + "ms");
}
// Register shutdown hook
if (useShutdownHook) {if (shutdownHook == null) {shutdownHook = new CatalinaShutdownHook();
}
Runtime.getRuntime().addShutdownHook(shutdownHook);
// If JULI is being used, disable JULI's shutdown hook since
// shutdown hooks run in parallel and log messages may be lost
// if JULI's hook completes before the CatalinaShutdownHook()
LogManager logManager = LogManager.getLogManager();
if (logManager instanceof ClassLoaderLogManager) {((ClassLoaderLogManager) logManager).setUseShutdownHook(false);
}
}
if (await) {await();
stop();}
}getServer().start() 调用 LifecycleBase 的 start 办法：
/**
* {@inheritDoc}
*/
@Override
public final synchronized void start() throws LifecycleException {if (LifecycleState.STARTING_PREP.equals(state) || LifecycleState.STARTING.equals(state) ||
LifecycleState.STARTED.equals(state)) {if (log.isDebugEnabled()) {Exception e = new LifecycleException();
log.debug(sm.getString("lifecycleBase.alreadyStarted", toString()), e);
} else if (log.isInfoEnabled()) {log.info(sm.getString("lifecycleBase.alreadyStarted", toString()));
}
return;
}
// start 办法时，state 为 INITIALIZED
if (state.equals(LifecycleState.NEW)) {init();
} else if (state.equals(LifecycleState.FAILED)) {stop();
} else if (!state.equals(LifecycleState.INITIALIZED) &&
!state.equals(LifecycleState.STOPPED)) {invalidTransition(Lifecycle.BEFORE_START_EVENT);
}
try {setStateInternal(LifecycleState.STARTING_PREP, null, false);
// 进入这里，调用的是 StandServer 的 startInternal（）startInternal();
if (state.equals(LifecycleState.FAILED)) {
// This is a 'controlled' failure. The component put itself into the
// FAILED state so call stop() to complete the clean-up.
stop();} else if (!state.equals(LifecycleState.STARTING)) {
// Shouldn't be necessary but acts as a check that sub-classes are
// doing what they are supposed to.
invalidTransition(Lifecycle.AFTER_START_EVENT);
} else {setStateInternal(LifecycleState.STARTED, null, false);
}
} catch (Throwable t) {
// This is an 'uncontrolled' failure so put the component into the
// FAILED state and throw an exception.
handleSubClassException(t, "lifecycleBase.startFail", toString());
}
}
@Override
protected void startInternal() throws LifecycleException {fireLifecycleEvent(CONFIGURE_START_EVENT, null);
setState(LifecycleState.STARTING);
globalNamingResources.start();
// Start our defined Services
synchronized (servicesLock) {for (Service service : services) {
// standService
service.start();}
}
}
前面和 load 办法一样，都是调用了父类 LifecycleBase 的模板办法实现各个组件的 start。