1234

有人吗……

好奇水水

直接把代码发出来

小白路过。。。

package datacollect;
import java.io.IOException;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.Socket;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.concurrent.Semaphore;
/**
* 主控类 用来控制整个系统
*
* @author Jack
* @version 1.0.2 可以指定单个客户端也可以批量操作
*
*/
public class PluginListener {
// 成员变量
public static Semaphore semp = new Semaphore(1);// 临界区互斥访问信号量(二进制信号量)，相当于互斥锁
public static boolean runFlag = true;// 运行标识符
public static void main(String[] args) throws IOException { //可抛出的异常
try {
ParamSet.collectIp = getLocalIp();// 获取采集器的IP地址
} catch (SocketException | UnknownHostException e) {
e.printStackTrace();
}
System.out.println("collectIp:" + ParamSet.collectIp + "\n");//系统输出IP地址
ArrayList<String> list = new ArrayList<String>();// 创建集合，是数据采集线程与数据存储线程的共享资源
ArrayList<Socket> socketList = new ArrayList<Socket>();
Menu menu = new Menu(list, socketList);
menu.showMainMenu();
}
/**
* 获取采集器的IP地址
*
* @return
* @throws SocketException
* @throws UnknownHostException
*/
private static String getLocalIp() throws SocketException, UnknownHostException { //可能抛出的异常
Enumeration<NetworkInterface> netInterfaces = NetworkInterface.getNetworkInterfaces();
InetAddress ip = null;
String needIp = "";
String os = System.getProperty("os.name"); // 获取操作系统的属性
if (os.toLowerCase().startsWith("win")) { // 如果是window系统
ip = InetAddress.getLocalHost(); // 实例化对象
String localip = ip.getHostAddress(); // 获取本IP地址
return localip;
} else {// 如果是linux系统
while (netInterfaces.hasMoreElements()) {
NetworkInterface ni = (NetworkInterface) netInterfaces.nextElement();
Enumeration<InetAddress> ips = ni.getInetAddresses();
while (ips.hasMoreElements() && ni.getName().contains("wlan0")) { // 如果ips还没有遍历完，并且ni的name中包含有wlan0
ip = ips.nextElement();// 把当前的ips取给ip
if (ip.isSiteLocalAddress() && !ip.isLoopbackAddress()) {// 如果是IPV4的地址
needIp = ip.getHostAddress();// 取出IPV4的地址给输出返回值
}
}
if (ip != null && ip instanceof Inet4Address && ip.getHostAddress().indexOf(".") != -1) {// 异常情况处理，确保获取符合条件的ip
} else {
ip = null;
}
}
return needIp;
} // end else
}
}

package datacollect;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
/**
* 数据转储线程 将采集到的数据每隔一分钟一次性批量存储到数据库
*
* @author Jack
*
*/
public class DataSaveThread implements Runnable {
// 成员变量
private ArrayList<String> list;// 共享资源
private ArrayList<String> list2DB;// 数据转储缓冲区
private int countSum;// 记录本次运行写入数据库的数据总条数
public DataSaveThread(ArrayList<String> list) {
this.list = list;
}
public void run() {
// 初始化模块
list2DB = new ArrayList<String>();// 将数据转储缓冲区初始化
try {
// 写入数据库模块
while (PluginListener.runFlag) {// 正常运行下，写入数据库
Thread.sleep(60 * 1000);// 该线程睡眠1分钟
if (!listToList2DB(list, list2DB).isEmpty()) {// 当数据转储缓冲区list2DB不为空的时候，再执行
dataBatch2DB(list2DB);// 写入数据库
}
}
} catch (InterruptedException e) {// 按下0，中断睡眠，把已经读到的数据及时写到数据库，保证数据的可靠性
if (!listToList2DB(list, list2DB).isEmpty()) {// 当数据转储缓冲区list2DB不为空的时候，再执行
dataBatch2DB(list2DB);// 写入数据库
}
}
finally {// 给出服务器关闭提示
System.out.println("The server has been closed!");
System.exit(0);
}
}
/**
* 将arrayList1集合中的元素copy到arrayList2集合中
*
* @param arrayList1
* @param arrayList2
* @return arrayList2
*/
private ArrayList<String> listToList2DB(ArrayList<String> arrayList1, ArrayList<String> arrayList2) {
try {
PluginListener.semp.acquire();// 申请信号量
if (!arrayList1.isEmpty()) {// 如果arrayList1不为空
System.out.println("\ndata2DB begin .....");
System.out.println("listSizeBegin=" + arrayList1.size());// arrayList1的大小
arrayList2.addAll(arrayList1);// 将arrayList1的内容全部复制到arrayList2中
arrayList1.clear();// 清空arrayList1
}
PluginListener.semp.release();// 释放信号量
} catch (InterruptedException e) {
e.printStackTrace();
}
return arrayList2;
}
/**
* 将数据批量插入数据库
*
* @param arrayList
*/
private void dataBatch2DB(ArrayList<String> arrayList) { //从这里开始不懂！！！！！！！！
// 定义变量并初始化
Connection conn = null;// 与特定数据库的连接
PreparedStatement ps = null;// SQL语句被预编译并存储在PreparedStatement对象中
int count = 0;// 用于记录合法记录的条数
long startTime;// 记录存入数据库的开始时间
long endTime;// 记录存入数据库的结束时间
String[] lineArray;// 用于存放分割arrayList元素之后的数据
String lineData;// 采集到的数据
String collectTime;// 采集到某条数据时所对应的时间
String sql = "insert into "+ParamSet.dbTable+"(sdata,collectTime,collectIP) values(?,?,?)";// 将SQL语句参数化
try {
conn = DBUtil.getConn();// 连接数据库
conn.setAutoCommit(false);// 禁用自动提交模式
ps = conn.prepareStatement(sql);// 将参数化的 SQL语句发送到数据库
// 批量存入数据库的核心代码
startTime = System.currentTimeMillis();// 存入数据库的开始时间
for (String line : arrayList) {
lineArray = line.split(",");
lineData = lineArray[0];
collectTime = lineArray[1];
ps.setString(1, lineData);
ps.setString(2, collectTime);
ps.setString(3, ParamSet.collectIp);
ps.addBatch();// 将一组参数添加到此 PreparedStatement 对象的批处理命令中
count++;
}
ps.executeBatch();// 将一批命令提交给数据库来执行
conn.commit();// 使所有上一次提交更改成为持久更改，并释放此 Connection对象当前持有的所有数据库锁
endTime = System.currentTimeMillis();// 存入数据库的结束时间
arrayList.clear();// 清空arrayList
countSum += count;// 本次运行写入数据库的数据总条数
// 信息提示模块
System.out.println("共有合法的记录" + count + "条");
System.out.println("数据存入DB花费的时间以毫秒为单位：" + (endTime - startTime) + "毫秒");
System.out.println("目前数据总条数是：" + countSum);
System.out.println("当前时间是："
+ new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(System.currentTimeMillis())));
} catch (Exception e) {
e.printStackTrace();
} finally {
DBUtil.closeConn(conn);// 关闭数据库连接
try {
if (null != ps) {// 如果预编译的 SQL语句的对象不为空，则关闭
ps.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
/**
* 数据库的连接
*
* @author Jack
*
*/
class DBUtil {
// 定义数据库连接参数
public static final String DRIVER_CLASS_NAME = ParamSet.driver;// 驱动名称
public static final String URL = ParamSet.url;// JDBC连接sqlserver数据库的格式
public static final String USERNAME = ParamSet.userName;// 该数据库的用户名
public static final String PASSWORD = ParamSet.passWord;// 与用户名匹配的密码
// 注册数据库驱动
static {
try {
Class.forName(DRIVER_CLASS_NAME);
} catch (ClassNotFoundException e) {
System.out.println("注册失败！");
e.printStackTrace();
}
}
// 获取连接
public static Connection getConn() throws SQLException {
return DriverManager.getConnection(URL, USERNAME, PASSWORD);
}
// 关闭连接
public static void closeConn(Connection conn) {
if (null != conn) {
try {
conn.close();
} catch (SQLException e) {
System.out.println("关闭连接失败！");
e.printStackTrace();
}
}
}
}

package datacollect;
import java.io.IOException;
import java.net.Socket;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
/**
* 数据采集线程 每监听一个客户端，就启动一次
*
* @author Jack
*
*/
public class DataCollectThread implements Runnable {
// 成员变量
private Socket socket;// 客户端套接字，也可以叫套接字
private ArrayList<String> list;// 共享资源
public DataCollectThread(Socket socket, ArrayList<String> list) {
this.socket = socket;
this.list = list;
}
@Override
public void run() {
try {
// 初始化模块
StringBuilder stringbuilder = new StringBuilder();// 定义缓冲区并初始化，用来缓存拼接后的字符
String data = null;// 用于接收（由客户端发送的字节转化的十六进制）字符串
int len = 0;// 用于接受从输入流中读取数据的下一个字节。返回 0 到 255 范围内的 int 字节值
String lineData;
String flagStr;
// 读写数据模块
// 读取客户端发送的数据，写到内存中
while (((len = socket.getInputStream().read()) != -1)) {
// 读取客户端发送的数据，放入缓冲区
data = Integer.toHexString(len).toUpperCase();// 将字节转化为十六进制形式的字符串，这里不算是很明白
if (len <= 15) {
data = "0" + data;// 如果字节值小于15，则在以转化的字符前面加一个0，确保一个字节值转化为两个字符的字符串
}
stringbuilder.append(data);// 拼接字符串，放入缓冲区
lineData = stringbuilder.toString();// 转化为字符串
// 从缓冲区读取数据，写到内存中
if (stringbuilder.length() % 32 == 0 && lineData.startsWith("FAFAFAFA")
&& lineData.endsWith("FAFAFAFA")) {
flagStr = lineData.substring(10, 12);
if (flagStr.equals("01") || flagStr.equals("03") || flagStr.equals("05")) {
PluginListener.semp.acquire();// 申请信号量
list.add(lineData + "," + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
.format(new Date(System.currentTimeMillis()))); // 读取的数据信息加入内存
PluginListener.semp.release(); // 释放信号量
}
stringbuilder.setLength(0);// 清空缓冲区
}
}
} catch (IOException e) {
if (socket != null) {
System.out.println("Try to reconnect!");
} else {
System.out.println("Client is not connected!");
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if (socket != null) {// 如果套接字不为空，则关闭
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}

package datacollect;
import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 监听端口线程也可以叫监听线程 用来监听多个客户端
*
* @author Jack
*
*/
public class ListenPortThread implements Runnable {
// 成员变量
private ArrayList<String> list;// 共享资源
public ArrayList<Socket> socketList;
public ListenPortThread(ArrayList<String> list, ArrayList<Socket> socketList) {
this.list = list;
this.socketList = socketList;
}
public ListenPortThread(ArrayList<Socket> socketList) {
this.socketList = socketList;
}
@Override
public void run() {
try {
// 初始化模块
int port = ParamSet.portID;
int backLog = 2;
InetAddress bindAddr = InetAddress.getByName(ParamSet.collectIp);
ServerSocket serverSocket = new ServerSocket(port, backLog, bindAddr);// 创建绑定到特定端口的服务器套接字
ExecutorService pool = Executors.newCachedThreadPool();// 创建线程池
List<Socket> templist = new ArrayList<Socket>();
String conectionInformation = null;
System.out.println("\nWaiting for the client connection!");
// 监听多个客户端模块
while (PluginListener.runFlag) {
Socket socket = serverSocket.accept();// 监听客户端
if (PluginListener.runFlag) {
conectionInformation = "New connection accepted:" + socket.getInetAddress() + ":" + socket.getPort();
System.out.println(conectionInformation);// 提示客户端有没有连上服务器
pool.submit(new DataCollectThread(socket, list));// 启动数据采集线程
}
if (!socketList.isEmpty()) { //不为空
for (Socket socketExisted : socketList) {
String ipOld = socketExisted.getInetAddress().toString();
String ipNew = socket.getInetAddress().toString();
if (ipOld.equals(ipNew)) {
templist.add(socketExisted);
}
}
socketList.removeAll(templist);
templist.clear();
}
socketList.add(socket);
}
// 关闭资源模块
serverSocket.close();// 关闭服务器套接字
pool.shutdown();// 关闭线程池
} catch (IOException e) {
e.printStackTrace();
}
}
}

就是这样子哦

直接跳过代码。只看了下导包就知道程序有多复杂