Java基础（项目1）——项目设计分层 & dao + service + test +ui + exception + log + util

引出

1.为什么建那么多层，dao，service…
2.项目设计分层初步；
3.本文以养老院老人信息管理、招聘应聘控制台项目为例；

git仓库地址

---

DAO层—和数据库交互

1.通过IO流存储到dat文件

IO流及其项目应用初步

（1）类需要实现Serializable序列化接口

package com.tianju.older.entity;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

import java.io.Serializable;
import java.util.Date;
import java.util.Objects;

@Setter@Getter
@AllArgsConstructor
@NoArgsConstructor
public class Older implements Serializable { // 实现序列化接口
    private String id;
    private String name;
    private Integer age;
    private Date inDate;

    @Override
    public String toString() {
        return "Older[" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", inDate=" + inDate +
                ']';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Older older = (Older) o;
        return Objects.equals(id, older.id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

（2）dao层的接口和实现分离

接口：

package com.tianju.older.dao;

import com.tianju.older.entity.Older;

import java.util.List;

/**
 * Older的dao类
 */
public interface IOlderDao {
    // 保存老人信息
    void save(Older older);
    // 删除老人信息
    void delete(Older older);
    // 更新老人信息
    void update(Older older);
    // 根据id找老人信息
    Older findById(String id);
    // 找到全部老人信息
    List<Older> findAll();
    // 保存到文件的方法
    void saveToFile();
    // 从文件中读取成老人类的方法
    List<Older> loadFromFile();
}

实现：

package com.tianju.older.dao.impl;

import com.tianju.older.dao.IOlderDao;
import com.tianju.older.entity.Older;
import com.tianju.older.exception.NotFoundOlderException;
import com.tianju.older.util.Config;
import org.apache.log4j.Logger;

import java.io.*;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;

public class OlderDaoImpl implements IOlderDao {
    List<Older> list = null;

    // 如果读取到的loadFromFiLe不为null，则赋值给list；
    // 否则new 出来
    public OlderDaoImpl() {
        List<Older> olders = loadFromFile();
        if (Objects.isNull(olders)){
            list = new ArrayList<>(20);
        }else {
            list = olders;
        }
    }

    @Override
    public void save(Older older) {
        list.add(older);
        Logger.getLogger(this.getClass()).info("addOlder: " + older);
        saveToFile();
    }

    @Override
    public void delete(Older older) {
        // 先看能不能找到
        Older find = findById(older.getId());
        // 如果找到，删除；没找到，抛出异常，并记录日志
        if (Objects.isNull(find)){
            throw new NotFoundOlderException("404异常，该老人信息不存在，未删除");
        }
        Logger.getLogger(this.getClass()).info("deleteOlder: " + find);
        list.remove(older);
        saveToFile(); // 文件更新
    }

    @Override
    public void update(Older older) {
        // 找到index，用set方法更新
        Older find = findById(older.getId()); // 根据ID定位老人
        if (Objects.isNull(find)){
            throw new NotFoundOlderException("404异常，该老人信息不存在，无法修改");
        }
        // 记录日志信息
        Logger.getLogger(this.getClass()).info("beforeUpdate: " + find);
        int index = list.indexOf(find);
        list.set(index,older);
        Logger.getLogger(this.getClass()).info("afterUpdate: "+older);
        // 刷新文件
        saveToFile();
    }

    @Override
    public Older findById(String id) {
        Older find = null;
        Iterator<Older> it = list.iterator();
        while (it.hasNext()){
            Older older = it.next();
            if (older.getId().equals(id)){
                find = older;
                break;
            }
        }
        return find;
    }

    @Override
    public List<Older> findAll() {
        return list;
    }

    @Override
    public void saveToFile() {
        // 从内存写入硬盘，输出
        try {
            ObjectOutputStream out = new ObjectOutputStream(
                    new FileOutputStream("D:\\Myprogram\\idea-workspace\\Older_v2.6\\Older_v2.6\\src\\com\\woniuxy\\older\\resources\\older.dat")
            );
            out.writeObject(list);
            Logger.getLogger(OlderDaoImpl.class).info("save保存"+list.size()+"信息");
            out.flush();
            out.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public List<Older> loadFromFile() {
        // 从硬盘读入内存，输入
        List<Older> loadList = null;
        try {
            ObjectInputStream in = new ObjectInputStream(
                    new FileInputStream(Config.getDatPath())
            );
            loadList = (List<Older>) in.readObject();
            in.close();

        } catch (IOException | ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
        return loadList;

    }
}

2.通过JDBC存储到数据库

参考下面文章：

java连接SQL数据库 & 单例封装数据库

【测试】用junit进行测试：@Test注解

Service层—处理业务

1.项目设计分层初步

引入前端后，MVC模型：视图，模型，控制器

2.service处理业务相关

一个求职者和应聘者登陆和注册的业务接口

package com.qianbaidu.recruit.service;

import com.qianbaidu.recruit.entity.Boss;
import com.qianbaidu.recruit.entity.Emp;

/**
 * 用户登陆的服务接口
 */
public interface ILoginService {
    boolean login(String role);
    boolean sign(String role);

    // 返回登陆后的id，默认的id为-1，或者null
    // 0老板，1应聘者；-1，未登录成功，登陆成功返回id
    String[] execute();


}

3.和UI层以及dao层进行交互

UI层界面—控制台，单例模式

1.创建单例的方法

创建单例的方法

2.页面的实现

用枚举的方式实现单例

package com.qianbaidu.recruit.ui;

import java.util.List;
import java.util.Scanner;
import java.util.Set;

public enum ApplicantMenuUI {
    APPLY_UI;
    
    private Scanner sc;


    private ApplicantMenuUI(){
        sc = new Scanner(System.in);
    }
    
    
    // 主界面 公司查询，信息修改，职位查询，企业打分
    public String appExecuteUI(){
        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("0.返回上一级界面");
        return sc.nextLine();
    }

}

Exception层----异常的处理

（1）自定义异常—用户登陆异常

package com.qianbaidu.recruit.exception;

/**
 * 402异常，用户登陆异常
 */
public class LoginIllegalException extends RuntimeException{
    public LoginIllegalException(String message) {
        super(message);
    }
}

（2）使用异常类进行登陆验证

    private Emp loginEmp(){
        // 用户名错误
        String[] loginInput = LoginMenu.loginUI("1");//（企业0，求职者1）
        if (dao.findEmpByLoginName(loginInput[0])==null){
            throw new LoginNameNotFoundException("404异常，用户名"+loginInput[1]+"不存在，请注册");
        }
        Emp loginEmpLoginNameTrue = dao.findEmpByLoginName(loginInput[0]);
        // 用户名/密码错误
        if (dao.findEmpLoginNameAndPassword(loginInput[0],loginInput[1])==null){
            throw new LoginIllegalException("405异常，用户名|密码错误，请重新输入+" + loginEmpLoginNameTrue.getUsername());
        }
        Emp loginEmp = dao.findEmpLoginNameAndPassword(loginInput[0],loginInput[1]);
        Logger.getLogger(this.getClass()).info("应聘者用户 "+loginEmp.getUsername()+" 登陆");
        return loginEmp;
    }

Test测试层----dao和service可测

1.dao的测试

Dao层的测试，用junit4

package com.tianju.older.test;

import com.tianju.older.dao.IOlderDao;
import com.tianju.older.dao.impl.OlderDaoImpl;
import com.tianju.older.entity.Older;
import org.junit.Test;

import java.text.ParseException;
import java.text.SimpleDateFormat;

/**
 * dao的测试类
 */
public class OlderDaoImplTest {
    private IOlderDao dao = new OlderDaoImpl();
    private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-mm-dd");

    @Test
    public void save() throws ParseException {
        dao.save(new Older("1", "小王", 28, sdf.parse("2023-04-07")));
        dao.save(new Older("2", "小张", 26, sdf.parse("2023-05-07")));
        dao.save(new Older("3", "小李", 24, sdf.parse("2021-06-07")));
        dao.save(new Older("3", "小鹏", 24, sdf.parse("2022-04-10")));
        System.out.println(dao.findAll());
    }


    @Test
    public void loadFromFile() {
        System.out.println(dao.loadFromFile());
        System.out.println(dao.findAll());
    }

    @Test
    public void delete() {
        dao.loadFromFile();
        System.out.println(dao.findAll());
        // 删除
        dao.delete(new Older("2",null,null,null));
        // 删除是否保存成功
        System.out.println(dao.loadFromFile());

    }
}

2.service结合UI测试

如果涉及到控制台的输入，则不能用junit

package com.qianbaidu.recruit.test;

import com.qianbaidu.recruit.dao.IApplicantDao;
import com.qianbaidu.recruit.dao.impl.ApplicantDaoImpl;
import com.qianbaidu.recruit.service.IApplicantService;
import com.qianbaidu.recruit.service.impl.ApplicantServiceImpl;

public class ApplyMainTest {
    public static void main(String[] args) {
        IApplicantService ias = new ApplicantServiceImpl();
        while (true){
            ias.execute(1);
        }
    }
}

resource层-----配置文件，数据文件

可以参考下面博客：

IO流及其项目应用初步

在本控制台项目中，resources文件夹包括以下文件

• 户名密码存储的文件，login.properties文件；
• log4j日志记录文档，log.log文件；
• 保存数据信息的文件，older.dat文件；
  

项目的日志—log4j

日志是文件，记录一些信息。记录重要的，登录信息，操作，异常信息。

1.日志的级别

DEBUG: 项目开发人员的测试
INFO： 一般信息（开发人员，其他）
WARN: 警告(开发人员警告使用者)
ERROR: 系统比较严重问题
FATAL: 非常严重的问题

控制的日志可见性

2.日志的配置和使用

其中的log4j配置文件目录和内容如下：

配置文件内容：

log4j.rootLogger=DEBUG,Console,F
#显示在控制台
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout 
log4j.appender.Console.layout.ConversionPattern=[%p],%d{yyyy-MM-dd HH:mm:ss},[%t],%rms,[%m]%n
#在文件输出
log4j.appender.F=org.apache.log4j.RollingFileAppender
log4j.appender.F.File=d:\\log.log
log4j.appender.F.layout=org.apache.log4j.PatternLayout 
log4j.appender.F.layout.ConversionPattern=[%p],%d{yyyy-MM-dd HH:mm:ss},[%t],%rms,[%m]%n

util层—工具，DbUtil，常量

1.枚举的使用

枚举类型作用
替代常量的。编码规范： 魔鬼常量

if(choice == 1)

switch(a){

case 1:

​ break;

}

枚举的定义代码：

package com.tianju.older.util;

/**
 * 业务的选择
 * 登陆后选择，1.录入老人信息；2.修改老人信息；3.删除老人信息；4.查询老人信息；0.返回登陆界面
 */
public enum Choice {
    ADD_MES,UPDATE_MES,DELETE_MES,QUERY_ALL,BACK_LOGIN;

    /**
     * 根据客户输入的数字转换成枚举类型
     * @param ch 输入的数字
     * @return 转换成的枚举类型
     */
    public static Choice get(String ch){
        if (ch.equals("1")){
            return ADD_MES;
        }else if (ch.equals("2")){
            return UPDATE_MES;
        } else if (ch.equals("3")){
            return DELETE_MES;
        } else if (ch.equals("4")){
            return QUERY_ALL;
        }else {
            return BACK_LOGIN;
        }
    }
}

使用枚举类型代替魔鬼常量：

比如在页面里让用户在控制台输入，0~4进行操作选择

public static String welcome(){
        System.out.println("-------------------欢迎进入老人信息管理系统-------------------");
        // 登陆后选择，1.录入老人信息；2.修改老人信息；3.删除老人信息；4.查询老人信息；0.返回登陆界面
        System.out.println("1.录入老人信息");
        System.out.println("2.修改老人信息");
        System.out.println("3.删除老人信息");
        System.out.println("4.查询老人信息");
        System.out.println("0.返回登陆界面");
        System.out.println("-----------------------------------------");
        System.out.print("请输入选择：");
        // 正则表达式判断
        String in = sc.nextLine();
        String regex = "[0-4]{1}";
        if (!in.matches(regex)){
            System.out.println("输入错误，请输入0-4之间的数字");
        }
        return in;
    }

然后在这里用枚举代替魔鬼常量，让代码可读性增强；

 private void welcome(){
        boolean isContinue = true;
        while (isContinue) {
            String ch = OlderMenu.welcome();
            Choice c = Choice.get(ch);
            switch (c){
                case ADD_MES:
                    addOlder();
                    break;
                case UPDATE_MES:
                    updateOlder();
                    break;
                case DELETE_MES:
                    deleteOlder();
                    break;
                case QUERY_ALL:
                    findAll();
                    break;
                case BACK_LOGIN:
                    isContinue = false;
                    System.out.println("------------再见，欢迎再次登陆------------");
                    break;
            }
        }
    }

2.常量的定义

比如下面，用数字0~3来表示公司规模为1-20人，20-100人，100-500人，以及大于500人这几种公司规模

package com.qianbaidu.recruit.util;

import com.qianbaidu.recruit.exception.InputIllegalException;

public class Constance {
    public final static String COMPANY_LESS20 = "1~20人";
    public final static String COMPANY_LESS100 = "20~100人";
    public final static String COMPANY_LESS500 = "100~500人";
    public final static String COMPANY_MORE500 = "大于500人";

    public static String showCompanySize(int size){
        if (size==0){
            return COMPANY_LESS20;
        }else if(size==1){
            return COMPANY_LESS100;
        }else if (size==2){
            return COMPANY_LESS500;
        }else if (size==3){
            return COMPANY_MORE500;
        }
        return null;
    }
}

在公司信息的实体类的toString方法中调用showCompanySize（）方法把数字转成常量对应的中文；

    @Override
    public String toString() {
        return "\nCompany{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", size=" + Constance.showCompanySize(size) +
                ", address='" + address + '\'' +
                ", type='" + type + '\'' +
                ", web='" + web + '\'' +
                ", phone='" + phone + '\'' +
                ", person='" + person + '\'' +
                ", desc='" + desc + '\'' +
                ", rate=" + rate +
                ", rates=" + rates +
                '}';
    }

3.DbUtil

参考下面文章：

java连接SQL数据库 & 单例封装数据库

---

总结

1.关于控制台项目中使用到Java基础知识；
2.实体类和dao层，增删改查CRUD分离，从IO流到JDBC，SQL语句；
3.dao层和service层，dao层和数据库交互，service层处理业务，初步了解程序设计思想；
4.测试：dao层和service层的方法要可测，@Test注解，涉及控制台输入不能用@Test；
5.控制台的UI层处理控制台的输入，学习单例创建UI类的方法；
6.异常类，用自定义异常处理业务，初步学习Java的异常机制；
7.配置文件，resources层，用配置文件实现程序解耦，初步了解程序设计思想；
8.日志文件：log4j的配置，软件要有日志，日志的级别；
9.工具类：枚举类的使用，常量的定义，JDBC封装方式，创建单例的三种方法；