论如何一句命令实现单tomcat多应用的部署

因为工作需要实现单个tomcat部署多个应用，其中每个应用可自定义单独的端口，配置路径参数，war包存放路径，可以独立的启动停止。于是网上学习了一番后自己写了个脚本来完成，嘿嘿，顺带记录一下作为本月份的输出。

tomcat下载地址：archive.apache.org/dist/tomcat...

jdk地址：www.oracle.com/java/techno...

standard.jar：mvnrepository.com/artifact/ta...

jstl.jar：mvnrepository.com/artifact/ja...

我这边用的版本是：tomcat-8.5.100、jdk1.8.0_261

tomcat配置

上传和解压，理论上会解压出apache-tomcat-8.5.100、jdk1.8.0_261两个文件夹

cd ~

#上传包
put apache-tomcat-8.5.100.tar.gz
put jdk-8u261-linux-x64.tar.gz

#解压
tar -zxvf apache-tomcat-8.5.100.tar.gz
tar -zxvf jdk-8u261-linux-x64.tar.gz

配置tomcat使用的JDK，在tomcat的bin目录下面的catalina.sh，在文件前几行增加JDK配置

# 具体路径记得替换下哦
vim ~/apache-tomcat-8.5.100/bin/catalina.sh

# 要增加的配置，记得pwd确认下自己的路径，/home/test部分按照自己的配置
export JAVA_HOME=/home/test/jdk1.8.0_261
export JRE_HOME=/home/test/jdk1.8.0_261/jre

cache配置大点，要启动多个应用来着

vim ~/apache-tomcat-8.5.100/conf/context.xml

# <Context>标签内添加如下内容
<Resources cachingAllowed="true" cacheMaxSize="100000" />

taglib标签库要用到的

cd ~/apache-tomcat-8.5.100/lib
put standard.jars
put jstl.jar

部署脚本

#!/bin/sh

echo "deploy start"
cd ~

# 判断入参个数
if [ $# -lt 7 ]; then
    echo "please input true value like:"
    echo "tomcat_path project_name war_path war_name server_port connector_port connector_redirect_port app_path"
    exit 1
fi

now_path=`pwd`
tomcat_path=$1
project_name=$2
war_path=$3
war_name=$4
server_port=$5
connector_port=$6
connector_redirect_port=$7
if [ -n "$8" ]; then
    app_path=$8
else
	app_path=""
fi

outPrint(){
	echo "now_path is ${now_path}"
	echo "tomcat_path is ${tomcat_path}"
	echo "project_name is ${project_name}"
	echo "war_path is ${war_path}"
	echo "war_name is ${war_name}"
	echo "server_port is ${server_port}"
	echo "connector_port is ${connector_port}"
	echo "connector_redirect_port is ${connector_redirect_port}"
	echo "app_path is ${app_path}"						
}

initFile() {
	echo "mkdir and touch start"
	mkdir ${project_name}
	cp -r ${tomcat_path}/conf ${project_name}/conf
	cp -r ${tomcat_path}/logs ${project_name}/logs
	cp -r ${tomcat_path}/temp ${project_name}/temp
	cp -r ${tomcat_path}/work ${project_name}/work
	mkdir ${project_name}/webapps
	mkdir -p ${project_name}/conf/Catalina/localhost
	touch ${project_name}/conf/Catalina/localhost/${war_name}.xml
	touch ${project_name}/tomcat.sh
	chmod +x ${project_name}/tomcat.sh
	cp  ${project_name}/conf/server.xml ${project_name}/conf/server.xml.orgin
	echo "mkdir and touch end"
}


unzipWar() {
	target_war=${war_path}/${war_name}.war
    if [ ! -f "${target_war}" ]; then
        echo "war not exist: ${target_war}"
        exit 1
    fi
    target_dir=${project_name}/webapps/${war_name}
    unzip -q ${target_war} -d $target_dir
}

# init ${war_name}.xml
initWarXml(){
	echo "write ${project_name}/conf/Catalina/localhost/${war_name}.xml start"
	cat <<-EOF > "${project_name}/conf/Catalina/localhost/${war_name}.xml"
		<?xml version="1.0" encoding="UTF-8"?>
		<Context docBase="${war_path}/${war_name}.war" reloadable="true">
		</Context>
	EOF
	echo "write ${war_name}.xml end"
}


# init server.xml
initServerXml(){
	echo "write ${project_name}/conf/server.xml start"
	cat <<-EOF > "${project_name}/conf/server.xml"
		<?xml version="1.0" encoding="UTF-8"?>
		<Server port="${server_port}" shutdown="SHUTDOWN">
		  <Listener className="org.apache.catalina.startup.VersionLoggerListener" />
		  <Listener className="org.apache.catalina.core.AprLifecycleListener" SSLEngine="on" />
		  <Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" />
		  <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />
		  <Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />
		  <GlobalNamingResources>
		    <Resource name="UserDatabase" auth="Container"
		              type="org.apache.catalina.UserDatabase"
		              description="User database that can be updated and saved"
		              factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
		              pathname="conf/tomcat-users.xml" />
		  </GlobalNamingResources>
		  <Service name="Catalina">
		    <Connector port="${connector_port}" protocol="HTTP/1.1"
		               connectionTimeout="20000"
		               redirectPort="${connector_redirect_port}"
		               maxParameterCount="1000"
		               relaxedPathChars="|{}[],%" relaxedQueryChars="|{}[],%"
		               />
		    <Engine name="Catalina" defaultHost="localhost">
		      <Realm className="org.apache.catalina.realm.LockOutRealm">
		        <Realm className="org.apache.catalina.realm.UserDatabaseRealm"
		               resourceName="UserDatabase"/>
		      </Realm>
		      <Host name="localhost"  appBase="webapps"
		            unpackWARs="true" autoDeploy="true">
		        <Context reloadable="true" debug="0" docBase="${now_path}/${project_name}/webapps/${war_name}" path="${app_path}"/>
		        <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
		               prefix="localhost_access_log" suffix=".txt"
		               pattern="%h %l %u %t &quot;%r&quot; %s %b" />
		      </Host>
		    </Engine>
		  </Service>
		</Server>
	EOF
	echo "write server.xml end"
}

# init tomcat.sh
initTomcatSh(){
	echo "write ${project_name}/tomcat.sh start"
	cat <<-EOF > "${project_name}/tomcat.sh"
		#!/bin/sh
		export CATALINA_BASE="\$PWD"
		export CATALINA_HOME="${tomcat_path}"
		JAVA_OPTS="-Dbusi10040 -Dfile.encoding=UTF-8"
		target_war=${war_path}/${war_name}.war
		target_dir=webapps/${war_name}
		export JAVA_OPTS

		echo "CATALINA_BASE=\$CATALINA_BASE"
		echo "CATALINA_HOME=\$CATALINA_HOME"

		start() {
		  echo "Start Tomcat"
		  \$CATALINA_HOME/bin/startup.sh
		}

		unzipWar() {
			rm -rf webapps
			mkdir webapps
		    if [ ! -f "\${target_war}" ]; then
		        echo "war not exist: \${target_war}"
		        exit 1
		    fi
		    unzip -q \${target_war} -d \$target_dir
		}

		stop() {
		  echo "Stop Tomcat"
		  kill \`ps -ef|grep ${project_name}|grep -v grep|awk '{print \$2}'\`
		}

		case "\$1" in 
		start)
		  start
		;;
		stop)
		  stop
		;;
		restart)
		  stop
		  sleep 5
		  start
		;;
		deployment)
		  stop
		  unzipWar
		  sleep 5
		  start
		;;
		*)
		echo $"Usage: \$0 {start|stop|restart|deployment}"
		exit 1
		;;
		esac
	EOF
	echo "write tomcat.sh end"	
}

outPrint
initFile
unzipWar
initWarXml
initServerXml
initTomcatSh

使用方式：

cd ~
put new.sh
chmod +x new.sh

./new.sh  tomcat_path project_name war_path war_name server_port connector_port connector_redirect_port app_path project_fix

先来解释一下参数的意思（后面要是使用到我就加{}表示）

1. tomcat_path：必填，tomcat的路径（例如：$PWD/apache-tomcat-8.5.100）
2. project_name：必填，应用存放目录的名称，自定义
3. war_path：必填，war包存放位置，自定义
4. war_name：必填，war包名字
5. server_port：必填，可以触发关tomcat的端口，自定义
6. connector_port：必填，这个是应用启动的端口！！！自定义
7. connector_redirect_port：必填，请求的资源需要https连接时候重定向的端口，自定义
8. app_path：选填，这个是路径后缀，tomcat默认是用webapps下面目录名字作为应用访问路径，假设为APP1（war包名字），路径为http://ip:port/APP1，如果此处设置了参数APP2，那么路径变为http://ip:port/APP2，就不用跟随war包名字

应用维护：

cd ~/{project_name}
#  operate_type: start|stop|restart|deployment
./tomcat {operate_type}

应该很好理解，就是启动，停止，重启，部署 单独说下部署，就是替换了war包之后建议使用，不然只用restart可能jar包不更新，但是只是换配置文件呀，或者是换端口之类的操作，不涉及war的就直接restart就行。

解释与例子：

其实到这里就可以结束了哈哈，但是讲一下new.sh脚本吧，我是模块成几个函数：

• outPrint：输出一下输入的参数
• initFile：初始化下应用的目录啊，拷贝一些必要的Tomcat配置过来，比如conf、work，其实logs和temp直接mkdir就行，是空的。比较重要的是在conf/Catalina/localhost路径下面建了个{war_name}.xml，这个里面配置了自定义的war包位置，如果你就把war放webapps里面就不需要
• unzipWar：解压war包到webapps下面
• initWarXml：向initFile新建的{war_name}.xml写入内容，配置下war包位置。
• initServerXml：初始化conf下面的server.xml文件，配置服务端口，还有路径后缀
• initTomcatSh：生成tomcat.sh内容，这里是配置了UTF-8，CATALINA_BASE，CATALINA_HOME

然后来举个例子，有个应用打包了war包是 Test.war，放在~/app，希望存放目录是~/tmc_Test，访问路径是http://ip:8080/home，关闭是8001，转发到8002，new.sh就放在~，那么就这样部署启动：

cd ~
./new.sh "$PWD/apache-tomcat-8.5.100" "tmc_Test" "$PWD/app" "Test" 8001 8080 8002 "home"
cd ~/tmc_Test
./tomcat.sh start