开发者模式下，分析一个网站中一个变量的来源。

1、扒一个网站数据时候，有一个变量不知道是从哪里获取到的，即下图中的msg.Data[0]。

2、需要在开发者模式下调试代码，找到这个变量的来源和生成方法，并用java改写这个生成变量的方法。
3、联系方式：8736581

问题背景：爬取一个网站的数据，到服务器请求数据时，通过分析js代码可知，需要附带一个token到服务器校验身份，并且这个token的获取是通过js请求本地WebSocket服务获取的，爬虫程序想要获取这个token，以便顺利爬取数据

解决思路：使用Java重写获取token的代码，并使用springboot提供REST接口供爬虫程序调用即可。

解决过程：
1. 创建maven工程(我是使用的Eclipse)，并导入WebSocket客户端的依赖。

<dependency>
	<groupId>org.java-websocket</groupId>
	<artifactId>Java-WebSocket</artifactId>
	<version>1.4.0</version>
</dependency>

2. 继承WebSocketClient抽象类，重写生命周期方法，（WebSocketClient是WebSocket的抽象模板实现，提供了当WebSocket打开时，关闭时等业务接口，我们只需要继承，并添加自己的实现即可）

package wscom.ddd.ws;

import java.net.URI;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.Map;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.java_websocket.client.WebSocketClient;
import org.java_websocket.drafts.Draft;
import org.java_websocket.handshake.ServerHandshake;

import wscom.ddd.ws.controller.WebSocketController;

public class MyWssClient extends WebSocketClient {

	public MyWssClient(URI serverURI) {
		super(serverURI);
	}

	public MyWssClient(URI serverURI, Draft draft) {
		super(serverURI, draft);
	}

	public MyWssClient(URI serverURI, Draft draft, Map<String, String> headers, int connecttimeout) {
		super(serverURI, draft, headers, connecttimeout);
	}

	final static HostnameVerifier DO_NOT_VERIFY = new HostnameVerifier() {
		public boolean verify(String hostname, SSLSession session) {
			/* 默认不校验所有的域名 */
			return true;
		}
	};

	/**
	 * 开启时回调
	 */
	@Override
	public void onOpen(ServerHandshake handshakedata) {
		System.out.println(String.format("onOpen:%s", handshakedata));
	}

	/**
	 * 收到服务器返回消息时回调
	 */
	@Override
	public void onMessage(String message) {
		System.out.println("onMessage:" + message);
		if (message != null) {
			/**
			 * 匹配截取，拿到自己想要的数据即可
			 */
			int start = message.lastIndexOf("\"Data\":[\"");
			int end = message.lastIndexOf("\"],\"Error\"");
			if (start != -1 && end != -1) {
				String token = message.substring(start + 9, end);
				System.out.println("token:" + token);
				WebSocketController.value = token;
			}
		}
	}

	/**
	 * 关闭时回调
	 */
	@Override
	public void onClose(int code, String reason, boolean remote) {
		System.out.println(String.format("onClose:【%s】【%s】【%s】", code, reason, remote));
	}

	/**
	 * 出现异常时回调
	 */
	@Override
	public void onError(Exception ex) {
		ex.printStackTrace();
		System.out.println(String.format("onError:%s", ex));
	}
}

3. 添加springboot依赖，注入自己实现的WebSocket实现类，编写Controller
springboot核心依赖(使用2.2.2.RELEASE版本)：

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.2.2.RELEASE</version>
		<relativePath /> <!-- lookup parent from repository -->
	</parent>

启动类中注入WebSocket客户端；

package wscom.ddd.ws;

import java.net.URI;
import java.net.URISyntaxException;

import org.java_websocket.client.WebSocketClient;
import org.java_websocket.enums.ReadyState;
import org.java_websocket.handshake.ServerHandshake;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Lazy;

import wscom.ddd.ws.controller.WebSocketController;

@SpringBootApplication
public class Main {
	public static void main(String[] args) {
		SpringApplication.run(Main.class, args);
	}
	
	@Bean("wsClient")
	public WebSocketClient injectWebSocketClient() throws URISyntaxException {
		return new MyWssClient(new URI("ws://localhost/test"));
	}
}

Controller接口

package wscom.ddd.ws.controller;

import java.net.URISyntaxException;
import javax.annotation.Resource;

import org.java_websocket.client.WebSocketClient;
import org.java_websocket.enums.ReadyState;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class WebSocketController {

	public static volatile String value;
	
	@Resource(name = "wsClient")
	private WebSocketClient wsClient;
	
	@PostMapping("/getToken")
	public String getToken(@RequestBody String jsonParam) {
		int cnt=0;
		/**
		 * 自旋等待wsClient准备好
		 */
		while (wsClient.getReadyState() != ReadyState.OPEN) {
			System.out.println("wsClient not ready");
			++cnt;
			if(cnt==5) {
				break;
			}
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
		if(cnt==5) {
			cnt=0;
			wsClient.reconnect();
			while (wsClient.getReadyState() != ReadyState.OPEN) {
				System.out.println("wsClient reconnect not ready");
				++cnt;
				if(cnt==5) {
					System.out.println("超过5秒，wsClient重新连接失败，退出");
					System.exit(-1);
					break;
				}
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
		wsClient.send(jsonParam);
		cnt=0;
		while(WebSocketController.value==null) {
			System.out.println("还未获取到WebSocket服务器返回消息");
			++cnt;
			if(cnt==5) {
				System.out.println("超过5秒，WebSocket服务器还没返回消息");
				return "WebSocket服务器超时未返回消息";
			}
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		String t = WebSocketController.value;
		WebSocketController.value=null;
		return t;
	}
}