Linux下两种自动启动Tomcat的方法

wangguorui89

有很多办法可以让Tomcat在系统启动的时候自动运行，我这里介绍两种方法，一种简单，另外一种复杂而专业。在介绍这两个方法前你应该先装JDK,Tomcat。Tomcat的安装很简单，下载二进制压缩包 xxx.tar.gz ，用 tar zxvf xxx.tar.gz -C [target]，[target]是安装Tomcat的目录。设置环境变量JDK_HOME和JAVA_HOME都指向JDK的安装目录即可。

    一. 简单的方法

    Tomcat安装目录下的bin目录有两个脚本分别用来启动和停止Tomcat，分别是startup.sh, shutdown.sh，你可以用这两个脚本来手工启动和停止Tomcat服务并进行安装后的测试。

    我们最简单的方法就是通过startup.sh来自动启动Tomcat，编辑/etc/rc.d/rc.local 增加内容(假设JDK目录是/usr/jdk，Tomcat目录是/apache/tomcat)

export JDK_HOME=/usr/jdk
export JAVA_HOME=/usr/jdk
/apache/tomcat/bin/startup.sh


    这样在系统重启后就可以自动启动Tomcat

    二. 复杂而专业的方法

    前面介绍的应该是最简单的让Tomcat自动启动的方法了，但是它有两个不足
    1. 无法指定启动Tomcat服务的用户，会导致Tomcat已超级用户运行，存在重大的安全隐患
    2. 系统关闭的时候无法自动停止Tomcat服务

    在Linux下，Tomcat可以作为一个守护进程来启动以及停止，这个必须借助于项目commons-daemon中的jsvc工具。Tomcat安装完后就带有这个工具的源码{tomcat}/bin/jsvc.tar.gz。按照下列命令安装这个工具：

解压: tar zxvf jsvc.tar.gz
配置: cd jsvc-src
        chmod +x configure
       ./configure --with-java=/usr/jdk
编译: make
检验: ./jsvc -help


    jsvc工具本身带了一个脚本用来启动和停止Tomcat守护进程，但是在试验中发现该脚本无法设置为自动启动，显示的错误信息是：tomcat 服务不支持 chkconfig，因此修改了此脚本，可以从此处下载：tomcat.txt

    修改下载的脚本里面有关路径的信息以及要启动Tomcat的用户(用户必须已存在)，拷贝脚本到/etc/rc.d/init.d目录下的tomcat文件，给该脚本赋予可执行权限(chmod +x tomcat)，你可以使用命令/etc/rc.d/init.d/tomcat start|stop 来验证守护进程是否可以正常启动和停止。

    接下来就是把这个脚本设置成系统启动时自动执行，系统关闭时自动停止，使用如下命令：
    chkconfig --add tomcat

    重新启动系统后可以启动的过程中看到Starting Tomcat ..... [OK]的信息，这样就完成设置过程。（T111）

自由狼-台风

1. #! /bin/sh
   
2. 
   
3. # chkconfig: 35 96 04
   
4. # description: Apache-Tomcat service script.
   
5. 
   
6. # Version:
   
7. #        2008-01-17-01
   
8. # By:
   
9. #        Typhoon.Free.Wolf.
   
10. 
    
11. # Service name.
    
12. SVC_NAME="Apache-Tomcat"
    
13. # Lock file.
    
14. LOCK_FILE="/var/lock/subsys/tfw_tomcat"
    
15. # Installation prefix.
    
16. APP_HOME="/ext/prog/c/Apache/Tomcat"
    
17. # The process name to monitor.
    
18. APP_PROC="java"
    
19. # Authorize user.
    
20. APP_USER="userXXX"
    
21. 
    
22. SLEEP_START=5
    
23. SLEEP_STOP=$SLEEP_START
    
24. 
    
25. # Importing functions.
    
26. flg_func=0
    
27. if [ -f /etc/init.d/functions ] ; then
    
28.         . /etc/init.d/functions
    
29.         flg_func=1
    
30. elif [ -f /etc/rc.d/init.d/functions ] ; then
    
31.         . /etc/rc.d/init.d/functions
    
32.         flg_func=1
    
33. fi
    
34. 
    
35. # Templete.
    
36. # Return:
    
37. #        FLG_PROC_ON means process is there.
    
38. #        FLG_PROC_OFF means process not exists.
    
39. #        Other means error.
    
40. FLG_PROC_ON=1
    
41. FLG_PROC_OFF=0
    
42. probe() {
    
43.         srch_rst=$(ps -A|grep $APP_PROC|awk '{print $4}')
    
44.         for rst in $srch_rst ; do
    
45.                 if [ $APP_PROC = $rst ] ; then
    
46.                         return $FLG_PROC_ON
    
47.                 fi
    
48.         done
    
49.         return $FLG_PROC_OFF
    
50. }
    
51. 
    
52. # Templete.
    
53. #        Shows OK.
    
54. # Return:
    
55. echo_ok() {
    
56.         case $flg_func in
    
57.                 1)
    
58.                         echo_success
    
59.                         echo ""
    
60.                 ;;
    
61.                 *)
    
62.                         echo ""
    
63.                         echo "        [  OK  ]"
    
64.                 ;;
    
65.         esac
    
66. }
    
67. 
    
68. # Templete.
    
69. #        Shows Passed.
    
70. # Return:
    
71. echo_pass() {
    
72.         case $flg_func in
    
73.                 1)
    
74.                         echo_passed
    
75.                         echo ""
    
76.                 ;;
    
77.                 *)
    
78.                         echo ""
    
79.                         echo "        [PASSED]"
    
80.                 ;;
    
81.         esac
    
82. }
    
83. 
    
84. # Templete.
    
85. #        Shows Failed.
    
86. # Return:
    
87. echo_bad() {
    
88.         case $flg_func in
    
89.                 1)
    
90.                         echo_failure
    
91.                         echo ""
    
92.                 ;;
    
93.                 *)
    
94.                         echo ""
    
95.                         echo "        [FAILED]"
    
96.                 ;;
    
97.         esac
    
98. }
    
99. 
    
100. # Templete.
     
101. #        Start section.
     
102. # Return:
     
103. _start() {
     
104.         probe
     
105.         proc=$?
     
106.         echo ""
     
107.         echo "Starting $SVC_NAME..."
     
108. 
     
109.         if (touch $LOCK_FILE) ; then
     
110.                 echo_ok
     
111.         else
     
112.                 echo_bad
     
113.         fi
     
114. }
     
115. 
     
116. start() {
     
117.         probe
     
118.         proc=$?
     
119.         echo ""
     
120.         echo "Starting $SVC_NAME..."
     
121. 
     
122.         if [ $FLG_PROC_OFF = $proc ] ; then
     
123.                 if (su - $APP_USER -c "$APP_HOME/bin/startup.sh") ; then
     
124.                         sleep $SLEEP_START
     
125.                         if (touch $LOCK_FILE) ; then
     
126.                                 echo_ok
     
127.                         else
     
128.                                 echo_pass
     
129.                                 echo ""
     
130.                         fi
     
131.                 else
     
132.                         echo_bad
     
133.                 fi
     
134.         elif [ $FLG_PROC_ON = $proc ] ; then
     
135.                 if (touch $LOCK_FILE) ; then
     
136.                         echo_passed
     
137.                         echo ""
     
138.                 else
     
139.                         echo_bad
     
140.                 fi
     
141.         fi
     
142. }
     
143. 
     
144. # Templete.
     
145. #        Stop section.
     
146. # Return:
     
147. _stop() {
     
148.         probe
     
149.         proc=$?
     
150.         echo ""
     
151.         echo "Stopping $SVC_NAME..."
     
152. 
     
153.         if (rm -Rf $LOCK_FILE) ; then
     
154.                 echo_ok
     
155.         else
     
156.                 echo_bad
     
157.         fi
     
158. }
     
159. 
     
160. stop() {
     
161.         probe
     
162.         proc=$?
     
163.         echo ""
     
164.         echo "Stopping $SVC_NAME..."
     
165. 
     
166.         if [ $FLG_PROC_OFF = $proc ] ; then
     
167.                 if (rm -Rf $LOCK_FILE) ; then
     
168.                         echo_passed
     
169.                         echo ""
     
170.                 else
     
171.                         echo_bad
     
172.                 fi
     
173.         elif [ $FLG_PROC_ON = $proc ] ; then
     
174.                 if (su - $APP_USER -c "$APP_HOME/bin/shutdown.sh") ; then
     
175.                         sleep $SLEEP_STOP
     
176.                         if (rm -Rf $LOCK_FILE) ; then
     
177.                                 echo_ok
     
178.                         else
     
179.                                 echo_pass
     
180.                                 echo ""
     
181.                         fi
     
182.                 else
     
183.                         echo_bad
     
184.                 fi
     
185.         fi
     
186. }
     
187. 
     
188. # Parse command line parameters.
     
189. case $1 in
     
190.         start)
     
191.                 start
     
192.         ;;
     
193.         stop)
     
194.                 stop
     
195.         ;;
     
196.         restart)
     
197.                 stop
     
198.                 start
     
199.         ;;
     
200.         *)
     
201.                 # Print help
     
202.                 echo "Usage: $0 {start|stop|restart}"
     
203.                 exit 1
     
204.         ;;
     
205. esac
     
206. 
     
207. exit 0
     

复制代码