求助：如何用java检查windows下的服务进程状态？

kyang

如何用java检查windows下的服务进程状态？

sakulagi

使用JNI调用Win32 API

kyang

有没有例程？Thanks

大隐无名

1. 
   
2. //  Exam38.cpp
   
3. //  12/29/2000  (rk)
   
4. //  Modified: 6/16/2003  (rk)
   
5. //  Test the routine FIND_PROC_BY_NAME to find a running process
   
6. 
   
7. #include <windows.h>;
   
8. #include <tlhelp32.h>;
   
9. #include <iostream.h>;
   
10. 
    
11. int FIND_PROC_BY_NAME(const char *);
    
12. 
    
13. int main(int argc, char *argv[])
    
14. {
    
15. //  Check whether a process is currently running, or not
    
16.     char szName[100]="notepad.exe";   // Name of process to find
    
17.         int iRes;
    
18. 
    
19.         iRes=FIND_PROC_BY_NAME(szName);
    
20. 
    
21.     // Note: iRes=0 means process not found, =1 means yes, it is found in memory
    
22.         cout << "Result code=" << iRes << endl;
    
23.         return 0;
    
24. }
    
25. 
    
26. int FIND_PROC_BY_NAME(const char *szToFind)
    
27. // Created: 12/29/2000  (RK)
    
28. // Last modified: 6/16/2003  (RK)
    
29. // Please report any problems or bugs to kochhar@physiology.wisc.edu
    
30. // The latest version of this routine can be found at:
    
31. //     http://www.neurophys.wisc.edu/ravi/software/killproc/
    
32. // Check whether the process "szToFind" is currently running in memory
    
33. // This works for Win/95/98/ME and also Win/NT/2000/XP
    
34. // The process name is case-insensitive, i.e. "notepad.exe" and "NOTEPAD.EXE"
    
35. // will both work (for szToFind)
    
36. // Return codes are as follows:
    
37. //   0   = Process was not found
    
38. //   1   = Process was found
    
39. //   605 = Unable to search for process
    
40. //   606 = Unable to identify system type
    
41. //   607 = Unsupported OS
    
42. //   632 = Process name is invalid
    
43. // Change history:
    
44. //  3/10/2002   - Fixed memory leak in some cases (hSnapShot and
    
45. //                and hSnapShotm were not being closed sometimes)
    
46. //  6/13/2003   - Removed iFound (was not being used, as pointed out
    
47. //                by John Emmas)
    
48. {
    
49.         BOOL bResult,bResultm;
    
50.         DWORD aiPID[1000],iCb=1000,iNumProc,iV2000=0;
    
51.         DWORD iCbneeded,i;
    
52.         char szName[MAX_PATH],szToFindUpper[MAX_PATH];
    
53.         HANDLE hProc,hSnapShot,hSnapShotm;
    
54.         OSVERSIONINFO osvi;
    
55.     HINSTANCE hInstLib;
    
56.         int iLen,iLenP,indx;
    
57.     HMODULE hMod;
    
58.         PROCESSENTRY32 procentry;      
    
59.         MODULEENTRY32 modentry;
    
60. 
    
61.         // PSAPI Function Pointers.
    
62.      BOOL (WINAPI *lpfEnumProcesses)( DWORD *, DWORD cb, DWORD * );
    
63.      BOOL (WINAPI *lpfEnumProcessModules)( HANDLE, HMODULE *,
    
64.         DWORD, LPDWORD );
    
65.      DWORD (WINAPI *lpfGetModuleBaseName)( HANDLE, HMODULE,
    
66.         LPTSTR, DWORD );
    
67. 
    
68.       // ToolHelp Function Pointers.
    
69.       HANDLE (WINAPI *lpfCreateToolhelp32Snapshot)(DWORD,DWORD) ;
    
70.       BOOL (WINAPI *lpfProcess32First)(HANDLE,LPPROCESSENTRY32) ;
    
71.       BOOL (WINAPI *lpfProcess32Next)(HANDLE,LPPROCESSENTRY32) ;
    
72.       BOOL (WINAPI *lpfModule32First)(HANDLE,LPMODULEENTRY32) ;
    
73.       BOOL (WINAPI *lpfModule32Next)(HANDLE,LPMODULEENTRY32) ;
    
74. 
    
75.         // Transfer Process name into "szToFindUpper" and
    
76.         // convert it to upper case
    
77.         iLenP=strlen(szToFind);
    
78.         if(iLenP<1 || iLenP>;MAX_PATH) return 632;
    
79.         for(indx=0;indx<iLenP;indx++)
    
80.                 szToFindUpper[indx]=toupper(szToFind[indx]);
    
81.         szToFindUpper[iLenP]=0;
    
82. 
    
83.         // First check what version of Windows we're in
    
84.         osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
    
85.     bResult=GetVersionEx(&osvi);
    
86.         if(!bResult)     // Unable to identify system version
    
87.             return 606;
    
88. 
    
89.         // At Present we only support Win/NT/2000 or Win/9x/ME
    
90.         if((osvi.dwPlatformId != VER_PLATFORM_WIN32_NT) &&
    
91.                 (osvi.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS))
    
92.                 return 607;
    
93. 
    
94.     if(osvi.dwPlatformId==VER_PLATFORM_WIN32_NT)
    
95.         {
    
96.                 // Win/NT or 2000 or XP
    
97. 
    
98.          // Load library and get the procedures explicitly. We do
    
99.          // this so that we don't have to worry about modules using
    
100.          // this code failing to load under Windows 95, because
     
101.          // it can't resolve references to the PSAPI.DLL.
     
102.          hInstLib = LoadLibraryA("PSAPI.DLL");
     
103.          if(hInstLib == NULL)
     
104.             return 605;
     
105. 
     
106.          // Get procedure addresses.
     
107.          lpfEnumProcesses = (BOOL(WINAPI *)(DWORD *,DWORD,DWORD*))
     
108.             GetProcAddress( hInstLib, "EnumProcesses" ) ;
     
109.          lpfEnumProcessModules = (BOOL(WINAPI *)(HANDLE, HMODULE *,
     
110.             DWORD, LPDWORD)) GetProcAddress( hInstLib,
     
111.             "EnumProcessModules" ) ;
     
112.          lpfGetModuleBaseName =(DWORD (WINAPI *)(HANDLE, HMODULE,
     
113.             LPTSTR, DWORD )) GetProcAddress( hInstLib,
     
114.             "GetModuleBaseNameA" ) ;
     
115. 
     
116.          if( lpfEnumProcesses == NULL ||
     
117.             lpfEnumProcessModules == NULL ||
     
118.             lpfGetModuleBaseName == NULL)
     
119.             {
     
120.                FreeLibrary(hInstLib);
     
121.                return 605;
     
122.             }
     
123.                  
     
124.                 bResult=lpfEnumProcesses(aiPID,iCb,&iCbneeded);
     
125.                 if(!bResult)
     
126.                 {
     
127.                         // Unable to get process list, EnumProcesses failed
     
128.             FreeLibrary(hInstLib);
     
129.                         return 605;
     
130.                 }
     
131. 
     
132.                 // How many processes are there?
     
133.                 iNumProc=iCbneeded/sizeof(DWORD);
     
134. 
     
135.                 // Get and match the name of each process
     
136.                 for(i=0;i<iNumProc;i++)
     
137.                 {
     
138.                         // Get the (module) name for this process
     
139. 
     
140.                 strcpy(szName,"Unknown");
     
141.                         // First, get a handle to the process
     
142.                 hProc=OpenProcess(PROCESS_QUERY_INFORMATION|PROCESS_VM_READ,FALSE,
     
143.                                 aiPID[i]);
     
144.                 // Now, get the process name
     
145.                 if(hProc)
     
146.                         {
     
147.                if(lpfEnumProcessModules(hProc,&hMod,sizeof(hMod),&iCbneeded) )
     
148.                            {
     
149.                   iLen=lpfGetModuleBaseName(hProc,hMod,szName,MAX_PATH);
     
150.                            }
     
151.                         }
     
152.                 CloseHandle(hProc);
     
153.                         // Match regardless of lower or upper case
     
154.                         if(strcmp(_strupr(szName),szToFindUpper)==0)
     
155.                         {
     
156.                                 // Process found
     
157.                                 FreeLibrary(hInstLib);
     
158.                                 return 1;
     
159.                         }
     
160.                 }
     
161.         }
     
162. 
     
163.         if(osvi.dwPlatformId==VER_PLATFORM_WIN32_WINDOWS)
     
164.         {
     
165.                 // Win/95 or 98 or ME
     
166.                        
     
167.                 hInstLib = LoadLibraryA("Kernel32.DLL");
     
168.                 if( hInstLib == NULL )
     
169.                         return FALSE ;
     
170. 
     
171.                 // Get procedure addresses.
     
172.                 // We are linking to these functions of Kernel32
     
173.                 // explicitly, because otherwise a module using
     
174.                 // this code would fail to load under Windows NT,
     
175.                 // which does not have the Toolhelp32
     
176.                 // functions in the Kernel 32.
     
177.                 lpfCreateToolhelp32Snapshot=
     
178.                         (HANDLE(WINAPI *)(DWORD,DWORD))
     
179.                         GetProcAddress( hInstLib,
     
180.                         "CreateToolhelp32Snapshot" ) ;
     
181.                 lpfProcess32First=
     
182.                         (BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))
     
183.                         GetProcAddress( hInstLib, "Process32First" ) ;
     
184.                 lpfProcess32Next=
     
185.                         (BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))
     
186.                         GetProcAddress( hInstLib, "Process32Next" ) ;
     
187.                 lpfModule32First=
     
188.                         (BOOL(WINAPI *)(HANDLE,LPMODULEENTRY32))
     
189.                         GetProcAddress( hInstLib, "Module32First" ) ;
     
190.                 lpfModule32Next=
     
191.                         (BOOL(WINAPI *)(HANDLE,LPMODULEENTRY32))
     
192.                         GetProcAddress( hInstLib, "Module32Next" ) ;
     
193.                 if( lpfProcess32Next == NULL ||
     
194.                         lpfProcess32First == NULL ||
     
195.                     lpfModule32Next == NULL ||
     
196.                         lpfModule32First == NULL ||
     
197.                         lpfCreateToolhelp32Snapshot == NULL )
     
198.                 {
     
199.                         FreeLibrary(hInstLib);
     
200.                         return 605;
     
201.                 }
     
202.                        
     
203.                 // The Process32.. and Module32.. routines return names in all uppercase
     
204. 
     
205.                 // Get a handle to a Toolhelp snapshot of all the systems processes.
     
206. 
     
207.                 hSnapShot = lpfCreateToolhelp32Snapshot(
     
208.                         TH32CS_SNAPPROCESS, 0 ) ;
     
209.                 if( hSnapShot == INVALID_HANDLE_VALUE )
     
210.                 {
     
211.                         FreeLibrary(hInstLib);
     
212.                         return 605;
     
213.                 }
     
214.                
     
215.         // Get the first process' information.
     
216.         procentry.dwSize = sizeof(PROCESSENTRY32);
     
217.         bResult=lpfProcess32First(hSnapShot,&procentry);
     
218. 
     
219.         // While there are processes, keep looping and checking.
     
220.         while(bResult)
     
221.         {
     
222.                     // Get a handle to a Toolhelp snapshot of this process.
     
223.                     hSnapShotm = lpfCreateToolhelp32Snapshot(
     
224.                             TH32CS_SNAPMODULE, procentry.th32ProcessID) ;
     
225.                     if( hSnapShotm == INVALID_HANDLE_VALUE )
     
226.                         {
     
227.                                 CloseHandle(hSnapShot);
     
228.                             FreeLibrary(hInstLib);
     
229.                             return 605;
     
230.                         }
     
231.                         // Get the module list for this process
     
232.                         modentry.dwSize=sizeof(MODULEENTRY32);
     
233.                         bResultm=lpfModule32First(hSnapShotm,&modentry);
     
234. 
     
235.                         // While there are modules, keep looping and checking
     
236.                         while(bResultm)
     
237.                         {
     
238.                         if(strcmp(modentry.szModule,szToFindUpper)==0)
     
239.                                 {
     
240.                                         // Process found
     
241.                                         CloseHandle(hSnapShotm);
     
242.                                         CloseHandle(hSnapShot);
     
243.                                         FreeLibrary(hInstLib);
     
244.                                         return 1;
     
245.                                 }
     
246.                                 else
     
247.                                 {  // Look for next modules for this process
     
248.                                         modentry.dwSize=sizeof(MODULEENTRY32);
     
249.                                         bResultm=lpfModule32Next(hSnapShotm,&modentry);
     
250.                                 }
     
251.                         }
     
252. 
     
253.                         //Keep looking
     
254.                         CloseHandle(hSnapShotm);
     
255.             procentry.dwSize = sizeof(PROCESSENTRY32);
     
256.             bResult = lpfProcess32Next(hSnapShot,&procentry);
     
257.         }
     
258.                 CloseHandle(hSnapShot);
     
259.         }
     
260.         FreeLibrary(hInstLib);
     
261.         return 0;
     
262. }
     

复制代码

这有一个查找进程的例子。kill进程和得到进程状态的函数可以查一下msdn。
用JNI调用一下就可以了。

sakulagi

http://java.sun.com/developer/codesamples/jni.html
这个是JNI的一些例子