더 블 nginx 심장 박동 패 키 지 를 통 해 메 인 전환 을 실현 합 니 다.

최근 프로젝트 에서 프로젝트 의 객관 적 인 원인 으로 부터 제약 을 받 아 쌍 기 쌍 nginx 는 심장 박동 패 키 지 를 통 해 메 인 전환 방안 을 구축 하여 기록 했다.
필요 효과: 사용 자 는 두 대의 서버 만 있 고 사용자 에 게 유일한 접근 주 소 를 제공 합 니 다.
대체적인 사고방식: 각각 두 서버 에 nginx 를 배치 하고 nginx 의 프로필 은 대외 적 인 주소 와 포트 가 같 으 며 하층부 에 대응 하 는 서버 의 주 소 는 각 항목 의 주소 이 고 심장 박동 패 키 지 를 통 해 상호 감청 을 실현 하 며 동적 제어 프로젝트 내 정 된 작업 과 두 개의 nginx 서비스의 시작 과 닫 기 를 실현 한다.
구체 적 인 코드 는 다음 과 같다.
 

package com.justner;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketAddress;
import java.net.SocketException;
import java.net.UnknownHostException;

import javax.annotation.PostConstruct;

/**
 *         
 * @author Justner
 * @version 2017-12-27
 */
public class HeartbeatService{
	
	private static int port = 2001; //     
	private static int times = 0; //             
	private static int probeTimes = 5; //       
	private static boolean isMaster = true; //     
	private static boolean isFirst = true; //       
	private static InetAddress address; //       
	private static DatagramSocket socket; //  socket
	private static InetAddress localAddress; //       
	private static DatagramSocket localSocket; //  socket

	@PostConstruct
	public static void start() {
		//        
		init();
		//          
		startSenderThread();
		//              
		startRecvThread();
	}

	private static void init() {
		/**
		 *         UDP  
		 */
		try {
			address = InetAddress.getByName("192.168.3.9");
			socket = new DatagramSocket(); //      
			socket.setSoTimeout(1000); //  ms
		} catch (UnknownHostException | SocketException e1) {
			e1.printStackTrace();
		}
		
		/**
		 *          
		 */
		try {
			localAddress = InetAddress.getLocalHost();
			localSocket = new DatagramSocket(port, localAddress);
		} catch (UnknownHostException | SocketException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 *     
	 */
	private static void startSenderThread() {
		//        
		new Thread() {
			@Override
			public void run() {
				//            
				String context = "...";
				DatagramPacket dataGramPacket = new DatagramPacket(context.getBytes(), context.getBytes().length, address, port);
				//         
				while (true) {
					try {
						socket.send(dataGramPacket);//         
						doResultInfo(socket);
						//           ，        
						times = 0;
						//              、              ，        
						if (isFirst) {
							setMaster(false);
							isFirst = false;
						}
					} catch (IOException e) {
						//       ，         。  5 ，5       ，          
						times = times + 1;
						if (times >= probeTimes) {
							setMaster(true);
							//      
							if (isFirst) {
								isFirst = false;
							}
						}
					}
					//          
					try {
						Thread.sleep(1000); //  ms
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					//        
					if (isMaster) {
						System.out.println("=========    ：  ");
					} else {
						System.out.println("=========    ：  ");
					}
				}
			}
		}.start();
	}

	private static void doResultInfo(DatagramSocket socket) throws IOException {
		byte[] backbuf = new byte[1024];
		DatagramPacket backPacket = new DatagramPacket(backbuf, backbuf.length);
		socket.receive(backPacket);
		//       
		String getMsg = new String(backbuf, 0, backPacket.getLength());
		if ("......".equals(getMsg)) {
			times = 0;
			System.out.println("          ：" + getMsg);
		} else if ("....".equals(getMsg)) {
			setMaster(false);
			System.out.println("===========      ！============");
		}
	}

	/**
	 *       
	 */
	private static void startRecvThread() {
		new Thread() {
			public void run() {
				try {
					byte[] buf = new byte[1024]; //   byte  
					DatagramPacket packet = new DatagramPacket(buf, buf.length); //   DatagramPacket  
					while (true) {
						localSocket.receive(packet); //          
						String getMsg = new String(buf, 0, packet.getLength());
						System.out.println("         ：" + getMsg);
						String reContext = "";
						if ("...".equals(getMsg)) {
							reContext = ".....";
						} else if ("..".equals(getMsg)) {
							setMaster(true);
							reContext = "....";
						}
						SocketAddress sendAddress = packet.getSocketAddress();
						byte[] backbuf = reContext.getBytes();
						DatagramPacket sendPacket = new DatagramPacket(backbuf,backbuf.length, sendAddress); //            
						localSocket.send(sendPacket); //             
					}
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}.start();
	}
	
	/**
	 *       
	 * @param stauts
	 */
	private static void setMaster(boolean stauts) {
		//   
		if ((stauts && !isMaster) || (stauts && isFirst)) {
			try {
				/*           ，                     */
				nginxTurn("nginxStart.bat"); //cmd     nginx  ，         
				System.out.println("      ||      ");
			} catch (Exception e) {
				System.out.println("      ||      ");
			}
		//   
		} else if((!stauts && isMaster) || (!stauts && isFirst)){
			try {
				/*           ，                     */
				nginxTurn("nginxQuit.bat"); //cmd     nginx  ，         
				System.out.println("      ||      ");
			} catch (Exception e) {
				System.out.println("      ||      ");
			}
		}
		isMaster = stauts;
	}
	
	/**
	 *         
	 * @return
	 * @throws IOException 
	 */
	public static boolean setOtherMaster() throws IOException  {
		//            
		String context = "..";
		DatagramPacket dataGramPacket = new DatagramPacket(context.getBytes(),context.getBytes().length, address, port);
		//           
		socket.send(dataGramPacket);
		doResultInfo(socket);
		return !isMaster;
	}
	
	/**
	 * nginx    
	 * @param command
	 * command   bat    sh    ，               nginx  
	 *     ：  start nginx，  nginx -s quit
	 */
	public static void nginxTurn(String command){
		try {
			//    
			String cmd = "cmd /c start " + command; //Windows    
//			String cmd = "chmod 777 /" + command; //linux    
			Process process = Runtime.getRuntime().exec(cmd);
			InputStream ins = process.getInputStream(); //     cmd      
			BufferedReader reader = new BufferedReader(new InputStreamReader(ins));
			String line = null;
			while ((line = reader.readLine()) != null) {
				System.out.println(line); //   
			}
			int exitValue = process.waitFor();
			System.out.println("   ：" + exitValue);
			//   
			process.getOutputStream().close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}