标签：
【0】README2.1）org.apache.catalina.startup.Catalina类：用于启动和关闭Server对象，并负责解析Tomcat 配置文件 server.xml；2.2）org.apache.catalina.startup.Bootstrap类：是一个入口点，负责创建 Catalina实例，并调用其 process()方法；
1.1）该类还封装了一个Server对象（服务器组件，你是否有印象）：该对象有一个Service对象（服务组件，你是否有印象）；（干货——服务器组件+服务组件，参见tomcat(14)服务器组件和服务组件）1.2）Service对象包含有一个Servlet容器和一个或多个连接器。所以可以使用Catalina类来启动或关闭Server对象；
public void process(String args[]) { // org.apache.catalina.startup.Catalina.process().
setCatalinaHome();
setCatalinaBase();
try {
if (arguments(args)) //highlight line.
execute();
} catch (Exception e) {
e.printStackTrace(System.out);
}
}
protected void setCatalinaHome() {
if (System.getProperty("catalina.home") != null)
return;
System.setProperty("catalina.home",
System.getProperty("user.dir"));
}
protected void setCatalinaBase() {
if (System.getProperty("catalina.base") != null)
return;
System.setProperty("catalina.base",
System.getProperty("catalina.home"));
}step1）process()方法设置了两个系统属性：catalina.home and catalina.base.catalina.home，默认值均为user.dir 属性的值；step2）catalina.base == catalina.home ，所以，他们都与 user.dir 属性的值相同；step3）随后，process()方法会调用 arguments()方法(highlight line)，并传入参数列表；step4）intro to arguments()方法：arguments()方法处理命令行参数，如果Catalina对象能够继续处理的话，arguments()方法返回true；protected boolean arguments(String args[]) { boolean isConfig = false; if (args.length < 1) { usage(); return (false); } for (int i = 0; i < args.length; i++) { if (isConfig) { configFile = args[i]; isConfig = false; } else if (args[i].equals("-config")) { isConfig = true; } else if (args[i].equals("-debug")) { debug = true; } else if (args[i].equals("-nonaming")) { useNaming = false; } else if (args[i].equals("-help")) { usage(); return (false); } else if (args[i].equals("start")) { starting = true; } else if (args[i].equals("stop")) { stopping = true; } else { usage(); return (false); } } return (true); } protected void usage() { System.out.println ("usage: java org.apache.catalina.startup.Catalina" + " [ -config {pathname} ] [ -debug ]" + " [ -nonaming ] { start | stop }"); }
step5）process()方法会检查arguments()的返回值是否为true，若为true，则调用execute()方法；该方法会调用start()方法来启动tomcat， 或调用stop()方法来关闭 tomcat；protected void execute() throws Exception { if (starting) start(); else if (stopping) stop(); }
protected void start() { // org.apache.catalina.startup.Catalina.start().
// Setting additional variables
if (!useNaming) {
System.setProperty("catalina.useNaming", "false");
} else {
System.setProperty("catalina.useNaming", "true");
String value = "org.apache.naming";
String oldValue =
System.getProperty(javax.naming.Context.URL_PKG_PREFIXES);
if (oldValue != null) {
value = value + ":" + oldValue;
} // String URL_PKG_PREFIXES = "java.naming.factory.url.pkgs";
System.setProperty(javax.naming.Context.URL_PKG_PREFIXES, value);
value = System.getProperty
(javax.naming.Context.INITIAL_CONTEXT_FACTORY);
if (value == null) {
System.setProperty
(javax.naming.Context.INITIAL_CONTEXT_FACTORY,
"org.apache.naming.java.javaURLContextFactory");
}
}
// Create and execute our Digester
Digester digester = createStartDigester();
File file = configFile();
try {
InputSource is =
new InputSource("file://" + file.getAbsolutePath());
FileInputStream fis = new FileInputStream(file);
is.setByteStream(fis);
digester.push(this);
digester.parse(is);
fis.close();
} catch (Exception e) {
System.out.println("Catalina.start using "
+ configFile() + ": " + e);
e.printStackTrace(System.out);
System.exit(1);
}
// If a SecurityManager is being used, set properties for
// checkPackageAccess() and checkPackageDefinition
if( System.getSecurityManager() != null ) {
String access = Security.getProperty("package.access");
if( access != null && access.length() > 0 )
access += ",";
else
access = "sun.,";
Security.setProperty("package.access",
access +
"org.apache.catalina.,org.apache.jasper.");
String definition = Security.getProperty("package.definition");
if( definition != null && definition.length() > 0 )
definition += ",";
else
definition = "sun.,";
Security.setProperty("package.definition",
// FIX ME package "javax." was removed to prevent HotSpot
// fatal internal errors
definition +
"java.,org.apache.catalina.,org.apache.jasper.,org.apache.coyote.");
}
// Replace System.out and System.err with a custom PrintStream
SystemLogHandler log = new SystemLogHandler(System.out);
System.setOut(log);
System.setErr(log);
Thread shutdownHook = new CatalinaShutdownHook();
// Start the new server
if (server instanceof Lifecycle) {
try {
server.initialize();
((Lifecycle) server).start();
try {
// Register shutdown hook
Runtime.getRuntime().addShutdownHook(shutdownHook);
} catch (Throwable t) {
// This will fail on JDK 1.2. Ignoring, as Tomcat can run
// fine without the shutdown hook.
}
// Wait for the server to be told to shut down
server.await();
} catch (LifecycleException e) {
System.out.println("Catalina.start: " + e);
e.printStackTrace(System.out);
if (e.getThrowable() != null) {
System.out.println("----- Root Cause -----");
e.getThrowable().printStackTrace(System.out);
}
}
}
// Shut down the server
if (server instanceof Lifecycle) {
try {
try {
// Remove the ShutdownHook first so that server.stop()
// doesn't get invoked twice
Runtime.getRuntime().removeShutdownHook(shutdownHook);
} catch (Throwable t) {
// This will fail on JDK 1.2. Ignoring, as Tomcat can run
// fine without the shutdown hook.
}
((Lifecycle) server).stop();
} catch (LifecycleException e) {
System.out.println("Catalina.stop: " + e);
e.printStackTrace(System.out);
if (e.getThrowable() != null) {
System.out.println("----- Root Cause -----");
e.getThrowable().printStackTrace(System.out);
}
}
}
}step1）该方法会创建一个Digester实例来解析server.xml(tomcat配置文件)；在解析server.xml文件之前，该方法会调用 Digester.push()方法，传入当前的Catalina对象，这样，Catalina对象就成了Digester对象的内部栈中的第一个对象；step2）解析server.xml文件后，会使变量Server引用一个Server对象，默认是 org.apache.catalina.core.StandardServer类型的对象；step3）然后，start()方法会调用Server.initialize()方法 和 start()方法；step4）接着，Catalina.start()方法会调用server对象的await（）方法，Server对象会使用一个专用的线程来等待关闭命令；await()方法会一直等待直到接收到正确的关闭命令；step5）当await()方法返回时，Catalina.start()方法会调用Server.stop()方法，从而关闭Server对象和其它的组件；
A1）此外，start（）方法还会利用关闭钩子，确保用户突然退出应用程序时会执行Server.stop()方法；A2）start()方法会调用了createStartDigester 方法创建Digester对象，createStartDigester()方法的源码如下：
protected Digester createStartDigester() { // Initialize the digester Digester digester = new Digester(); digester.setClassLoader(StandardServer.class.getClassLoader()); if (debug) digester.setDebug(999); digester.setValidating(false); // Configure the actions we will be using digester.addObjectCreate("Server", "org.apache.catalina.core.StandardServer", "className"); digester.addSetProperties("Server"); digester.addSetNext("Server", "setServer", "org.apache.catalina.Server"); digester.addObjectCreate("Server/GlobalNamingResources", "org.apache.catalina.deploy.NamingResources"); digester.addSetProperties("Server/GlobalNamingResources"); digester.addSetNext("Server/GlobalNamingResources", "setGlobalNamingResources", "org.apache.catalina.deploy.NamingResources"); digester.addObjectCreate("Server/Listener", null, // MUST be specified in the element "className"); digester.addSetProperties("Server/Listener"); digester.addSetNext("Server/Listener", "addLifecycleListener", "org.apache.catalina.LifecycleListener"); digester.addObjectCreate("Server/Service", "org.apache.catalina.core.StandardService", "className"); digester.addSetProperties("Server/Service"); digester.addSetNext("Server/Service", "addService", "org.apache.catalina.Service"); digester.addObjectCreate("Server/Service/Listener", null, // MUST be specified in the element "className"); digester.addSetProperties("Server/Service/Listener"); digester.addSetNext("Server/Service/Listener", "addLifecycleListener", "org.apache.catalina.LifecycleListener"); digester.addObjectCreate("Server/Service/Connector", "org.apache.catalina.connector.http.HttpConnector", "className"); digester.addSetProperties("Server/Service/Connector"); digester.addSetNext("Server/Service/Connector", "addConnector", "org.apache.catalina.Connector"); digester.addObjectCreate("Server/Service/Connector/Factory", "org.apache.catalina.net.DefaultServerSocketFactory", "className"); digester.addSetProperties("Server/Service/Connector/Factory"); digester.addSetNext("Server/Service/Connector/Factory", "setFactory", "org.apache.catalina.net.ServerSocketFactory"); digester.addObjectCreate("Server/Service/Connector/Listener", null, // MUST be specified in the element "className"); digester.addSetProperties("Server/Service/Connector/Listener"); digester.addSetNext("Server/Service/Connector/Listener", "addLifecycleListener", "org.apache.catalina.LifecycleListener"); // Add RuleSets for nested elements digester.addRuleSet(new NamingRuleSet("Server/GlobalNamingResources/")); digester.addRuleSet(new EngineRuleSet("Server/Service/")); digester.addRuleSet(new HostRuleSet("Server/Service/Engine/")); digester.addRuleSet(new ContextRuleSet("Server/Service/Engine/Default")); digester.addRuleSet(new NamingRuleSet("Server/Service/Engine/DefaultContext/")); digester.addRuleSet(new ContextRuleSet("Server/Service/Engine/Host/Default")); digester.addRuleSet(new NamingRuleSet("Server/Service/Engine/Host/DefaultContext/")); digester.addRuleSet(new ContextRuleSet("Server/Service/Engine/Host/")); digester.addRuleSet(new NamingRuleSet("Server/Service/Engine/Host/Context/")); digester.addRule("Server/Service/Engine", new SetParentClassLoaderRule(digester, parentClassLoader)); return (digester); }
protected void stop() { //org.apache.catalina.startup.Catalina.stop().
// Create and execute our Digester
Digester digester = createStopDigester();
File file = configFile();
try {
InputSource is =
new InputSource("file://" + file.getAbsolutePath());
FileInputStream fis = new FileInputStream(file);
is.setByteStream(fis);
digester.push(this);
digester.parse(is);
fis.close();
} catch (Exception e) {
System.out.println("Catalina.stop: " + e);
e.printStackTrace(System.out);
System.exit(1);
}
// Stop the existing server
try {
Socket socket = new Socket("127.0.0.1", server.getPort());
OutputStream stream = socket.getOutputStream();
String shutdown = server.getShutdown();
for (int i = 0; i < shutdown.length(); i++)
stream.write(shutdown.charAt(i));
stream.flush();
stream.close();
socket.close();
} catch (IOException e) {
System.out.println("Catalina.stop: " + e);
e.printStackTrace(System.out);
System.exit(1);
}
}
protected Digester createStopDigester() {
// Initialize the digester
Digester digester = new Digester();
if (debug)
digester.setDebug(999);
// Configure the rules we need for shutting down
digester.addObjectCreate("Server",
"org.apache.catalina.core.StandardServer",
"className");
digester.addSetProperties("Server");
digester.addSetNext("Server",
"setServer",
"org.apache.catalina.Server");
return (digester);
}A1）stop()方法：调用createStopDigester()方法来创建一个 Digester实例，并调用该实例的push()方法，并将当前Catalina对象压入到 Digester对象的内部栈中，使用Digester对象解析tomcat 的配置文件；A2）然后，stop()方法会向正在运行的Server对象发送关闭命令，以关闭Server对象；
step1）该方法会创建org.apache.commons.digester.Digestser类的实例，并为其添加规则（rules）；step2）前3条规则用于解析 server.xml 文件的server元素。下面是为 server 模式添加的规则（因为server元素是跟元素，故又称为模式）：// Configure the actions we will be using digester.addObjectCreate("Server", "org.apache.catalina.core.StandardServer", "className"); digester.addSetProperties("Server"); digester.addSetNext("Server", "setServer", "org.apache.catalina.Server");
rule1）第1条规则表明：在遇到server元素时，Digester要创建 StandardServer 类的一个实例；rule2）第2条规则表明：要对 Server对象的指定属性名设置同名的属性值；rule3）第3条规则表明：将Server对象压入到 Digester对象的内部栈中，并与栈中的下一个对象相关联。
digester.push(this);
protected Digester createStopDigester() { //org.apache.catalina.startup.createStopDigester().
// Initialize the digester
Digester digester = new Digester();
if (debug)
digester.setDebug(999);
// Configure the rules we need for shutting down
digester.addObjectCreate("Server",
"org.apache.catalina.core.StandardServer",
"className");
digester.addSetProperties("Server");
digester.addSetNext("Server",
"setServer",
"org.apache.catalina.Server");
return (digester);
}public final class Bootstrap {
private static int debug = 0;
public static void main(String args[]) {
// Set the debug flag appropriately
for (int i = 0; i < args.length; i++) {
if ("-debug".equals(args[i]))
debug = 1;
}
// Configure catalina.base from catalina.home if not yet set
if (System.getProperty("catalina.base") == null)
System.setProperty("catalina.base", getCatalinaHome());
// Construct the class loaders we will need
ClassLoader commonLoader = null;
ClassLoader catalinaLoader = null;
ClassLoader sharedLoader = null;
try {
File unpacked[] = new File[1];
File packed[] = new File[1];
File packed2[] = new File[2];
ClassLoaderFactory.setDebug(debug);
unpacked[0] = new File(getCatalinaHome(),
"common" + File.separator + "classes");
packed2[0] = new File(getCatalinaHome(),
"common" + File.separator + "endorsed");
packed2[1] = new File(getCatalinaHome(),
"common" + File.separator + "lib");
commonLoader =
ClassLoaderFactory.createClassLoader(unpacked, packed2, null);
unpacked[0] = new File(getCatalinaHome(),
"server" + File.separator + "classes");
packed[0] = new File(getCatalinaHome(),
"server" + File.separator + "lib");
catalinaLoader =
ClassLoaderFactory.createClassLoader(unpacked, packed,
commonLoader);
unpacked[0] = new File(getCatalinaBase(),
"shared" + File.separator + "classes");
packed[0] = new File(getCatalinaBase(),
"shared" + File.separator + "lib");
sharedLoader =
ClassLoaderFactory.createClassLoader(unpacked, packed,
commonLoader);
} catch (Throwable t) {
log("Class loader creation threw exception", t);
System.exit(1);
}
Thread.currentThread().setContextClassLoader(catalinaLoader);
// Load our startup class and call its process() method
try {
SecurityClassLoad.securityClassLoad(catalinaLoader);
// Instantiate a startup class instance
if (debug >= 1)
log("Loading startup class");
Class startupClass =
catalinaLoader.loadClass
("org.apache.catalina.startup.Catalina");
Object startupInstance = startupClass.newInstance();
// Set the shared extensions class loader
if (debug >= 1)
log("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);
method.invoke(startupInstance, paramValues);
// Call the process() method
if (debug >= 1)
log("Calling startup class process() method");
methodName = "process";
paramTypes = new Class[1];
paramTypes[0] = args.getClass();
paramValues = new Object[1];
paramValues[0] = args;
method =
startupInstance.getClass().getMethod(methodName, paramTypes);
method.invoke(startupInstance, paramValues);
} catch (Exception e) {
System.out.println("Exception during startup processing");
e.printStackTrace(System.out);
System.exit(2);
}
}
private static String getCatalinaHome() {
return System.getProperty("catalina.home",
System.getProperty("user.dir"));
}
private static String getCatalinaBase() {
return System.getProperty("catalina.base", getCatalinaHome());
}
private static void log(String message) {
System.out.print("Bootstrap: ");
System.out.println(message);
}
private static void log(String message, Throwable exception) {
log(message);
exception.printStackTrace(System.out);
}
}A1）Bootstrap类有4个静态方法：两个log()方法，getCatalinaHome()方法 和 getCatalinaBase()方法；A2）getCatalinaHome()方法：其基本含义是，如果先前没有设置过catalina.home 属性的值，它就返回 user.dir属性的值；A3） getCatalinaBase()方法：基本含义是，如果catalina.base属性的值为空，则返回 catalina.home属性的值；A4）Bootstrap.main()方法中还会为不同目的而创建3个类载入器；使用多个类载入器的目的是为了防止应用程序中的类（包括servlet类和web 应用程序中的其他辅助类）使用 WEB-INF/classes目录 和 WEB-INF/lib 目录之外的类。部署到 %CATALINA_HOME%/common/lib 目录下的那个 JAR 文件的类文件是可以使用的；（干货——Bootstrap.main()方法中还会为不同目的而创建3个类载入器）
// Construct the class loaders we will need ClassLoader commonLoader = null; ClassLoader catalinaLoader = null; ClassLoader sharedLoader = null;
try {
File unpacked[] = new File[1];
File packed[] = new File[1];
File packed2[] = new File[2];
ClassLoaderFactory.setDebug(debug);
unpacked[0] = new File(getCatalinaHome(),
"common" + File.separator + "classes");
packed2[0] = new File(getCatalinaHome(),
"common" + File.separator + "endorsed");
packed2[1] = new File(getCatalinaHome(),
"common" + File.separator + "lib");
commonLoader =
ClassLoaderFactory.createClassLoader(unpacked, packed2, null);unpacked[0] = new File(getCatalinaHome(),
"server" + File.separator + "classes");
packed[0] = new File(getCatalinaHome(),
"server" + File.separator + "lib");
catalinaLoader =
ClassLoaderFactory.createClassLoader(unpacked, packed,
commonLoader);unpacked[0] = new File(getCatalinaBase(),
"shared" + File.separator + "classes");
packed[0] = new File(getCatalinaBase(),
"shared" + File.separator + "lib");
sharedLoader =
ClassLoaderFactory.createClassLoader(unpacked, packed,
commonLoader);
} catch (Throwable t) {
log("Class loader creation threw exception", t);
System.exit(1);
}public static ClassLoader createClassLoader(File unpacked[],
File packed[],
ClassLoader parent)
throws Exception { //org.apache.catalina.startup.ClassLoaderFactory.createClassLoader().
if (debug >= 1)
log("Creating new class loader");
// Construct the "class path" for this class loader
ArrayList list = new ArrayList();
// Add unpacked directories
if (unpacked != null) {
for (int i = 0; i < unpacked.length; i++) {
File file = unpacked[i];
if (!file.isDirectory() || !file.exists() || !file.canRead())
continue;
if (debug >= 1)
log(" Including directory " + file.getAbsolutePath());
URL url = new URL("file", null,
file.getCanonicalPath() + File.separator);
list.add(url.toString());
}
}
// Add packed directory JAR files
if (packed != null) {
for (int i = 0; i < packed.length; i++) {
File directory = packed[i];
if (!directory.isDirectory() || !directory.exists() ||
!directory.canRead())
continue;
String filenames[] = directory.list();
for (int j = 0; j < filenames.length; j++) {
String filename = filenames[j].toLowerCase();
if (!filename.endsWith(".jar"))
continue;
File file = new File(directory, filenames[j]);
if (debug >= 1)
log(" Including jar file " + file.getAbsolutePath());
URL url = new URL("file", null,
file.getCanonicalPath());
list.add(url.toString());
}
}
}
// Construct the class loader itself
String array[] = (String[]) list.toArray(new String[list.size()]);
StandardClassLoader classLoader = null;
if (parent == null)
classLoader = new StandardClassLoader(array);
else
classLoader = new StandardClassLoader(array, parent);
classLoader.setDelegate(true);
return (classLoader);
}A1）在tomcat中，每个 web 应用程序中与 Context容器相关联的每个类载入器的父类载入器都是sharedLoader 类载入器；A2）sharedLoader类载入器并不能访问 Catalina的内部类，或 CLASSPATH 环境变量指定的类路径中的类；
Class startupClass =
catalinaLoader.loadClass
("org.apache.catalina.startup.Catalina");
Object startupInstance = startupClass.newInstance(); // Set the shared extensions class loader
if (debug >= 1)
log("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);
method.invoke(startupInstance, paramValues); // Call the process() method
if (debug >= 1)
log("Calling startup class process() method");
methodName = "process";
paramTypes = new Class[1];
paramTypes[0] = args.getClass();
paramValues = new Object[1];
paramValues[0] = args;
method =
startupInstance.getClass().getMethod(methodName, paramTypes);
method.invoke(startupInstance, paramValues);A1）首先，批处理文件的后缀名必须是 “.bat”；A2）DOS 目录及环境变量是区分大小写的；
c1）rem： 该命令用于注释。解释器将不会执行以rem 命令开始的行；c2）pause：该命令用于暂停正在执行的批处理文件，并提示用户按某个键，然后程序会继续运行；c3）echo：该命令用于在dos 控制台上显示一段文本。例如，下面的命令将在控制台上输出“hello world”，然后暂停程序。之所以暂停程序是为了能够使控制台将输出的文本显示出来；echo hello world pause
c3.1）如果想要显示环境变量的值，需要在其的前后添加 %%；如，下面的目录将输出变量myVar的值： echo %myVar%c3.2）如果想要输出操作系统的名字，可以使用如下的命令： echo %OS%
看个荔枝）下面的set命令创建了一个名为 “usernmae”的环境变量，其值为“tang”，并输出到console：c4）echo off：使用echo off 命令可以防止将批处理文件中的具体命令输出，而只会输出执行结果。但是，“echo off”命令本身还是会显示出来。如果想要将 “echo off”也隐藏起来，需要使用 @echo off 命令；c5）@echo off：该命令与 echo off 命令类似，但是他会连 echo off 命令也隐藏起来；c6）set：用来设置用户定义或命名的环境变量。在批处理文件中设置的环境变量是临时存储在内存中的，在批处理文件执行完成后就会销毁；
set username=tang echo %username% pause
c7）label：使用冒号设置一个标签。然后可以将标签传递给goto命令，这样程序就会跳转到标签指定的位置。下面的语句定义了一个end的标签：":end"；c8）goto：goto命令强制批处理文件跳转到指定标签所在的位置继续执行
echo start goto end echo i am a student; :end echo end pause
c9）if：if用来测试条件测试，有3种用法（func）：（干货——if命令用来测试条件测试，有3种用法）if variable==value nextCommandfunc1）测试变量的值；set myVar=3if %myVar%==3 echo Correctfunc2）测试文件是否存在；if exist c:\temp\myFile.txt goto start；func3）测试错误值；set myVar=3if not %myVar%==3 echo Correct
c10）not：not关键字用来对一条语句取反；c11）exist：当测试文件是否存在时，会使用到 if 和 exist命令；c12）接收参数：可以给批处理文件传递参数，并使用%1 引用第1个参数，%2 引用第2个参数，以此类推；
c12.1）echo %1：将在console 输出 第1个参数的值；（如果批处理文件的名字是 test.bat，并使用 “test hello” 命令来调用它，那么将会在console中输出 “hello”）；
echo off if %1==start goto start if %1==stop goto stop go invalid :start echo start go end :stop echo stop goto end :invalid echo invalide :end
if "%1"=="" echo no parameter or if ""%1""=="""" echo no parameter
c13）shift：shift命令用来将参数向后移动一位，即将%2的值复制给%1，%3的值复制给%2，以此类推；例如，下面的代码使用一条shift命令：echo off shift echo %1 echo %2如果在运行批处理文件时，附加了3个参数a，b和c，那么上面的命令会有如下输出： b c 移动之后，要使用 %0 来应用第1个参数，而现在最后一个参数已经失效了；c14）call：该命令用来调用另一条命令；c15）setLocal：在批处理文件中使用 setLocal对环境变量的修改只在当前批处理脚本中有效。当遇到endLocal 命令后，在批处理文件的末尾修改的环境变量的值会恢复成原来的值；c16）start：打开一个新的Windows控制台，并可以为这个新的控制台指定一个名字，如： start "title" ；此外，在 title后面，还有传入一条将要在新的控制台中执行的目录，如下所示： start "title" commandName；
c1）debug：在调试器中启动 Catalina；c2）debug -security；在使用安全管理器的case下调试 Catalina；c3）embedded：以嵌入模式启动Catalina；c4）jpda start：在 JPDA调试器下启动 Catalina；c5）run：在当前窗口中启动 Catalina；r6）run -security：在当前窗口中，通过安全管理器启动 Catalina；r7）start：在新窗口中启动 Catalina；r8）start -security：在新窗口中通过安全管理器启动 Catalina；r9）stop：关闭Catalina；
c1）注释：shell脚本使用 # 符号来表示注释内容；c2）clear：使用该命令来清空屏幕；c3）exit：该命令可以用来退出当前shell 脚本的执行；一般case下，exit后面都会附加一个退出状态，其中0 表示shell脚本正常执行完成，非0值表示shell异常退出；如果因为程序运行中的某种异常而想退出，使用如下命令：exit 1；（干货——exit后面都会附加一个退出状态，其中0 表示shell脚本正常执行完成，非0值表示shell异常退出）c4）echo：该命令可以向屏幕输出一个字符串：echo hello world；c5）调用函数：可以使用句点(.)来调用一个函数，或执行另一个shell 脚本；c6）系统变量与用于自定义变量：变量名必须以字母，数字或下划线开头，使用等号就可以定义一个变量；如下面的命令定义了一个名为 myVar 的变量，其值为 Tootsie：myVar=Toosie；
A1）等号的前后一定不能有空格。此外，shell 脚本对变量名是区分大小写的 ；A2）若想定义一个值为NULL的变量，可使用空字符串为其赋值，或在等号右边留空即可：myVar= myVar=""A3）若想要获取变量的值，需要在变量前面加上美元符号（$）：echo $myVarA4）Unix/Linux 提供了一些系统变量供用户使用；如，变量HOME 保存了当前用户的主目录，变量PWD 保存了用户当前所在的目录，变量PATH 保存了将会在哪些地方查找要执行的命令等；
c7）expr： 可以使用该命令来计算一个表达式的值。表达式必须以反引号引用；如下面的shell 脚本计算一个数学表达式：sum=`expr 100+200` echo $sum
c7.1）脚本:echo `expr 200+300` 会输出500；c7.2）特殊表达式`uname`会得到操作系统的名称：echo `uname` 会输出操作系统名称（Linux或Unix）；c7.3）特殊表达式 `dirname filePath` 会返回指定文件所在的目录。如，命令 `dirname /home/user1/test.sh` 会返回“home/user1”；
c8）访问参数：如同向函数中传入参数一样，也可以向shell脚本传入参数，并使用 $1 来引用第1个参数，$2引用第2个参数，以此类推；$# 会返回参数的格式，$@会返回所有的参数；c9）shift：这条命令会将参数向后移动一位，$1的值改为 $2， $2的值改为$3， 以此类推；
看个荔枝）如下面的shell脚本，若传入的第1个参数是 “start”，运行下面的脚本，会输出“start”；如果传入的第1个参数是 “stop”，则输出“stop”；c10）if...then...[else...] fi：if 语句用来测试条件，并执行相应的命令列表。它的语法格式如下：if condition then list of commands [else list of commands ] fiAttention）也可以使用 “elif”来代替“else if”；
Attention）if [ "$1" = "start" ]; then echo start fi if [ "$1" = "end" ]; then echo end fi
看个荔枝）A1）判断条件在 “[” 后面必须有一个空格， 在“]”前面也必须有一个空格；A2）将 $1 用双引号引起来可以防止解释器在发现调用脚本时没有使用参数而抛出异常；A3）$0：表示的是用来调用该脚本的命令。如，使用下面的命令来调用一个名为 test.sh 的脚本：./test.sh；那么，$0 返回 “./test.sh”；下面是一些用来进行条件判断的测试选项：-f file：当存在文件file时，为true； -r file：当文件file可读时，为true； -z string：如果string 是空字符串，为 true； -n string：如果string 不为空字符串，为true； string1 = string2：如果string1 等于string2，为true； string1 != string2：如果string1 不等于 string2，为true；c11）for循环：使用for循环来重复执行一些命令：for {var} in {list} do list of commands done
看个荔枝）for i in 1 2 3 do echo i=$i done output： i1 i2 i3c12）while循环：while [condition] do list of commands done
n=1 while [$n -lt 3] do echo i $n done output： i1 i2
c13）case：case结构表示可以在程序中执行一些选择过程。其语法格式如下所示：case $variable-name in pattern1) list of commands ;; pattern2) list of commands ;; *) list of commands ;; esac
case "`uname`" in
CYGWIN*)echo cygwin;;
OS400*)echo os400;;
LINUX*)echo linux;;
*)echo os not recognized;;
esacc14）输出重定向（review）：使用 “>”将输出重定向到一个文件；（echo hello > myFile.txt）；这会创建一个 myFile.txt的文件，并将 hello 写入到其中，不会向屏幕上输出文字；
S1）"1>&2"：会把标准输出上的错误消息重定向到标准错误中；S1）"2>&1"：会把标准错误中的信息重新向到 标准输出中；
c15）条件执行：可以使用命令或条件来决定是否执行另一条命令。在这种 case下， 可以使用 && 或 || ，如下所示：
c15.1）command1 && command2：如果command1返回的退出状态是0，那么会执行command2；（0表true，非0表false）c15.2）command1 || command2：如果command1返回的退出状态是非0，那么会执行command2；（0表true，非0表false）c15.3）command1 && command2 || command3：如果command1返回的退出状态是非0，那么会执行command2；否则，执行command3；（0表true，非0表false）；
p1）debug：在调试器中启动catalina；（在OS400系统上不可用）p2）debug -security：通过安全管理器调试catalina；（在OS400系统上不可用）p3）embedded：以嵌入模式启动 Catalina；p4）jpda start：在JPDA 调试器下启动 Catalina；p5）run：在当前窗口中启动 Catalina；p6）run -security：在安全管理器下，使用当前窗口启动 catalina；p7）start：使用一个新窗口启动 catalina；p8）start -security：在安全管理器下，使用一个新窗口启动 catalina；p9）stop：关闭 catalina；
标签：
原文地址：http://blog.csdn.net/pacosonswjtu/article/details/51510996
