备案控制台
探索云世界
开发者社区 大数据 文章 正文

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

2023-10-12 25
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
数据管理 DMS，安全协同 3个实例 3个月
推荐场景：
学生管理系统数据库
简介： 【技能实训】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数据挖掘
数据挖掘项目
实训dms数据挖掘项目
实训数据管理数据挖掘项目
Want595
目录
相关文章
Want595
|
6月前
|
监控 数据挖掘 数据库
【技能实训】DMS数据挖掘项目（完整程序） 1
【技能实训】DMS数据挖掘项目（完整程序）
Want595
73 0
Want595
|
6月前
|
存储 数据挖掘 测试技术
【技能实训】DMS数据挖掘项目（完整程序）2
【技能实训】DMS数据挖掘项目（完整程序）
Want595
47 0
Want595
|
6月前
|
数据挖掘 数据库 数据库管理
【技能实训】DMS数据挖掘项目-Day14
【技能实训】DMS数据挖掘项目-Day14
Want595
40 1
飞翔的佩奇
|
3月前
|
前端开发 Java 数据管理
javaWeb基于SSM框架开发的社区医疗数据管理系统【项目源码+数据库脚本+报告】
javaWeb基于SSM框架开发的社区医疗数据管理系统【项目源码+数据库脚本+报告】
飞翔的佩奇
56 0
zrblue
|
3月前
|
数据管理 程序员 人工智能
后台数据管理系统 - 项目架构设计【黑马程序员】
后台数据管理系统 - 项目架构设计【黑马程序员】
zrblue
142 0
后台数据管理系统 - 项目架构设计【黑马程序员】
Want595
|
6月前
|
存储 数据挖掘 Java
【技能实训】DMS数据挖掘项目-Day15
【技能实训】DMS数据挖掘项目-Day15
Want595
35 0
三分钟热度的鱼
|
1月前
|
Web App开发 缓存 数据库
DMS产品常见问题之DMS数据规定失败如何解决
DMS（数据管理服务，Data Management Service）是阿里云提供的一种数据库管理和维护工具，它支持数据的查询、编辑、分析及安全管控；本汇总集中了DMS产品在实际使用中用户常遇到的问题及其相应的解答，目的是为使用者提供快速参考，帮助他们有效地解决在数据管理过程中所面临的挑战。
三分钟热度的鱼
25 1
晓之以理的喵~~
|
4月前
|
数据管理 数据库 数据安全/隐私保护
数据管理与持久化：深度解析Docker数据卷
Docker 数据卷在容器化应用中扮演着关键角色，它们提供了一种灵活且可持久化的方式来处理应用数据。本文将深入讨论 Docker 数据卷的基本概念、使用方法以及一系列高级应用场景，通过更为丰富和实际的示例代码，帮助大家全面掌握数据卷的使用和管理。
晓之以理的喵~~
62 0
1941623231718325
|
9天前
|
存储 Oracle 数据管理
Oracle 12c的自动数据优化（ADO）与热图：数据管理的“瘦身”与“透视”艺术
【4月更文挑战第19天】Oracle 12c的ADO和热图技术革新数据管理。ADO智能清理无用数据，优化存储，提升查询速度，实现数据&quot;瘦身&quot;；热图则以直观的视觉表示展示数据分布和状态，助力识别性能瓶颈，犹如数据的&quot;透视&quot;工具。这两项技术结合，强化数据管理，为企业业务发展保驾护航。
1941623231718325
17 0
技术君
|
16天前
|
人工智能 安全 数据处理
首次全国数据工作会议召开，数据管理体制建设迈上新台阶
首次全国数据工作会议召开，数据管理体制建设迈上新台阶
技术君
24 1

热门文章

最新文章

  • 1
    首次全国数据工作会议召开，数据管理体制建设迈上新台阶
  • 2
    探索数据挖掘中的特征选择算法
  • 3
    Oracle 12c的自动数据优化（ADO）与热图：数据管理的“瘦身”与“透视”艺术
  • 4
    Oracle 12c多租户架构：数据管理的“摩天大楼”
  • 5
    SAS，R和Python应对数据管理和分析挑战
  • 6
    API电商接口大数据分析与数据挖掘 （商品详情店铺）
  • 7
    数据仓库(12)数据治理之数仓数据管理实践心得
  • 8
    数据库系统架构与DBMS功能探微：现代信息时代数据管理的关键
  • 9
    Docker卷和数据管理
  • 10
    【Python数据挖掘课程】八.关联规则挖掘及Apriori实现购物推荐
  • 1
    Docker卷和数据管理
    16
  • 2
    数据仓库(12)数据治理之数仓数据管理实践心得
    306
  • 3
    数据库系统架构与DBMS功能探微：现代信息时代数据管理的关键
    36
  • 4
    从设计模式看前端开发中的数据管理
    12
  • 5
    AWS Database Migration Service (DMS)
    43
  • 6
    DMS问题之恢复数据如何解决
    43
  • 7
    DMS问题之从归档目标手动恢复数据到源如何解决
    40
  • 8
    DMS问题之删除数据库报错如何解决
    56
  • 9
    DMS问题之异常慢如何解决
    57
  • 10
    DMS问题之数据库执行超时如何解决
    56

    • 相关课程

    更多
  • 存储应用与数据管理
  • 高校精品课-北京理工大学-数据仓库与数据挖掘（下）
  • 高校精品课-北京理工大学-数据仓库与数据挖掘（上）
  • 数据分析系统之数据管理与数据仓库
  • 数据挖掘入门与实践
  • 数据分析训练营

    • 相关电子书

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

    • 相关实验场景

    更多
  • 基于Hologres+PAI+计算巢，5分钟搭建企业级AI问答知识库
  • 倚天大数据电商数据分析快速实践
  • 温控器设备接入IoT物联网平台与数据管理实践
  • 【企业数据中台交付】数据回刷实验
  • 高效敏捷开发体验
  • 基于MaxCompute的热门话题分析
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）