获取网络上下行速度、判断nginx是否运行、检查网络端口是否通、执行ssh连接工具、注解方式分布式锁

快来打我* 2023-01-09 12:38 194阅读 0赞

## 一、获取网络上下行速度 ##

import cn.hutool.core.date.DateUtil;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.*;
    
    public class NetWorkUtil { 
    
    	private static final int SLEEP_TIME = 2 * 1000;
    
    	// 获取网络上行下行速度
    	public static NetworkInfo getNetworkDownUp() { 
    		Properties props = System.getProperties();
    		String os = props.getProperty("os.name").toLowerCase();
    		os = os.startsWith("win") ? "windows" : "linux";
    		Process pro = null;
    		Runtime r = Runtime.getRuntime();
    		BufferedReader input = null;
    		NetworkInfo networkInfo = new NetworkInfo();
    
    		try { 
    			String command = "windows".equals(os) ? "netstat -e" : "ifconfig";
    			pro = r.exec(command);
    			input = new BufferedReader(new InputStreamReader(pro.getInputStream()));
    			long result1[] = readInLine(input, os);
    			Thread.sleep(SLEEP_TIME);
    			pro.destroy();
    			input.close();
    			pro = r.exec(command);
    			input = new BufferedReader(new InputStreamReader(pro.getInputStream()));
    			long result2[] = readInLine(input, os);
                // 上行速率(kB/s)
    			networkInfo.setReceive(formatNumber((result2[0] - result1[0]) / (1024.0 * (SLEEP_TIME / 1000))));
                // 下行速率(kB/s)
    			networkInfo.setSend(formatNumber((result2[1] - result1[1]) / (1024.0 * (SLEEP_TIME / 1000))));
    			// 去绝对值
    			if (networkInfo.getReceive() < 0) { 
    				networkInfo.setReceive(0 - networkInfo.getReceive());
    			}
    			if (networkInfo.getSend() < 0) { 
    				networkInfo.setSend(0 - networkInfo.getSend());
    			}
    		} catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 
    			if (input != null) { 
    				try { 
    					input.close();
    				} catch (IOException e) { 
    					log.error("获取失败：{}",e)
    				}
    			}
    			Optional.ofNullable(pro).ifPresent(p -> p.destroy());
    		}
    		networkInfo.setTime(DateUtil.format(new Date(), "HH:mm:ss"));
    		return networkInfo;
    
    	}
    
    	private static long[] readInLine(BufferedReader input, String osType) { 
    		long arr[] = new long[2];
    		StringTokenizer tokenStat;
    		try { 
                // 获取linux环境下的网口上下行速率
    			if (Objects.equals(osType, "linux")) { 
    				long rx = 0, tx = 0;
    				String line;
    				// 旧
    				// RX packets:4171603 errors:0 dropped:0 overruns:0 frame:0
    				// TX packets:4171603 errors:0 dropped:0 overruns:0 carrier:0
    				// 新
    				// RX packets 228451110 bytes 153707332334 (153.7 GB)
    				// TX packets 169848511 bytes 155937621328 (155.9 GB)
    				while ((line = input.readLine()) != null) { 
    					if (line.indexOf("RX packets") >= 0) { 
    						rx += Long.parseLong(line.split("packets")[1].split("bytes")[0].trim()) * 1024;
    					} else if (line.indexOf("TX packets") >= 0) { 
    						tx += Long.parseLong(line.split("packets")[1].split("bytes")[0].trim()) * 1024;
    					}
    				}
    				arr[0] = rx;
    				arr[1] = tx;
    			} else {  // 获取windows环境下的网口上下行速率
    				input.readLine();
    				input.readLine();
    				input.readLine();
    				input.readLine();
    				tokenStat = new StringTokenizer(input.readLine());
    				tokenStat.nextToken();
    				arr[0] = Long.parseLong(tokenStat.nextToken());
    				arr[1] = Long.parseLong(tokenStat.nextToken());
    			}
    		} catch (Exception e) { 
    			log.error("获取失败：{}",e)
    		}
    		return arr;
    	}
    
    	private static Double formatNumber(double f) { 
    		return Double.parseDouble(new Formatter().format("%.2f", f).toString());
    	}
    
    	public static void main(String[] args) { 
    		String line = " RX packets 0 bytes 0 (0.0 B)";
    		System.out.println(Long.parseLong(line.split("packets")[1].split("bytes")[0].trim()));
    	}
    
    
        static class NetworkInfo { 
    
            Double send;
    
            Double receive;
    
            String time;
    
            public String getTime() { 
                return time;
            }
    
            public void setTime(String time) { 
                this.time = time;
            }
    
            public Double getSend() { 
                return send;
            }
    
            public void setSend(Double send) { 
                this.send = send;
            }
    
            public Double getReceive() { 
                return receive;
            }
    
            public void setReceive(Double receive) { 
                this.receive = receive;
            }
    
        }
    }

import cn.hutool.system.SystemUtil;
    
    public class SystemTool { 
    
    	public static String getSystem() { 
    
    		if (SystemUtil.get(SystemUtil.OS_NAME).toLowerCase().contains("windows")) { 
    			return "Windows";
    		} else if (SystemUtil.get(SystemUtil.OS_NAME).toLowerCase().contains("mac os")) { 
    			return "Mac OS";
    		} else { 
    			return "Linux";
    		}
    
    	}
    
    	public static Boolean isWindows() { 
    		return getSystem().equals("Windows");
    	}
    
    	public static Boolean isMacOS() { 
    		return getSystem().equals("Mac OS");
    	}
    
    	public static Boolean isLinux() { 
    		return getSystem().equals("Linux");
    	}
    
    	public static boolean hasRoot() { 
    		if (SystemTool.isLinux()) { 
    			String user = System.getProperties().getProperty(SystemUtil.USER_NAME);
    			if ("root".equals(user)) { 
    				return true;
    			} else { 
    				return false;
    			}
    		}
    		return true;
    	}
    
    }

## 二、判断nginx是否运行 ##

import cn.hutool.core.util.RuntimeUtil;
    
    public class NginxUtils { 
    
    	/** * 判断nginx是否运行 * * @return */
    	public static boolean isRun() { 
    		boolean isRun = false;
    		if (SystemTool.isWindows()) { 
    			String[] command = {  "tasklist" };
    			String rs = RuntimeUtil.execForStr(command);
    			isRun = rs.toLowerCase().contains("nginx.exe");
    		} else { 
    			String[] command = {  "/bin/sh", "-c", "ps -ef|grep nginx" };
    			String rs = RuntimeUtil.execForStr(command);
    			isRun = rs.contains("nginx: master process") || rs.contains("nginx: worker process");
    		}
    
    		return isRun;
    	}
    }

## 三、检查网络端口是否通 ##

import java.io.IOException;
    import java.net.*;
    
    /** * @author nick */
    public class TelnetUtils { 
    	public static boolean isRunning(String host, int port) { 
    		Socket sClient = null;
    		try { 
    			SocketAddress saAdd = new InetSocketAddress(host.trim(), port);
    			sClient = new Socket();
    			// 设置超时 1s
    			sClient.connect(saAdd, 1000);
    		} catch (UnknownHostException | SocketTimeoutException e) { 
    			return false;
    		} catch (IOException e) { 
    			return false;
    		} catch (Exception e) { 
    			return false;
    		} finally { 
    			try { 
    				if (sClient != null) { 
    					sClient.close();
    				}
    			} catch (Exception e) { 
    			}
    		}
    		return true;
    	}
    
    	public static void main(String[] args) { 
    		System.out.println( isRunning("127.0.0.1", 8080));
    	}
    }

## 四、执行ssh连接工具 ##

import com.jcraft.jsch.*;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.io.IOUtils;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.nio.charset.Charset;
    
    @Slf4j
    public class SSHClientUtils { 
    
    	public static class MyUserInfo implements UserInfo { 
    
    		private String password;
    
    		@Override
    		public String getPassphrase() { 
    			return null;
    		}
    
    		@Override
    		public String getPassword() { 
    			return password;
    		}
    
    		@Override
    		public boolean promptPassword(String message) { 
    			return true;
    		}
    
    		@Override
    		public boolean promptPassphrase(String message) { 
    			return true;
    		}
    
    		@Override
    		public boolean promptYesNo(String message) { 
    			return true;
    		}
    
    		@Override
    		public void showMessage(String message) { 
    			log.info(message);
    		}
    
    		public void setPassword(String password) { 
    			this.password = password;
    		}
    
    	}
    
    	/** * 直接执行命令 */
    	public static String exec(Ssh ssh, String cmd) { 
    		JSch jsch = new JSch();
    		String outStr = "";
    		try { 
    			Session session = jsch.getSession(ssh.getUsername(), ssh.getHost(), ssh.getPort());
    			MyUserInfo ui = new MyUserInfo();
    			ui.setPassword(ssh.getPassword());
    			session.setUserInfo(ui);
    			session.connect();
    			Channel channel = session.openChannel("exec");
    			((ChannelExec) channel).setCommand(cmd);
    			InputStream in = channel.getInputStream();
    			OutputStream out = channel.getOutputStream();
    			((ChannelExec) channel).setErrStream(System.err);
    			channel.connect();
    			out.flush();
    			outStr = IOUtils.toString(in, Charset.forName("utf-8"));
    			log.info(outStr);
    			channel.disconnect();
    			session.disconnect();
    		} catch (Exception e) { 
                log.error("出现异常：{}",e);
    		}
    		return outStr;
    	}
    
    
    	class Ssh{ 
    
    		private String name;
    		private String host;
    		private Integer port;
    		private String username;
    		private String password;
    
    		public String getName() { 
    			return name;
    		}
    
    		public void setName(String name) { 
    			this.name = name;
    		}
    
    		public String getHost() { 
    			return host;
    		}
    
    		public void setHost(String host) { 
    			this.host = host;
    		}
    
    		public Integer getPort() { 
    			return port;
    		}
    
    		public void setPort(Integer port) { 
    			this.port = port;
    		}
    
    		public String getUsername() { 
    			return username;
    		}
    
    		public void setUsername(String username) { 
    			this.username = username;
    		}
    
    		public String getPassword() { 
    			return password;
    		}
    
    		public void setPassword(String password) { 
    			this.password = password;
    		}
    	}
    
    }

## 五、注解方式分布式锁 ##

import java.lang.annotation.*;
    
    
    @Target({ ElementType.ANNOTATION_TYPE, ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    public @interface RedisLock { 
    }

import lombok.extern.slf4j.Slf4j;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.data.redis.core.StringRedisTemplate;
    
    import java.time.Duration;
    import java.util.Optional;
    
    
    @Aspect
    @Slf4j
    public class RedisLockAspect { 
    
        private StringRedisTemplate redisTemplate;
        @Value("${common-mq.redis-lock.namespace:#{'common-mq:${spring.application.name:unknown-service-name}:'}}")
        private String namespace;
    
        public RedisLockAspect(StringRedisTemplate redisTemplate) { 
            this.redisTemplate = redisTemplate;
        }
    
        @Pointcut("@within(redisLock) || @annotation(redisLock)")
        public void joinPoint(RedisLock redisLock) { 
        }
    
        @Around(value = "joinPoint(redisLock)", argNames = "pjp,redisLock")
        public final Object doAround(final ProceedingJoinPoint pjp, RedisLock redisLock) throws Throwable { 
            Boolean success =
                    Optional.ofNullable(redisTemplate.opsForValue().setIfAbsent(getKey(pjp),
                            Thread.currentThread().getName(), Duration.ofMinutes(1))).orElse(false);
            if (success) { 
                try { 
                    return pjp.proceed();
                } finally { 
                    redisTemplate.delete(getKey(pjp));
                }
            }
            return null;
        }
    
        protected String getKey(ProceedingJoinPoint pjp) { 
            return namespace + pjp.toString();
        }
    
    }

import org.springframework.beans.factory.ObjectProvider;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.StringRedisTemplate;
    
    
    @Configuration
    @ConditionalOnClass(RedisTemplate.class)
    public class RedisLockConfiguration { 
    
        @Bean
        @ConditionalOnMissingBean
        public RedisLockAspect redisLockAspect(ObjectProvider<StringRedisTemplate> redisTemplates) { 
            StringRedisTemplate redisTemplate = redisTemplates.getIfUnique();
            return redisTemplate == null ? null : new RedisLockAspect(redisTemplate);
        }
    
    }