AI 助理
备案控制台
开发者社区 大数据 文章 正文

【技能实训】DMS数据挖掘项目-Day09

2023-10-12 39
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
数据管理 DMS，安全协同 3个实例 3个月
推荐场景：
学生管理系统数据库
日志服务 SLS，月写入数据量 50GB 1个月
简介： 【技能实训】DMS数据挖掘项目-Day09

任务9

【任务9.1.1】升级DataBase类为可序列化的类，以便在文件保存或网络中传递

程序设计

package com.qst.dms.entity;
import java.io.Serializable;
import java.util.Date;
public class DataBase implements Serializable {
    public static final int IN = 1;
    public static final int OUT = 0;
    // ID标识
    private int id;
    // 时间
    private Date time;
    // 地点
    private String address;
    // 状态
    private int type;
    // 状态常量
    public static final int GATHER = 1;//"采集"
    public static final int MATHCH = 2;//"匹配";
    public static final int RECORD = 3;//"记录";
    public static final int SEND = 4;//"发送";
    public static final int RECIVE = 5;//"接收";
    public static final int WRITE = 6;//"归档";
    public static final int SAVE = 7;//"保存";
    public static final String DataType[]=new String[]{
            null,
            "GATHER",
            "MATHCH",
            "RECORD",
            "SEND",
            "RECIVE",
            "WRITE",
            "SAVE"
    };
    public DataBase(int id, Date time, String address, int type) {
        this.id = id;
        this.time = time;
        this.address = address;
        this.type = type;
    }
    public DataBase() {
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public Date getTime() {
        return time;
    }
    public void setTime(Date time) {
        this.time = time;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public int getType() {
        return type;
    }
    public void setType(int type) {
        this.type = type;
    }
    @Override
    public String toString() {
        return  "\nid=" + id +
                "\ntime=" + time +
                "\naddress=" + address +
                "\ntype=" + DataType[type]
                ;
    }
}

【任务9.1.2】升级LogRec类为可序列化的类，以便在文件保存或网络中传递

程序设计

package com.qst.dms.entity;
import java.io.Serializable;
import java.util.Date;
public class LogRec extends DataBase implements Serializable {
    /**
     *  登录用户名
     */
    private String user;
    /**
     * 登录用户主机IP地址
     */
    private String ip;
    /**
     * 登录状态：登录、登出
     */
    private int logType;
    /**
     * 登录常量LOG_IN、登出常量常量LOG_OUT
     */
    public static final int LOG_IN=1;
    public static final int LOG_OUT=0;
    public static final String LogTypeArray[]=new String[]{
            "LogOut",
            "LogIn"
    };
    public LogRec(int id, Date time, String address, int type, String user, String ip, int logType) {
        super(id, time, address, type);
        this.user = user;
        this.ip = ip;
        this.logType = logType;
    }
    public LogRec() {
        super();
    }
    public String getUser() {
        return user;
    }
    public void setUser(String user) {
        this.user = user;
    }
    public String getIp() {
        return ip;
    }
    public void setIp(String ip) {
        this.ip = ip;
    }
    public int getLogType() {
        return logType;
    }
    public void setLogType(int logType) {
        this.logType = logType;
    }
    @Override
    public String toString() {
        return  "LogRec: " +
                super.toString() +
                "\nuser=" + user +
                "\nip=" + ip +
                "\nlogType=" + LogTypeArray[logType] +
                "\n";
    }
    public char[] toArray() {
        String data = this.getId() + "," + this.getTime().getTime() + "," + this.getAddress() + "," + this.getType() + "," + this.getUser() + "," + this.getIp() + "," + LogTypeArray[this.getLogType()];
        return data.toCharArray();
    }
}

【任务9.1.3】升级MatchedLogRec类为可序列化的类，以便在文件保存或网络中传递

程序设计

package com.qst.dms.entity;
import java.io.Serializable;
import java.util.Date;
public class MatchedLogRec extends MatchedDataBase implements Serializable {
    private LogRec login;
    private LogRec logout;
    // user用户登录名
    public String getUser() {
        return login.getUser();
    }
    // 登入时刻
    public Date getLogInTime() {
        return login.getTime();
    }
    // 登出时刻
    public Date getLogoutTime() {
        return logout.getTime();
    }
    // 登入记录
    public LogRec getLogin() {
        return login;
    }
    // 登出记录
    public LogRec getLogout() {
        return logout;
    }
    public MatchedLogRec() {
    }
    public MatchedLogRec(LogRec login, LogRec logout) {
        this.login = login;
        this.logout = logout;
    }
    @Override
    public String toString() {
        return login.toString() + " | " + logout.toString();
    }
}

【任务9.1.4】升级Transport类为可序列化的类，以便在文件保存或网络中传递

程序设计

package com.qst.dms.entity;
import java.io.Serializable;
import java.util.Date;
public class Transport extends DataBase implements Serializable {
    /**
     * 经手人
     */
    private String handler;
    /**
     * 收货人
     */
    private String reciver;
    /**
     * 物流状态
     */
    private int transportType;
    /**
     * 物流状态常量:发货中, 送货中, 已签收
     */
    public static final int SENDING = 1;// 发货中
    public static final int TRANSPORTING = 2;// 送货中
    public static final int RECEIVED = 3;// 已签收
    public static final String TransportArray[]=new String[]{
            null,
            "SENDDING",
            "TRANSPORTING",
            "RECIEVED"
    };
    public Transport(int id, Date time, String address, int type, String handler, String reciver, int transportType) {
        super(id, time, address, type);
        this.handler = handler;
        this.reciver = reciver;
        this.transportType = transportType;
    }
    public String getHandler() {
        return handler;
    }
    public void setHandler(String handler) {
        this.handler = handler;
    }
    public String getReciver() {
        return reciver;
    }
    public void setReciver(String reciver) {
        this.reciver = reciver;
    }
    public int getTransportType() {
        return transportType;
    }
    public void setTransportType(int transportType) {
        this.transportType = transportType;
    }
    @Override
    public String toString() {
        return  "Transport: " +
                super.toString() +
                "\nhandler=" + handler +
                "\nreciver=" + reciver +
                "\ntransportType=" + TransportArray[transportType] +
                "\n";
    }
    public char[] toArray() {
        String data = this.getId() + "," + this.getTime().getTime() + "," + this.getAddress() + "," + this.getType() + "," + this.getHandler() + "," + this.getReciver() + "," + TransportArray[this.getTransportType()];
        return data.toCharArray();
    }
}

【任务9.1.5】升级MatchedTransport类为可序列化的类，以便在文件保存或网络中传递

程序设计

package com.qst.dms.entity;
import java.io.Serializable;
public class MatchedTransport extends MatchedDataBase implements Serializable {
    private Transport send;
    private Transport trans;
    private Transport receive;
    public MatchedTransport(Transport send, Transport tran, Transport rec) {
        this.send=send;
        this.trans=tran;
        this.receive=rec;
    }
    public MatchedTransport() {
    }
    public Transport getSend() {
        return send;
    }
    public void setSend(Transport send) {
        this.send = send;
    }
    public Transport getTrans() {
        return trans;
    }
    public void setTrans(Transport trans) {
        this.trans = trans;
    }
    public Transport getReceive() {
        return receive;
    }
    public void setReceive(Transport receive) {
        this.receive = receive;
    }
    @Override
    public String toString() {
        return send.toString() + " | " + trans.toString() + " | " + receive.toString();
    }
}

【任务9.2】修改LogRecService类，在该类中增加三个方法，分别用于保存匹配的日志信息，读取匹配的日志信息和读取匹配日志信息并返回日志实体集合，实现匹配日志的保存和读取功能

首先给类中，增加一个属性：

private static final String  saveFile = "MatchedLogRec.dat";
//存储本地存储文件的文件名。
// 匹配日志信息保存，参数是集合
public void saveMatchLogRec(List<MatchedLogRec> matchLogs) {
// 创建一个ObjectOutputStream对象输出流，并连接文件输出流
// 以可追加的方式创建文件输出流，数据保存到MatchedLogRec.dat文件中
　
}
// 读匹配日志信息保存，参数是集合
public List<MatchedLogRec> readMatchLogRec(){
List<MatchedLogRec> matchLogs = new ArrayList<>();
// 创建一个ObjectInputStream对象输入流，并连接文件输入流，读MatchedLogRec.dat文件中
//读取文件之前，首先判断文件是否存在，如果不存在，则创建一个空文件
//读取文件中的所有对象时，可以使用异常处理和EOFException异常处理读取结束
//读取数据结束后，关闭文件流。
}
// 读匹配日志信息保存，参数是集合
public List<LogRec> readLogRec (){
List<LogRec> matchLogs = new ArrayList<>();
// 创建一个ObjectInputStream对象输入流，并连接文件输入流，读MatchedLogRec.dat文件中
//读取文件之前，首先判断文件是否存在，如果不存在，则创建一个空文件
//读取文件中的所有对象时，可以使用异常处理和EOFException异常处理读取结束
//读取数据结束后，关闭文件流。
}

程序设计

package com.qst.dms.service;
import com.qst.dms.entity.LogRec;
import com.qst.dms.entity.MatchedLogRec;
import com.qst.dms.exception.DataAnalyseException;
import com.qst.dms.gather.LogRecAnalyse;
import com.qst.dms.util.AppendObjectOutputStream;
import java.io.*;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Scanner;
public class LogRecService {
    private static final String saveFile = "MatchedLogRec.dat";
    private Scanner scanner;
    public LogRecService() {
        scanner = new Scanner(System.in);
    }
    public LogRec inputLog() {
        int id, type, logType;
        Date nowDate;
        String address;
        String user;
        String ip;
        while (true) {
            try {
                System.out.println("请输入ID标识：");
                id = scanner.nextInt();
                nowDate = new Date();
                System.out.println("请输入地址：");
                address = scanner.next();
                type = LogRec.GATHER;
                System.out.println("请输入登录用户名：");
                user = scanner.next();
                System.out.println("请输入主机IP：");
                ip = scanner.next();
                System.out.println("请输入登录状态（1表示登录，0表示登出）：");
                logType = scanner.nextInt();
                if (logType == 0 || logType == 1) {
                    break;
                } else {
                    throw new IllegalArgumentException("非法的登录状态");
                }
            } catch (Exception e) {
                System.out.println("输入错误，请重新输入");
                scanner.nextLine();
            }
        }
        return new LogRec(id, nowDate, address, type, user, ip, logType);
    }
    public void showLog(List<LogRec> logRecs) {
        System.out.println("日志信息：");
        for (LogRec logRec : logRecs) {
            System.out.println(logRec);
        }
    }
    // 匹配日志信息输出，参数是集合
    public void showMatchLog(List<MatchedLogRec> matchLogs) {
        System.out.println("匹配日志信息：");
        for (MatchedLogRec matchLog : matchLogs) {
            System.out.println(matchLog);
        }
    }
    // 保存
    public static void saveLogRec(List<LogRec> matchLogs) {
        try {
            AppendObjectOutputStream.setFile(new File(saveFile));
            File file = AppendObjectOutputStream.getFile();
            FileOutputStream fileOut = new FileOutputStream(file, true);
            AppendObjectOutputStream objOut = new AppendObjectOutputStream(file);
            for (LogRec matchLog : matchLogs) {
                objOut.writeObject(matchLog);
            }
            objOut.close();
            fileOut.close();
            System.out.println("匹配日志信息保存成功\n");
        } catch (IOException e) {
            System.out.println("保存匹配日志信息发生异常：" + e.getMessage()+"\n");
        }
    }
    //匹配
    public static List<MatchedLogRec> readMatchLogRec() {
        List<MatchedLogRec> matchedLogs = new ArrayList<>();
        List<LogRec> logs = new ArrayList<>();
        try {
            AppendObjectOutputStream.setFile(new File(saveFile));
            File file = AppendObjectOutputStream.getFile();
            if (!file.exists()) {
                file.createNewFile();
            }
            FileInputStream fileIn = new FileInputStream(file);
            // 创建一个ObjectInputStream对象输入流，并连接文件输入流
            ObjectInputStream objIn = new ObjectInputStream(fileIn);
            // 使用异常处理和EOFException异常处理读取结束
            try {
                while (true) {
                    LogRec log = (LogRec) objIn.readObject();
                    logs.add(log);
                }
            } catch (EOFException e) {
                // 读取结束，不做任何操作
            }
            // 创建日志数据分析对象
            LogRecAnalyse logAnalyse = new LogRecAnalyse(logs);
            // 日志数据过滤
            logAnalyse.doFilter();
            // 日志数据匹配分析
            try {
                List<MatchedLogRec> objs = logAnalyse.matchData(); // 进行数据匹配
                // 处理匹配的日志数据
                // 判断objs集合是否是配置日志集合
                if (objs instanceof List<?>) {
                    // 将集合强制类型转换成配置日志集合
                    matchedLogs = (List<MatchedLogRec>) objs;
                    // 输出匹配的日志信息
                    System.out.println("匹配日志信息如下：");
                    for (MatchedLogRec log : matchedLogs) {
                        if (log != null) {
                            System.out.println(log);
                        }
                    }
                    System.out.println("\n");
                }
            } catch (DataAnalyseException e) {
                System.out.println(e.getMessage());
            }
            objIn.close();
            fileIn.close();
            System.out.println("匹配日志信息读取完成\n");
        } catch (IOException | ClassNotFoundException e) {
            System.out.println("读取匹配日志信息发生异常：" + e.getMessage()+"\n");
        }
        return matchedLogs;
    }
    //显示
    public static List<LogRec> readLogRec() {
        List<LogRec> logs = new ArrayList<>();
        try {
            AppendObjectOutputStream.setFile(new File(saveFile));
            File file = AppendObjectOutputStream.getFile();
            if (!file.exists()) {
                file.createNewFile();
            }
            FileInputStream fileIn = new FileInputStream(file);
            // 创建一个ObjectInputStream对象输入流，并连接文件输入流
            ObjectInputStream objIn = new ObjectInputStream(fileIn);
            // 使用异常处理和EOFException异常处理读取结束
            try {
                while (true) {
                    LogRec log = (LogRec) objIn.readObject();
                    logs.add(log);
                }
            } catch (EOFException e) {
                // 读取结束，不做任何操作
            }
            // 输出的日志信息
            System.out.println("日志信息如下：");
            for (LogRec log : logs) {
                if (log != null) {
                    System.out.println(log);
                }
            }
            objIn.close();
            fileIn.close();
            System.out.println("日志信息读取完成\n");
        } catch (IOException | ClassNotFoundException e) {
            System.out.println("读取日志信息发生异常：" + e.getMessage() +"\n");
        }
        return logs;
    }
}

【任务9.3】修改TransportService类，在该类中增加三个方法，分别用于保存匹配的物流信息，和读取匹配的物流信息，实现匹配物流信息的保存和读取功能．

// 存储物流数据的文件名
private static final String  saveFile = "MatchedTransport.dat";
// 匹配物流信息保存，参数是集合
public void saveMatchedTransport(List<MatchedTransport> matchTrans) {
// 创建一个ObjectOutputStream对象输出流，并连接文件输出流
// 以可追加的方式创建文件输出流，数据保存到MatchedTransport.dat文件中
}
// 读匹配物流信息保存，参数是集合
public List<MatchedTransport> readMatchedTransport(){
List<MatchedTransport> matchTrans = new ArrayList<>();
// 创建一个ObjectInputStream对象输入流，并连接文件输入流，读MatchedTransport.dat文件中
　　　//读取文件之前，首先判断文件是否存在，如果不存在，则创建一个空文件
//读取文件中的所有对象时，可以使用异常处理和EOFException异常处理读取结束
//读取数据结束后，关闭文件流。
}
// 读匹配物流信息保存，参数是集合
public List<Transport> readTransport(){
List<Transport> matchTrans = new ArrayList<>();
// 创建一个ObjectInputStream对象输入流，并连接文件输入流，读MatchedTransport.dat文件中
　　　//读取文件之前，首先判断文件是否存在，如果不存在，则创建一个空文件
//读取文件中的所有对象时，可以使用异常处理和EOFException异常处理读取结束
//读取数据结束后，关闭文件流。
}

程序设计

package com.qst.dms.service;
import com.qst.dms.entity.MatchedTransport;
import com.qst.dms.entity.Transport;
import com.qst.dms.exception.DataAnalyseException;
import com.qst.dms.gather.TransportAnalyse;
import com.qst.dms.util.AppendObjectOutputStream;
import java.io.*;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Scanner;
public class TransportService {
    private static final String  saveFile = "MatchedTransport.dat";
    private Scanner scanner;
    public TransportService() {
        scanner = new Scanner(System.in);
    }
    public Transport inputTransport() {
        int transportType;
        int id, type;
        Date nowDate;
        String address, handler, receiver;
        while (true) {
            try {
                System.out.println("请输入ID标识：");
                id = scanner.nextInt();
                nowDate = new Date();
                System.out.println("请输入地址：");
                address = scanner.next();
                type = Transport.GATHER;
                System.out.println("请输入货物经手人：");
                handler = scanner.next();
                System.out.println("请输入收货人：");
                receiver = scanner.next();
                System.out.println("请输入物流状态（1表示发货中，2表示送货中，3表示已签收）：");
                transportType = scanner.nextInt();
                if (transportType == 1 || transportType == 2 || transportType == 3) {
                    break;
                } else {
                    throw new IllegalArgumentException("非法的物流状态");
                }
            } catch (Exception e) {
                System.out.println("输入错误，请重新输入");
                scanner.nextLine();
            }
        }
        return new Transport(id, nowDate, address, type, handler, receiver, transportType);
    }
    public void showTransport(List<Transport> transports) {
        System.out.println("物流信息：");
        for (Transport transport : transports) {
            System.out.println(transport);
        }
    }
    // 匹配物流信息输出，参数是集合
    public void showMatchTransport(List<MatchedTransport> matchTrans) {
        System.out.println("匹配物流信息：");
        for (MatchedTransport matchTran : matchTrans) {
            System.out.println(matchTran);
        }
    }
    // 保存
    public static void saveTransport(List<Transport> transports) {
        try {
            AppendObjectOutputStream.setFile(new File(saveFile));
            File file = AppendObjectOutputStream.getFile();
            FileOutputStream fileOut = new FileOutputStream(file, true);
            AppendObjectOutputStream objOut = new AppendObjectOutputStream(file);
            for (Transport transport : transports) {
                objOut.writeObject(transport);
            }
            objOut.close();
            fileOut.close();
            System.out.println("匹配物流信息保存成功\n");
        } catch (IOException e) {
            System.out.println("保存匹配物流信息发生异常：" + e.getMessage()+"\n");
        }
    }
    //匹配
    public static List<MatchedTransport> readMatchTransport() {
        List<MatchedTransport> matchedTransports = new ArrayList<>();
        List<Transport> transports = new ArrayList<>();
        try {
            AppendObjectOutputStream.setFile(new File(saveFile));
            File file = AppendObjectOutputStream.getFile();
            if (!file.exists()) {
                file.createNewFile();
            }
            FileInputStream fileIn = new FileInputStream(file);
            // 创建一个ObjectInputStream对象输入流，并连接文件输入流
            ObjectInputStream objIn = new ObjectInputStream(fileIn);
            // 创建物流数据分析对象
            TransportAnalyse ta = new TransportAnalyse(transports);
            // 物流数据过滤
            ta.doFilter();
            try {
                // 物流数据分析
                List<MatchedTransport> objs = ta.matchData();
                // 判断objs集合是否是匹配物流集合
                if (objs instanceof List<?>) {
                    // 将集合强制类型转换成匹配物流集合
                    matchedTransports = (List<MatchedTransport>) objs;
                    // 输出匹配的物流信息
                    System.out.println("匹配物流信息如下：");
                    for (MatchedTransport transport : matchedTransports) {
                        if (transport != null) {
                            System.out.println(transport);
                        }
                    }
                    System.out.println("\n");
                }
            } catch (DataAnalyseException e) {
                System.out.println(e.getMessage());
            }
            objIn.close();
            fileIn.close();
            System.out.println("匹配物流信息读取完成\n");
        } catch (IOException e) {
            System.out.println("读取匹配物流信息发生异常：" + e.getMessage() +"\n");
        }
        return matchedTransports;
    }
    //显示
    public static List<Transport> readTransport() {
        List<Transport> transports = new ArrayList<>();
        try {
            AppendObjectOutputStream.setFile(new File(saveFile));
            File file = AppendObjectOutputStream.getFile();
            if (!file.exists()) {
                file.createNewFile();
            }
            FileInputStream fileIn = new FileInputStream(file);
            // 创建一个ObjectInputStream对象输入流，并连接文件输入流
            ObjectInputStream objIn = new ObjectInputStream(fileIn);
            // 使用异常处理和EOFException异常处理读取结束
            try {
                while (true) {
                    Transport transport = (Transport) objIn.readObject();
                    transports.add(transport);
                }
            } catch (EOFException e) {
                // 读取结束，不做任何操作
            }
            objIn.close();
            fileIn.close();
            // 输出的物流信息
            System.out.println("物流信息如下：");
            for (Transport transport : transports) {
                if (transport != null) {
                    System.out.println(transport);
                }
            }
            System.out.println("物流信息读取完成\n");
        } catch (IOException | ClassNotFoundException e) {
            System.out.println("读取物流信息发生异常：" + e.getMessage() +"\n");
        }
        return transports;
    }
}

【任务9.4】在com.qst.dms.dos下创建测试类FileDemo，测试匹配的日志、物流信息的保存和读写功能

测试数据如下：

new LogRec(1001, new Date(), "青島",DataBase.GATHER, "zhangsan", "192.168.1.1", 1),
new LogRec(1002, new Date(), "青島", DataBase.GATHER, "zhangsan", "192.168.1.1", 0)));
new LogRec(1003, new Date(), "北京",DataBase.GATHER, "lisi", "192.168.1.6", 1),
new LogRec(1004, new Date(), "北京", DataBase.GATHER, "lisi", "192.168.1.6", 0)));
new LogRec(1005, new Date(), "济南",DataBase.GATHER, "wangwu", "192.168.1.89", 1),
new LogRec(1006, new Date(), "济南", DataBase.GATHER, "wangwu", "192.168.1.89", 0)));
new Transport(2001, new Date(), "青島",DataBase.GATHER,"zhangsan","zhaokel",1),
new Transport(2002, new Date(), "北京",DataBase.GATHER,"lisi","zhaokel",2),
new Transport(2003, new Date(), "北京",DataBase.GATHER,"wangwu","zhaokel",3)));
new Transport(2004, new Date(), "青島",DataBase.GATHER,"maliu","zhaokel",1),
new Transport(2005, new Date(), "北京",DataBase.GATHER,"sunqi","zhaokel",2),
new Transport(2006, new Date(), "北京",DataBase.GATHER,"fengba","zhaokel",3)))

程序设计

package com.qst.dms.dos;
import com.qst.dms.entity.*;
import com.qst.dms.service.LogRecService;
import com.qst.dms.service.TransportService;
import java.util.*;
public class FileDemo {
    public static void main(String[] args) {
        List<LogRec> logs = new ArrayList<>();
        List<Transport> transports = new ArrayList<>();
        //日志信息
        logs.add(new LogRec(1001, new Date(), "青島", DataBase.GATHER, "zhangsan", "192.168.1.1", 1));
        logs.add(new LogRec(1002, new Date(), "青島", DataBase.GATHER, "zhangsan", "192.168.1.1", 0));
        logs.add(new LogRec(1003, new Date(), "北京", DataBase.GATHER, "lisi", "192.168.1.6", 1));
        logs.add(new LogRec(1004, new Date(), "北京", DataBase.GATHER, "lisi", "192.168.1.6", 0));
        logs.add(new LogRec(1005, new Date(), "济南", DataBase.GATHER, "wangwu", "192.168.1.89", 1));
        logs.add(new LogRec(1006, new Date(), "济南", DataBase.GATHER, "wangwu", "192.168.1.89", 0));
        //物流信息
        transports.add(new Transport(2001, new Date(), "青島",DataBase.GATHER,"zhangsan","zhaokel",1));
        transports.add(new Transport(2002, new Date(), "北京",DataBase.GATHER,"lisi","zhaokel",2));
        transports.add(new Transport(2003, new Date(), "北京",DataBase.GATHER,"wangwu","zhaokel",3));
        transports.add(new Transport(2004, new Date(), "青島",DataBase.GATHER,"maliu","zhaokel",1));
        transports.add(new Transport(2005, new Date(), "北京",DataBase.GATHER,"sunqi","zhaokel",2));
        transports.add(new Transport(2006, new Date(), "北京",DataBase.GATHER,"fengba","zhaokel",3));
        //日志测试
        LogRecService.saveLogRec(logs);
        LogRecService.readMatchLogRec();
        LogRecService.readLogRec();
        //物流测试
        TransportService.saveTransport(transports);
        TransportService.readMatchTransport();
        TransportService.readTransport();
    }
}

【任务9.5】 以上的文件的保存，由于使用ObjectOutputStream，在多次进行打开—写入—关闭一个文件时，会出现异常，无法读取所有数据，可以利用下面的方法解决：

下面类主要解决使用ObjectOutputStream进行多次写入数据时，流信息重复写入的问题。

使用AppendObjectOutputStream类，修改上面的文件保存方法

创建了AppendObjectOutputStream的流操作对象收，必修执行

设置数据文件，否则在处理流信息写入时会出现错误，无法完成正确的数据存储功能。

程序设计

package com.qst.dms.util;
import java.io.*;
public class AppendObjectOutputStream extends ObjectOutputStream {
    private static File file = null;
    public static File getFile(){
        return file;
    }
    public static void setFile(File file){
        AppendObjectOutputStream.file = file;
    }
    public AppendObjectOutputStream() throws IOException,SecurityException{
        super();
    }
    public AppendObjectOutputStream(File file) throws IOException,SecurityException{
        super(new FileOutputStream(file,true));
    }
    public void writeStreamHeader() throws IOException{
        if(file==null||(file.exists()&&file.length()==0)){
            super.writeStreamHeader();
        }else{
            this.reset();
        }
    }
}

【任务9.6】 将数据保存功能，集成到MenuDriver，并进行测试。

程序设计

package com.qst.dms.dos;
import com.qst.dms.entity.LogRec;
import com.qst.dms.entity.MatchedLogRec;
import com.qst.dms.entity.MatchedTransport;
import com.qst.dms.entity.Transport;
import com.qst.dms.exception.DataAnalyseException;
import com.qst.dms.gather.LogRecAnalyse;
import com.qst.dms.gather.TransportAnalyse;
import com.qst.dms.service.LogRecService;
import com.qst.dms.service.TransportService;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class MenuDriver {
    public static void main(String[] args) {
        // 建立一个从键盘接收数据的扫描器
        Scanner scanner = new Scanner(System.in);
        // 创建一个泛型ArrayList集合存储日志数据
        List<LogRec> logRecList = new ArrayList<>();
        // 创建一个泛型ArrrayList集合存储物流数据
        List<Transport> transportList = new ArrayList<>();
        // 创建一个日志业务类
        LogRecService logService = new LogRecService();
        // 创建一个物流业务类
        TransportService tranService = new TransportService();
        // 日志数据匹配集合
        List<MatchedLogRec> matchedLogs = null;
        // 物流数据匹配集合
        List<MatchedTransport> matchedTrans = null;
        // 运行菜单选择
        while (true) {
            System.out.println("请选择操作：");
            System.out.println("1. 采集数据");
            System.out.println("2. 数据匹配");
            System.out.println("3. 显示数据");
            System.out.println("4. 退出");
            // 接收键盘输入的选项
            try {
                int choice = scanner.nextInt();
                int type;
                switch (choice) {
                    case 1:
                        System.out.println("请输入采集数据类型：1.日志  2.物流");
                        // 接收键盘输入的选项
                        type = scanner.nextInt();
                        if (type == 1) {
                            System.out.println("正在采集日志数据，请输入正确信息，确保数据的正常采集！");
                            // 采集日志数据
                            LogRec log = logService.inputLog();
                            // 将采集的日志数据添加到logRecList集合中
                            logRecList.add(log);
                            LogRecService.saveLogRec(logRecList);
                        } else if (type == 2) {
                            System.out.println("正在采集物流数据，请输入正确信息，确保数据的正常采集！");
                            // 采集物流数据
                            Transport tran = tranService.inputTransport();
                            // 将采集的物流数据添加到transportList集合中
                            transportList.add(tran);
                            TransportService.saveTransport(transportList);
                        }
                        break;
                    case 2:
                        System.out.println("请输入匹配数据类型：1.日志  2.物流");
                        // 接收键盘输入的选项
                        type = scanner.nextInt();
                        if (type == 1) {
                            System.out.println("匹配日志数据如下：");
                            // 数据匹配
                            LogRecService.readMatchLogRec();
                        } else if (type == 2) {
                            System.out.println("匹配物流数据如下：");
                            // 数据匹配
                            TransportService.readMatchTransport();
                        }
                        break;
                    case 3:
                        System.out.println("请输入显示原始数据类型：1.日志  2.物流");
                        // 接收键盘输入的选项
                        type = scanner.nextInt();
                        if (type == 1) {
                            // 显示日志数据
                            LogRecService.readLogRec();
                        } else if (type == 2) {
                            // 显示物流数据
                            TransportService.readTransport();
                        }
                        break;
                    case 4:
                        System.out.println("谢谢使用！");
                        return;
                    default:
                        System.out.println("无效选项，请重新选择！");
                }
            } catch (Exception e) {
                System.out.println("非法输入，请重新输入！");
                scanner.nextLine();
            }
        }
    }
}

文章标签：
数据管理
日志服务
数据挖掘
数据库管理
存储
关键词：
数据管理项目
数据挖掘项目
实训dms数据挖掘项目
实训数据管理数据挖掘项目
相关实践学习
MySQL基础-学生管理系统数据库设计
本场景介绍如何使用DMS工具连接RDS，并使用DMS图形化工具创建数据库表。
Want595
目录
相关文章
Want595
|
监控 数据挖掘 数据库
【技能实训】DMS数据挖掘项目（完整程序） 1
【技能实训】DMS数据挖掘项目（完整程序）
Want595
123 0
Want595
|
数据挖掘 数据库 数据库管理
【技能实训】DMS数据挖掘项目-Day14
【技能实训】DMS数据挖掘项目-Day14
Want595
69 1
Want595
|
存储 数据挖掘 测试技术
【技能实训】DMS数据挖掘项目（完整程序）2
【技能实训】DMS数据挖掘项目（完整程序）
Want595
83 0
飞翔的佩奇
|
6月前
|
前端开发 Java 数据管理
javaWeb基于SSM框架开发的社区医疗数据管理系统【项目源码+数据库脚本+报告】
javaWeb基于SSM框架开发的社区医疗数据管理系统【项目源码+数据库脚本+报告】
飞翔的佩奇
106 0
zrblue
|
6月前
|
数据管理 程序员 人工智能
后台数据管理系统 - 项目架构设计【黑马程序员】
后台数据管理系统 - 项目架构设计【黑马程序员】
zrblue
253 0
后台数据管理系统 - 项目架构设计【黑马程序员】
Want595
|
存储 数据挖掘 Java
【技能实训】DMS数据挖掘项目-Day15
【技能实训】DMS数据挖掘项目-Day15
Want595
71 0
土木林森
|
3月前
|
物联网 数据管理 Apache
拥抱IoT浪潮，Apache IoTDB如何成为你的智能数据守护者？解锁物联网新纪元的数据管理秘籍！
【8月更文挑战第22天】随着物联网技术的发展，数据量激增对数据库提出新挑战。Apache IoTDB凭借其面向时间序列数据的设计，在IoT领域脱颖而出。相较于传统数据库，IoTDB采用树形数据模型高效管理实时数据，具备轻量级结构与高并发能力，并集成Hadoop/Spark支持复杂分析。在智能城市等场景下，IoTDB能处理如交通流量等数据，为决策提供支持。IoTDB还提供InfluxDB协议适配器简化迁移过程，并支持细致的权限管理确保数据安全。综上所述，IoTDB在IoT数据管理中展现出巨大潜力与竞争力。
土木林森
100 1
三分钟热度的鱼
|
4月前
|
SQL NoSQL 数据管理
数据管理DMS使用问题之如何批量导入MongoDB的数据文件
阿里云数据管理DMS提供了全面的数据管理、数据库运维、数据安全、数据迁移与同步等功能，助力企业高效、安全地进行数据库管理和运维工作。以下是DMS产品使用合集的详细介绍。
三分钟热度的鱼
69 3
数据库小能手
|
2天前
|
关系型数据库 分布式数据库 数据库
云栖大会｜从数据到决策：AI时代数据库如何实现高效数据管理？
在2024云栖大会「海量数据的高效存储与管理」专场，阿里云瑶池讲师团携手AMD、FunPlus、太美医疗科技、中石化、平安科技以及小赢科技、迅雷集团的资深技术专家深入分享了阿里云在OLTP方向的最新技术进展和行业最佳实践。
数据库小能手
15 4
瓴羊Dataphin
|
17天前
|
存储 人工智能 安全
【荣誉奖项】荣获2024数据治理优秀产品！瓴羊Dataphin联合DAMA发布数据管理技能认证
瓴羊Dataphin连续俩年获得DAMA年度优秀数据治理产品奖，本次与DAMA联合发布“DAMA x 瓴羊 数据管理技能认证”，助力提升全民数据素养。
瓴羊Dataphin
127 0
【荣誉奖项】荣获2024数据治理优秀产品！瓴羊Dataphin联合DAMA发布数据管理技能认证

热门文章

最新文章

  • 1
    Data Fabric：一站式数据管理与服务
  • 2
    十年磨一剑，阿里巴巴企业级数据管理平台：iDB
  • 3
    数据管理(DMS)：让你轻松管理云端数据
  • 4
    MySQL数据管理5
  • 5
    Docker数据管理
  • 6
    运维平台的建设思考-元数据管理（二）
  • 7
    运维平台的建设思考-元数据管理（四）
  • 8
    阿里云DMS数据管理控制台通过钉钉机器人方式发送通知
  • 9
    《云数据管理：挑战与机遇》一第1章
  • 10
    小微企业阿里云最佳实践系列（二）：RDS 数据库与DMS 数据库管理（数据管理）
  • 1
    探索数据挖掘中的特征选择算法
    115
  • 2
    API电商接口大数据分析与数据挖掘 （商品详情店铺）
    507
  • 3
    预测未来：Python 数据挖掘案例
    296
  • 4
    数据挖掘实战：基于KMeans算法对超市客户进行聚类分群
    681
  • 5
    【Python数据挖掘】优化电能能源策略：基于非侵入式负荷检测与分解的智能解决方案
    92
  • 6
    Python数据挖掘项目实战——自动售货机销售数据分析
    216
  • 7
    基于非侵入式负荷检测与分解的电力数据挖掘
    90
  • 8
    通过案例理解数据挖掘
    96
  • 9
    数据挖掘之旅：京东商品详情API与销售策略的优化
    70
  • 10
    探索大数据时代的关键技术：数据挖掘、可视化和数据仓库
    488

    • 相关课程

    更多
  • 数据管理 DMS产品介绍及Data Copilot演示教程智能助手 DMS Data Copilot简介
  • 存储应用与数据管理
  • 高校精品课-北京理工大学-数据仓库与数据挖掘（下）
  • 高校精品课-北京理工大学-数据仓库与数据挖掘（上）
  • 数据分析系统之数据管理与数据仓库
  • 数据挖掘入门与实践

    • 相关电子书

    更多
  • 金融行业高频交易数据管理解决方案
  • 基于Spark的统一数据管理与数据探索平台
  • INFINIDATA:基于Spark的统一数据管理与探索平台

    • 相关实验场景

    更多
  • 【涂鸦即艺术】基于云应用开发平台CAP部署AI实时生图绘板
  • 奥运时刻！零代码生成奥运风格AI写真。
  • 【AI破次元壁合照】少年白马醉春风，函数计算一键部署AI绘画平台
  • 基于Hologres+PAI+计算巢，5分钟搭建企业级AI问答知识库
  • 倚天大数据电商数据分析快速实践
  • 温控器设备接入IoT物联网平台与数据管理实践
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月