备案控制台
探索云世界
开发者社区 人工智能 文章 正文

[零基础学JAVA]Java SE实战开发-37.MIS信息管理系统实战开发[文件保存]（1）

2017-11-01 1109
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：
MIS信息管理系统实战开发之单独使用文件实现保存
image
开发背景
image
ID、姓名、年龄为公共信息，而学生有成绩，工人有工资
定义一个抽象类Person（ID、姓名、年龄），学生是其子类，有成绩，工人是其子类有工资
ID如何定义呢？ 
ID最好可以自己生成，最好的方式是采用下面的编码方式： 
· 标记 + 时间戳 + 三位随机数 
· 例如：2009年3月22 20:10:10.345 
· 学生的标记为s，工人的标记为w 
· 生成的ID号： 学生 --> s20090322201010345023 
                           工人 --> w20090322201010345023 
因为现在的程序要满足文件和数据库的操作标准，所以此处应该定义出一个公共的标准 —— 接口 
查询信息的时候可以进行排序操作，可以使用Comparable接口完成。
整个代码中牵扯到数据层的操作 
· 数据层就是指真实的数据操作 --> CRUD。 
· 最终结果操作的肯定是一个人（人为工人和学生） 
应该进行分开，一个是全部的学生管理，一个是全部的工人管理。 
数据层操作标准定义完成之后，有两种选择，一种是直接使用子类实现，但是以后的修改不是很方便， 
所以此处最好使用代理设计的思路完成，做一个中间层。 
代码关系： 
Main --> Menu --> PersonOperate --> DAO
因为程序即要求使用文件保存，又要求使用数据库保存，所以此处可以设计出一个工厂，通过此工厂进行DAO的操作子类实例取得。
image
 
###################Michael分割线#####################
PersonDAO.java
package org.michael.demo.dao;    

import java.util.Set;    

import org.michael.demo.vo.Person;    

// 定义具体的数据的操作方法 
public  interface PersonDAO { 
         /** 
         * 插入数据的操作 
         *    
         * @param person 
         *                        插入的是一个人员信息 
         * @return 操作成功与否的提示 
         * @throws Exception 
         *                         如果有错误，则把错误抛给调用处处理 
         */ 
         public  boolean doCreate(Person person)  throws Exception;    

         /** 
         * 更新数据操作 
         *    
         * @param person 
         *                        更新的具体信息 
         * @return 更新成功与否的提示 
         * @throws Exception 
         *                         如果有错误，则把错误抛出 
         */ 
         public  boolean doUpdate(Person person)  throws Exception;    

         /** 
         * 按id删除信息 
         *    
         * @param id 
         *                        人员的编号 
         * @return 删除与否的提示 
         * @throws Exception 
         *                         如果有错误，则在调用处处理 
         */ 
         public  boolean doDelete(String id)  throws Exception;    

         /** 
         * 因为查询是多个，所以要返回Set集合 
         *    
         * @return 全部的查询结果，一个Set中包含了多个Person对象 
         * @throws Exception 
         */ 
         public Set<Person> findAll()  throws Exception;    

         /** 
         * 按id进行查询 
         *    
         * @param id 
         *                        人员的编号 
         * @return 具体的人员信息 
         * @throws Exception 
         */ 
         public Person findById(String id)  throws Exception;    

         /** 
         * 按关键字进行查询 
         *    
         * @param keyWord 
         *                        输入的关键字 
         * @return 返回一组信息 
         * @throws Exception 
         */ 
         public Set<Person> findByLike(String keyWord)  throws Exception; 
} 
 
PersonDAOImplFile.java 
package org.michael.demo.dao.impl;    

import java.util.Iterator;    
import java.util.Set;    
import java.util.TreeSet;    

import org.michael.demo.dao.PersonDAO;    
import org.michael.demo.io.FileOperate;    
import org.michael.demo.vo.Person;    
import org.michael.demo.vo.Student;    
import org.michael.demo.vo.Worker;    

public  class PersonDAOImplFile  implements PersonDAO {    
         // 所有的内容肯定保存在一个集合之中，因为一个集合可以直接向文件中保存    
         // 此集合的内容最好由文件读取进来，因为文件本身中要保存对象，    
         // 但是此程序牵扯到第一次运行的情况    
         private Set<Person> allPerson;    
         private FileOperate fo =  null;    
         public  static String fileName =  null ;    

         // 在构造方法中为其实例化    
        @SuppressWarnings( "unchecked")    
         public PersonDAOImplFile() {    
                 this.fo =  new FileOperate(fileName);    
                 try {    
                         this.allPerson = (Set) fo.load();    
                }  catch (Exception e) {    
                        e.printStackTrace();    
                }    
        }    

         public  boolean doCreate(Person person)  throws Exception {    
                 // 就是插入操作    
                 // 在原有的基础上进行增加操作    
                 boolean flag =  false;    
                 try {    
                         this.allPerson.add(person);    
                         this.fo.save( this.allPerson);    
                        flag =  true;    
                }  catch (Exception e) {    
                         throw e;    
                }    
                 return flag;    
        }    

         public  boolean doDelete(String id)  throws Exception {    
                 boolean flag =  false;    
                 // 如果要删除之前必须先进行查找操作    
                 try {    
                         this.allPerson.remove( this.findById(id));    
                         this.fo.save( this.allPerson);    
                        flag =  true;    
                }  catch (Exception e) {    
                         throw e;    
                }    
                 return flag;    
        }    

         public  boolean doUpdate(Person person)  throws Exception {    
                 // 无论怎样更新，里面的id是不能改变的    
                 boolean flag =  false;    
                 try {    
                        Person p =  this.findById(person.getId());    
                         if (person  instanceof Student) {    
                                Student oldO = (Student) p;    
                                Student newO = (Student) person;    
                                oldO.setId(newO.getId());    
                                oldO.setName(newO.getName());    
                                oldO.setAge(newO.getAge());    
                                oldO.setScore(newO.getScore());    
                        }    
                         if (person  instanceof Worker) {    
                                Worker oldO = (Worker) p;    
                                Worker newO = (Worker) person;    
                                oldO.setId(newO.getId());    
                                oldO.setName(newO.getName());    
                                oldO.setAge(newO.getAge());    
                                oldO.setSalary(newO.getSalary());    
                        }    
                         // 进行更新操作    
                         this.allPerson.add(p);    
                         this.fo.save( this.allPerson);    
                }  catch (Exception e) {    
                         throw e;    
                }    
                 return flag;    
        }    

         public Set<Person> findAll()  throws Exception {    
                 return  this.allPerson;    
        }    

         public Person findById(String id)  throws Exception {    
                Person per =  null;    
                 try {    
                        Iterator<Person> iter =  this.allPerson.iterator();    
                         while (iter.hasNext()) {    
                                Person p = iter.next();    
                                 if (p.getId().equals(id)) {    
                                         // id匹配成功，则取出此对象    
                                        per = p;    
                                         break;    
                                }    
                        }    
                }  catch (Exception e) {    
                         throw e;    
                }    
                 return per;    
        }    

         public Set<Person> findByLike(String keyWord)  throws Exception {    
                Set<Person> search =  new TreeSet<Person>();    
                Iterator<Person> iter =  this.allPerson.iterator();    
                 while (iter.hasNext()) {    
                         // 按姓名进行模糊查询    
                        Person p = iter.next();    
                         if (p.getName().indexOf(keyWord) != -1) {    
                                 // 查到内容向search集合中存放    
                                search.add(p);    
                        }    
                }    
                 return search;    
        }    

} 
DAOFactory.java
package org.michael.demo.factory;    

import org.michael.demo.dao.PersonDAO;    
import org.michael.demo.proxy.PersonDAOProxyFile;    

public class DAOFactory {    
        public static PersonDAO getPersonDAOInstance() {    
                return null;    
        }    

        public static PersonDAO getPersonDAOInstance(String path) {    
                return new PersonDAOProxyFile(path);    
        }    
} 
 
FileOperate.java
package org.michael.demo.io;    

import java.io.File; 
import java.io.FileInputStream; 
import java.io.FileOutputStream; 
import java.io.ObjectInputStream; 
import java.io.ObjectOutputStream; 
import java.util.TreeSet;    

import org.michael.demo.vo.Person;    

public  class FileOperate { 
         private File file =  null;    

         // 在够方法处必须指定保存文件的名字 
         public FileOperate(String path) { 
                 this.file =  new File(path); 
                 if (! this.file.exists()) { 
                         // 如果内容不存在，则认为是第一次操作，需要初始化 
                         try { 
                                 this.save( new TreeSet<Person>()) ; 
                        }  catch (Exception e) { 
                                e.printStackTrace(); 
                        } 
                } 
        }    

         // 把对象保存在文件之中 
         public  void save(Object obj)  throws Exception { 
                ObjectOutputStream out =  null; 
                 try { 
                        out =  new ObjectOutputStream( new FileOutputStream( this.file)); 
                         // 写入对象 
                        out.writeObject(obj); 
                }  catch (Exception e) { 
                         throw e; 
                }  finally { 
                         try { 
                                out.close(); 
                        }  catch (Exception e) { 
                        } 
                } 
        }    

         // 把对象从文件之中读进来 
         public Object load()  throws Exception { 
                Object obj =  null; 
                ObjectInputStream input =  null; 
                 try { 
                        input =  new ObjectInputStream( new FileInputStream( this.file)); 
                        obj = input.readObject(); 
                }  catch (Exception e) { 
                         throw e; 
                }  finally { 
                         try { 
                                input.close(); 
                        }  catch (Exception e) { 
                        } 
                } 
                 return obj; 
        } 
} 
 
Main.java 
package org.michael.demo.main;    

import org.michael.demo.menu.Menu;    

public  class Main {    
         public  static  void main(String[] args) {    
                 new Menu();    
        }    
}
 
Menu.java 
package org.michael.demo.menu;    

import org.michael.demo.operate.PersonOperate;    
import org.michael.demo.operate.StudentOperate;    
import org.michael.demo.operate.WorkerOperate;    
import org.michael.demo.util.InputData;    

public  class Menu {    
         private InputData input =  null;    
         private PersonOperate po =  null;    
         private  boolean sflag =  true;    
         private  boolean wflag =  true;    

         // 菜单要有增加信息、修改信息等的功能，增加信息的时候要选择是增加学生还是工人    
         public Menu() {    
                 this.input =  new InputData();    
                 while ( true) {    
                         this.showMain();    
                }    
        }    

         // 显示主菜单    
         public  void showMain() {    
                System.out.println( "                    学校信息管理程序                            ");    
                System.out.println( "                    1、学生信息管理                             ");    
                System.out.println( "                    2、工人信息管理                             ");    
                System.out.println( "                    3、退出系统                                     ");    
                 // 要进行选择    
                System.out.println( "\n\n 请选择所要的操作：");    
                 switch (input.getInt()) {    
                 case 1: {    
                         this.sflag =  true;    
                         while (sflag) {    
                                 this.showStudent();    
                        }    
                         break;    
                }    
                 case 2: {    
                         this.wflag =  true;    
                         while (wflag) {    
                                 this.showWorker();    
                        }    
                         break;    
                }    
                 case 3: {    
                        System.out.println( "系统退出，拜拜~~~") ;    
                        System.exit(1);    
                         break;    
                }    
                 default: {    
                        System.out.println( "            选择错误，请重新选择！");    
                         break;    
                }    
                }    
        }    

         // 显示学生操作的菜单    
         public  void showStudent() {    
                 this.po =  new StudentOperate();    
                System.out.println( "                        学生信息管理                                 ");    
                System.out.println( "                     1、增加学生信息                             ");    
                System.out.println( "                     2、列出全部学生信息                     ");    
                System.out.println( "                     3、查询学生信息                             ");    
                System.out.println( "                     4、删除学生信息                             ");    
                System.out.println( "                     5、修改学生信息                             ");    
                System.out.println( "                     6、返回上一级菜单                         ");    
                System.out.println( "\n\n请选择具体的操作：");    
                 switch ( this.input.getInt()) {    
                 case 1: {    
                         this.po.add();    
                         break;    
                }    
                 case 2: {    
                         this.po.findAll();    
                         break;    
                }    
                 case 3: {    
                         this.po.findByLike();    
                         break;    
                }    
                 case 4: {    
                         this.po.delete();    
                         break;    
                }    
                 case 5: {    
                         this.po.update();    
                         break;    
                }    
                 case 6: {    
                         this.sflag =  false;    
                         break;    
                }    
                 default: {    
                        System.out.println( "            选择错误，请重新选择！");    
                         break;    
                }    
                }    
        }    

         // 显示工人操作的菜单    
         public  void showWorker() {    
                 this.po =  new WorkerOperate();    
                System.out.println( "                        工人信息管理                                 ");    
                System.out.println( "                     1、增加工人信息                             ");    
                System.out.println( "                     2、列出全部工人信息                     ");    
                System.out.println( "                     3、查询工人信息                             ");    
                System.out.println( "                     4、删除工人信息                             ");    
                System.out.println( "                     5、修改工人信息                             ");    
                System.out.println( "                     6、返回上一级菜单                         ");    
                System.out.println( "\n\n请选择具体的操作：");    
                 switch ( this.input.getInt()) {    
                 case 1: {    
                         this.po.add();    
                         break;    
                }    
                 case 2: {    
                         this.po.findAll();    
                         break;    
                }    
                 case 3: {    
                         this.po.findByLike();    
                         break;    
                }    
                 case 4: {    
                         this.po.delete();    
                         break;    
                }    
                 case 5: {    
                         this.po.update();    
                         break;    
                }    
                 case 6: {    
                         this.wflag =  false;    
                         break;    
                }    
                 default: {    
                        System.out.println( "            选择错误，请重新选择！");    
                         break;    
                }    
                }    
        }    
} 
 
PersonOperate.java 
package org.michael.demo.operate;    

public  interface PersonOperate {    
         public  void add();    

         public  void delete();    

         public  void update();    

         public  void findAll();    

         public  void findByLike();    
} 
 
  StudentOperate.java
package org.michael.demo.operate;    

import java.util.Iterator;    

import org.michael.demo.dao.PersonDAO;    
import org.michael.demo.util.InputData;    
import org.michael.demo.util.TimeStamp;    
import org.michael.demo.vo.Person;    
import org.michael.demo.vo.Student;    
import org.michael.demo.factory.*;    

public  class StudentOperate  implements PersonOperate {    
         private PersonDAO dao =  null;    
         private InputData input =  null;    

         public StudentOperate() {    
                 this.dao = DAOFactory.getPersonDAOInstance( "student.ser");    
                 this.input =  new InputData();    
        }    

         public  void add() {    
                String id =  new TimeStamp( "s").getTimeStampRandom();    
                System.out.print( "输入学生姓名：");    
                String name =  this.input.getString();    
                System.out.print( "输入学生年龄：");    
                 int age =  this.input.getInt();    
                System.out.print( "输入学生成绩：");    
                 float score =  this.input.getFloat();    
                Student s =  new Student(id, name, age, score);    
                 try {    
                         this.dao.doCreate(s);    
                }  catch (Exception e) {    
                        e.printStackTrace();    
                }    
        }    

         public  void delete() {    
                String id =  null;    
                System.out.print( "请输入要删除的学生ID：");    
                id = input.getString();    
                 try {    
                         this.dao.doDelete(id);    
                }  catch (Exception e) {    
                        e.printStackTrace();    
                }    
        }    

         public  void update() {    
                 // 更新之前需要先查询出来    
                String id =  null;    
                System.out.print( "请输入要修改的学生ID：");    
                id = input.getString();    
                Student s =  null;    
                 try {    
                        s = (Student)  this.dao.findById(id);    
                }  catch (Exception e1) {    
                         // TODO Auto-generated catch block    
                        e1.printStackTrace();    
                }    
                System.out.print( "输入学生姓名（原姓名：" + s.getName() +  "）：");    
                String name =  this.input.getString();    
                System.out.print( "输入学生年龄（原年龄：" + s.getAge() +  "）：");    
                 int age =  this.input.getInt();    
                System.out.print( "输入学生成绩（原成绩：" + s.getScore() +  "）：");    
                 float score =  this.input.getFloat();    
                s.setName(name);    
                s.setAge(age);    
                s.setScore(score);    
                 try {    
                         this.dao.doUpdate(s);    
                }  catch (Exception e) {    
                        e.printStackTrace();    
                }    
        }    

         public  void findAll() {    
                Iterator<Person> iter =  null;    
                 try {    
                        iter =  this.dao.findAll().iterator();    
                }  catch (Exception e) {    
                         // TODO Auto-generated catch block    
                        e.printStackTrace();    
                }    
                System.out.println( "ID\t\t\t姓名\t年龄\t成绩");    
                 while (iter.hasNext()) {    
                        System.out.println(iter.next());    
                }    

        }    

         public  void findByLike() {    
                String keyWord =  null ;    
                System.out.print( "请输入查询关键字：") ;    
                keyWord =  this.input.getString() ;    
                Iterator<Person> iter =  null;    
                 try {    
                        iter =  this.dao.findByLike(keyWord).iterator();    
                }  catch (Exception e) {    
                         // TODO Auto-generated catch block    
                        e.printStackTrace();    
                }    
                System.out.println( "ID\t\t\t姓名\t年龄\t成绩");    
                 while (iter.hasNext()) {    
                        System.out.println(iter.next());    
                }    
        }    
} 
###################Michael分割线#####################
###################Michael分割线#####################
###################Michael分割线#####################





本文转自redking51CTO博客，原文链接：http://blog.51cto.com/redking/142460 ，如需转载请自行联系原作者
文章标签：
Java
机器学习/深度学习
技术小美
目录
相关文章
小蜗牛耶
|
13天前
|
JavaScript Java 测试技术
基于Java的图书管理系统的设计与实现(源码+lw+部署文档+讲解等)
基于Java的图书管理系统的设计与实现(源码+lw+部署文档+讲解等)
小蜗牛耶
33 1
小蜗牛耶
|
4天前
|
JavaScript Java 测试技术
基于Java的兰亭序图书管理系统的设计与实现(源码+lw+部署文档+讲解等)
基于Java的兰亭序图书管理系统的设计与实现(源码+lw+部署文档+讲解等)
小蜗牛耶
15 0
小蜗牛耶
|
5天前
|
JavaScript Java 测试技术
基于Java的普通话培训信息管理系统的设计与实现(源码+lw+部署文档+讲解等)
基于Java的普通话培训信息管理系统的设计与实现(源码+lw+部署文档+讲解等)
小蜗牛耶
34 9
小蜗牛耶
|
12天前
|
JavaScript Java 测试技术
基于Java的成绩管理系统的设计与实现(源码+lw+部署文档+讲解等)
基于Java的成绩管理系统的设计与实现(源码+lw+部署文档+讲解等)
小蜗牛耶
6 0
小蜗牛耶
|
13天前
|
JavaScript Java 测试技术
基于Java的学生宿舍维修服务平台的设计与实现(源码+lw+部署文档+讲解等)
基于Java的学生宿舍维修服务平台的设计与实现(源码+lw+部署文档+讲解等)
小蜗牛耶
17 0
小蜗牛耶
|
13天前
|
JavaScript Java 测试技术
基于Java的网上商城的设计与实现(源码+lw+部署文档+讲解等)
基于Java的网上商城的设计与实现(源码+lw+部署文档+讲解等)
小蜗牛耶
23 0
前端歌谣
|
8月前
java202304java学习笔记第五十二天员工管理-文件上传-简介2
java202304java学习笔记第五十二天员工管理-文件上传-简介2
前端歌谣
23 0
翰文编程
|
6月前
|
Java 关系型数据库 MySQL
java网上购物系统eclipse定制开发mysql数据库BS模式java编程jdbc
JSP 网上购物系统是一套完善的web设计系统，对理解JSP java SERLVET mvc编程开发语言有帮助，系统具有完整的源代码和数据库，系统主要采用B/S模式开发。开发环境为TOMCAT7.0,eclipse开发，数据库为Mysql5.0，使用java语言开发。 系统运行视频 https://www.bilibili.com/video/BV1Yh4y1E7x8/
翰文编程
57 0
前端歌谣
|
10月前
java202304java学习笔记第五十二天员工管理-文件上传-简介3
java202304java学习笔记第五十二天员工管理-文件上传-简介3
前端歌谣
34 0
前端歌谣
|
11月前
java202304java学习笔记第六十一天-ssm-spring配置文件-集成简介和开发步骤
java202304java学习笔记第六十一天-ssm-spring配置文件-集成简介和开发步骤
前端歌谣
48 0

热门文章

最新文章

  • 1
    Mac安装并使用telnet命令操作
  • 2
    OSS回源的几种方式和应用场景
  • 3
    [剑指offer] 孩子们的游戏(圆圈中最后剩下的数)
  • 4
    网络安全系列之二十二 Windows用户账号加固
  • 5
    我理解的一个程序员如何学习前端开发
  • 6
    《社交网站界面设计（原书第2版）》——1.9　为设备之间的空间进行设计
  • 7
    《Microduino实战》——1.2　为什么要开源
  • 8
    .Net函数Math.Round你会用吗？
  • 9
    麻省理工大学新发明：暗黑WiFi透视技术
  • 10
    2014秋C++第19周 补充代码 哈希法的存储与查找
  • 1
    R语言关联规则模型(Apriori算法)挖掘杂货店的交易数据与交互可视化
    25
  • 2
    R语言近似贝叶斯计算MCMC（ABC-MCMC）轨迹图和边缘图可视化
    21
  • 3
    r语言中对LASSO回归，Ridge岭回归和弹性网络Elastic Net模型实现-4
    29
  • 4
    Sentieon | 每周文献-Multi-omics-第四十一期
    25
  • 5
    数据分享|R语言广义线性模型GLM：线性最小二乘、对数变换、泊松、二项式逻辑回归分析冰淇淋销售时间序列数据和模拟-2
    15
  • 6
    数据分享|R语言广义线性模型GLM：线性最小二乘、对数变换、泊松、二项式逻辑回归分析冰淇淋销售时间序列数据和模拟-1
    22
  • 7
    基于RT-Thread摄像头车牌图像采集系统
    22
  • 8
    R语言极值理论：希尔HILL统计量尾部指数参数估计可视化
    15
  • 9
    【视频】R语言中的分布滞后非线性模型（DLNM）与发病率，死亡率和空气污染示例
    18
  • 10
    sql语句创建数据库
    17

    • 相关课程

    更多
  • Java高级开发
  • Java面试疑难点解析 - Java Web开发
  • Java Web项目实战 - 图书商城
  • Java Web开发系列课程 - Spring框架入门
  • 「大师课」搞定 Java 开发基础
  • Java零基础入门

    • 相关电子书

    更多
  • Java 8 简明教程
  • Java高级特性入门（二）
  • Java基础入门(三)-阿里巴巴Java开发手册介绍

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • Elasticsearch Java API Client 开发
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）