书店管理系统---User模块.Dao层（JavaSE综合运用（一）），---userjavase

书店管理系统---User模块.Dao层（JavaSE综合运用（一）），---userjavase

6**项目开发步骤**
一、项目想法（项目是做什么的）
二 、可行性分析
2.1、经济可行性
2.2、技术可行性分析（自己无法完成部分可以考虑外包）
三、需求分析：具体有什么功能，可以查阅资料，调研找类似系统
四、概要设计（概要设计+详细设计）
4.1、概要设计：功能模板图—数据表、数据设计库、表结构等
4.2、详细设计：要把具体的类。方法写出来。如图

五、开发 。

——— —————————以书店管理系统为例开发————————————–

（省略部分步骤）
一：项目功能需求分析
1、能进行操作用户的注册，修改基本信息，删除和查询。
2、能对图书的基本信息进行增加、删除、修改和查询操作。
3、能填写进货单，一张进货单带有多条具体的进货信息，进货的书籍必须是图书管理里面已经有的；进货的同时修改库存对应书籍的存货量。
4、能填写销售单，一张销售单带有多条具体的销售信息，销售的书籍必须是图书管理里面已经有的，而且销售的数量不能超过当前库存的数量；销售的同时修改库存对应书籍的存货量。
5、可以查看库存的明细，可以按照条件进行查找具体的图书的库存值。
6、权限方面进行简化，做固定的权限控制。把用户按照模块分成不同操作权限的人员，特设一个admin的用户，可以操作全部的功能。
二：项目的不同功能模块（如图）

不同木块内部部分为三层（如图）

三、概要设计（只给出了用户信息模块）
说明：其中的type为int类型，用来表示操作用户的类。
1——表示为admin，可以进行全部操作
2——表示为能操作图书模块的人员
3——表示为能操作进货模块的人员
4——表示为能操作销售模块的人员
5——表示为能操作库存模块的员

四、具体开发 （user模块）
首先写VO 值对象 因为 所有都需要用到 。

package cn.hncu.bookStore.user.vo;

import java.io.Serializable;
/**
 * User 值对象
 * @author<a href="mailto:953801304@qq.com">胡龙华</a>
 * @version 2017-3-12  上午11:20:09
 * @fileName UserVO.java
 */
public class UserVO implements Serializable{
    private String uuid;// 用户信息的主键
    private String name;// 用户姓名
    private int type;   // 用户类型 
    private String pwd;// 用户密码
    public UserVO (){
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((uuid == null) ? 0 : uuid.hashCode());
        return result;
    }
    @Override
    public String toString() {
        return "UserVO [uuid=" + uuid + ", name=" + name + ", type=" + type
                + ", pwd=" + pwd + "]";
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        UserVO other = (UserVO) obj;
        if (uuid == null) {
            if (other.uuid != null)
                return false;
        } else if (!uuid.equals(other.uuid))
            return false;
        return true;
    }
    public String getUuid() {
        return uuid;
    }
    public void setUuid(String uuid) {
        this.uuid = uuid;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getType() {
        return type;
    }
    public void setType(int type) {
        this.type = type;
    }
    public String getPwd() {
        return pwd;
    } 
}

接下来写什么呢？ 当然是dao User里面数据库模块。为什么？ 很简单，UI层调用逻辑层，逻辑层调研dao层。肯定先把dao写了 再写逻辑层 再写UI啊。
dao层 三部分：接口 (dao) 实现类（impl） 工厂方法（factory）
1.接口dao

package cn.hncu.bookStore.user.dao.dao;

import java.util.List;

import cn.hncu.bookStore.user.vo.UserQueryVO;
import cn.hncu.bookStore.user.vo.UserVO;
/**
 * User  接口
 * @author<a href="mailto:953801304@qq.com">胡龙华</a>
 * @version 2017-3-12  上午11:26:52
 * @fileName Userdao.java
 */
public interface Userdao {
    // 增删改
    /**
     * 增加一个用户，通过值对象传递
     * @param uservo
     * @return
     */
    public boolean create(UserVO uservo);
    /**
     * 删除一个用户，通过主键 uuid 找到需要删除的用户
     * @param uservo
     * @return
     */
    public boolean detele(String uuid);
    /**
     * 修该用户信息，通过值对象传递需要修改的信息
     * @param uservo
     * @return
     */
    public boolean update(UserVO uservo);

    //查（单，全，部分）
    /**
     * 查单个用户信息,通过主键来差
     * @param uservo
     * @return
     */
    public UserVO getSingle(String uuid);
    /**
     * 查全部用户信息
     * @return
     */
    public List<UserVO> getAll();
    /**
     * 范围查找
     * @param uqvo
     * @return
     */
    public List<UserVO> getByCondtion(UserQueryVO uqvo);
}

2.具体实现类 impl （create方法没有用抽取方法（开始不会抽取方法所有代码敲 好累 /(ㄒoㄒ)/~~） 其他的几个方法都用了 抽取方法 ）
抽取方法就是把重复使用率高的代码抽取成一个工具类调用。

package cn.hncu.bookStore.user.dao.impl;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

import javax.swing.JOptionPane;

import cn.hncu.bookStore.user.dao.dao.Userdao;
import cn.hncu.bookStore.user.vo.UserQueryVO;
import cn.hncu.bookStore.user.vo.UserVO;
import cn.hncu.bookStore.utils.FileIoUtil;
/**
 * 
 * @author<a href="mailto:953801304@qq.com">胡龙华</a>
 * @version 2017-3-11  下午9:53:02
 * @fileName UserDaoImpl.java
 */
public class UserDaoImpl implements Userdao{
      private final String filename = "User.txt";

    @Override
    public boolean create(UserVO uservo) {
        ObjectInputStream in=null;
        // 思路：先从文件里读出来，读成LISt  然后和要添加的比较主键， 在来添加
        File file = new File("User.txt");
        //要用到List  先声明好
        List<UserVO> list = new ArrayList<UserVO>();
        // 对于程序来说是读入所以用  in
         if(file.exists()){
            try {
               in = new ObjectInputStream(new FileInputStream(file));
               try {
                list = (List<UserVO>)in.readObject();     //*1* 把文件从数据库（此处用的是文件IO流）里读出来；
                //*2* 判断是否存在要添加的用户信息
                for(UserVO vo:list){
                    if(vo.getUuid().equals(uservo.getUuid())){
                        return false; //说明存在，不添加  添加失败。
                    }
                }
            } catch (ClassNotFoundException e) {
                // 这个是对应List可能会出现的读出来的数据不能转成List<UserVO>
                JOptionPane.showMessageDialog(null, "读出来的数据不是需要的UserVO");
                e.printStackTrace();
            }
            } catch (FileNotFoundException e) {
                JOptionPane.showMessageDialog(null, "找不到文件");
                e.printStackTrace();
            } catch (IOException e) {
                JOptionPane.showMessageDialog(null, "IO错误，用户信息读取失败");
                e.printStackTrace();
            }finally{
                if(in!=null){
                    try {
                        in.close();
                    } catch (IOException e) {
                        JOptionPane.showMessageDialog(null, "IO错误，关流失败");
                        e.printStackTrace();
                    }
                }

            }
        }

        // *3* 添加进数据库，对于程序来说是输出 所以用OUT
        try {
            ObjectOutputStream out = new  ObjectOutputStream(new FileOutputStream(file));
            list.add(uservo);    // 先添加到列表  再把列表添加到 文件里。
            out.writeObject(list);
        } catch (FileNotFoundException e) {
            JOptionPane.showMessageDialog(null, "找不到文件");
            e.printStackTrace();
        } catch (IOException e) {
            JOptionPane.showMessageDialog(null, "IO错误，用户信息存储失败");
            e.printStackTrace();
        }
        return true;
    }

    @Override
    public boolean detele(String uuid) {
        // 思路：先找到  然后 删除 存  没找到 失败
        //List<UserVO> list = FileIoUtil.readFromFile(filename); 
        List<UserVO> list = getAll();
        if(list!=null){
             for(int i=0;i<list.size();i++){
                 UserVO vo=list.get(i);
                    if(vo.getUuid().equals(uuid)){
                        //说明存在
                        list.remove(i);
                        FileIoUtil.write2File(filename, list);
                        return true;
                    }
                }
        }
        return false;
    }

    @Override
    public boolean update(UserVO uservo) {
        // 思路：先找到  删除旧的的  添加忻的 存  没找到 结束
        //List<UserVO> list = FileIoUtil.readFromFile(filename);
        List<UserVO> list = getAll();
         if(list!=null){
            for(int i=0;i<list.size();i++){
                UserVO vo=list.get(i);
                if(vo.getUuid().equals(uservo.getUuid())){
                    list.remove(i);
                    list.add(uservo);
                    FileIoUtil.write2File(filename, list);
                    return true;
                }
            }
         }
        return false;
    }

    @Override
    public UserVO getSingle(String uuid) {
        // 找到 返回
        //List<UserVO> list = FileIoUtil.readFromFile(filename);
        List<UserVO> list = getAll();
        if(list!=null){
            for(UserVO vo:list){
                if(vo.getUuid().equals(uuid)){
                    return vo;
                }
            }
        }
        return null;
    }

    @Override
    public List<UserVO> getAll() {
        return FileIoUtil.readFromFile(filename);
    }

    @Override
    public List<UserVO> getByCondtion(UserQueryVO uqm) {
        //条件查询的思路:
                //把所有数据记录查询出来，然后遍历所有记录并把不符合查询条件的记录
                //过滤掉(采用卫条件、反逻辑来实现)，把剩下的存入一个结果集，最后返回这个结果集

                List<UserVO> list = getAll();
                List<UserVO> results = new ArrayList<UserVO>();
                for(UserVO model: list){
                    //反逻辑、卫条件
                    //uuid ---精确查询用equals()
                    if(uqm.getUuid()!=null && uqm.getUuid().trim().length()>0){//外层:判断用户是否输入该查询条件---该条件是否是有效的查询条件
                        if(!uqm.getUuid().trim().equals(model.getUuid())){//内层:判断当前对象model是否符合该查询条件
                            continue;
                        }
                    }

                    //name ----模糊查询
                    if(uqm.getName()!=null && uqm.getName().trim().length()>0){
                        if(!model.getName().contains( uqm.getName().trim() ) ){
                            continue;
                        }
                    }

                    //type
                    if(uqm.getType()>0){//只有大于0才代表用户输了“用户类型”的查询条件
                        if(model.getType()!=uqm.getType()){
                            continue;
                        }
                    }

                    results.add(model);
                }
                for(UserVO vo1:results){
                    System.out.println(vo1.getName());
                }
                return results;
    }

代码抽取方法
1.把相近的几段代码拿出来比较
2.把先定义的变量改为方法的参数
3.把要给后面使用的东西作为返回值。

接下来的代码是我抽取的方法类

package cn.hncu.bookStore.utils;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

import javax.swing.JOptionPane;
/**
 * 抽取出来的方法
 * @author<a href="mailto:953801304@qq.com">胡龙华</a>
 * @version 2017-3-12  上午11:41:52
 * @fileName FileIoUtil.java
 */
public class FileIoUtil {
    private FileIoUtil (){
    }

    @SuppressWarnings("unchecked")
    public static<E> List<E> readFromFile(String filename){
        // 思路：先从文件里读出来，读成LISt  然后和要添加的比较主键， 在来添加
                File file = new File(filename);
                ObjectInputStream in = null;
                //要用到List  先声明好
                List<E> list = new ArrayList<E>();
                if(file.exists()){
                // 对于程序来说是读入所以用  in
                    try {
                       in = new ObjectInputStream(new FileInputStream(file));
                       try {
                        list = (List<E>)in.readObject();     //*1* 把文件从数据库（此处用的是文件IO流）里读出来；
                        //*2* 判断是否存在要添加的用户信息
                    } catch (ClassNotFoundException e) {
                        // 这个是对应List可能会出现的读出来的数据不能转成List<UserVO>
                        JOptionPane.showMessageDialog(null, "读出来的数据不是需要的UserVO");
                        e.printStackTrace();
                    }
                    } catch (FileNotFoundException e) {
                        JOptionPane.showMessageDialog(null, "找不到文件");
                        e.printStackTrace();
                    } catch (IOException e) {
                        JOptionPane.showMessageDialog(null, "IO错误，用户信息读取失败");
                        e.printStackTrace();
                    }finally{
                        if(in!=null){
                            try {
                                in.close();
                            } catch (IOException e) {
                                JOptionPane.showMessageDialog(null, "IO错误，关流失败");
                                e.printStackTrace();
                            }
                        }

                    }
                }
                return list;
    }
    public static<E> void write2File(String filename,List<E> list){
        File file = new File(filename);
        ObjectOutputStream out=null;
        try {
            out = new  ObjectOutputStream(new FileOutputStream(file));
            out.writeObject(list);
        } catch (FileNotFoundException e) {
            JOptionPane.showMessageDialog(null, "找不到文件");
            e.printStackTrace();
        } catch (IOException e) {
            JOptionPane.showMessageDialog(null, "IO错误，用户信息存储失败");
            e.printStackTrace();
        }finally{
            if(out!=null){
                try {
                    out.close();
                } catch (IOException e) {
                    throw new RuntimeException("系统发生严重:用户信息数据表的文件关流失败!");
                }
            }
        }
    }
}

dao里面的工厂方法如下

package cn.hncu.bookStore.user.dao.factory;

import cn.hncu.bookStore.user.dao.dao.Userdao;
import cn.hncu.bookStore.user.dao.impl.UserDaoImpl;

public class UserDaoFactory {
    private UserDaoFactory() {
    }

    public static Userdao getUserdao(){
        return new UserDaoImpl();
    }

}

最后但是也很重要的是写完一层代码，一定要测试！一定要测试！一定要测试！这样才能保证你写的这段代码没有错误。或者数BUG更少，当你后面的代码写的时候出现BUG的时候就不用再从前面的代码找原因。 别问我怎么知道，刚刚找了半个小时。