Java基础（项目2）——项目案例：控制台的一个云就业平台项目【应聘+招聘】

git仓库地址

引出

1.关于控制台项目中使用到Java基础知识；
Java基础（1）——数据类型&包装类，引用类型String&StringBuilder，正则表达式，定点数，日期类
Java基础（9）——从匿名内部类 到 函数式编程
Java基础（2）——列表&集合List，函数式编程Lamda表达式
Java基础（3）——算术|逻辑|位运算符，三元运算符
Java基础（4）——逻辑控制词 和 语句

2.实体类和dao层，增删改查CRUD分离，从IO流到JDBC，SQL语句；
Java基础（5）——IO流及其项目应用初步
Java基础（6）——架构迭代–从面向过程到面向对象，到IO流再到数据库
Java基础（7）——java连接SQL数据库 & 单例封装数据库

3.dao层和service层，dao层和数据库交互，service层处理业务，初步了解程序设计思想；
Java基础（项目1）——项目设计分层 & dao + service + test +ui + exception + log + util

4.测试：dao层和service层的方法要可测，@Test注解，涉及控制台输入不能用@Test；

5.控制台的UI层处理控制台的输入，学习单例创建UI类的方法；

6.异常类，用自定义异常处理业务，初步学习Java的异常机制；
Java基础（8）——java的异常机制初步

7.配置文件，resources层，用配置文件实现程序解耦，初步了解程序设计思想；

8.日志文件：log4j的配置，软件要有日志，日志的级别；

9.工具类：枚举类的使用，常量的定义，JDBC封装方式，创建单例的三种方法；

---

项目的分层

参考下面博客：

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

固定的流程+反思

1.entity — 实体类

（1）可以采用用包装类型定义数据类型：这样初始化为null，

（2）固定需要实现 set，get方法，全参，无参的构造方法；

（3）生成toString() 方法：进行改造，用于更好地打印显示；

（4）可以按照需求生成equals() 和 hashCode() 方法，从而快速判断两个类是否相等，以及调用list的remove(object) 方法；

实体类中，一些可以用数字表示的属性可以采用数字进行定义和表示：

例如：学历，大专、本科、硕士、博士，如果用中文，数据库查询效率低，且不好实现大于本科学历的人的查询；而如果用0、1、2、3进行代替，就可以避免上述问题，再结合toString() 方法的改造，就可以很好地解决这个问题；

公司规模，公司规模 (1-20)，(20-100)，(100-500), 500；

甚至是面试状态，未通过初筛0，申请中1，预约面试2，已面试3，通过4，不通过5

2.dao —数据库的CRUD【进化到Spring的JdbcTemplate】

dao里面有三个固定需要实现的方法：

（1）save(Company comp) 保存方法：保存到数据库中；

（2）findById(Integer id) 根据id找的方法：根据唯一id找到保存的数据；（主键）

（3）update(Company comp) 更新：如果传入的是某个要修改的字段，那只能修改这一字段，

如果是实例化一个类，把这个类传入进行update，则可以相对灵活地修改；

（4）findAll() 全查询：找到数据库中的全部数据，思考：如果数据量大，这里是不是要用到分页查询；

其中，实现类中，要写两个私有的方法：

（1）List getCompanys(Result rs) ：获得一个集合

（2）Company getCompany(Result rs) :获得单个类

以职位投递的dao为例—进化到Spring的JdbcTemplate：

1.私有的方法–获取单个和多个：

/**
     * 私有的获取单个对象的方法
     * @param rs 数据库查询到的结果 ResultSet
     * @return 找到的对象Job，为null或者对应一个Job实体类
     */
    private Job getJob(ResultSet rs) {
        Job job =null;
        try {
            if (rs.next()){
                job = new Job(
                        rs.getInt("hire_id"),
                        rs.getInt("company_id"),
                        rs.getString("company_name"),
                        rs.getInt("hire_num"),
                        rs.getString("hire_name"),
                        rs.getInt("hire_year"),
                        rs.getInt("hire_degree"),
                        rs.getString("hire_desc"),
                        rs.getDate("hire_date")
                );

            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
        db.close();
        return job;
    }


    /**
     * 私有的获取工作经验（年限要求的方法）
     * @param year 工作年限参数
     * @param sql sql语句
     * @return 返回list集合
     */
    private List<Job> getJobs( String sql, Integer year) {
        List<Job> list = new ArrayList<>(10);
        db.prepareStatement(sql,year);
        ResultSet rs = db.executeQuery();
        // 尝试用类型转换一下，可以实现
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        try {
            while (rs.next()){
                try {
                    Job job = new Job(
                            rs.getInt("hire_id"),
                            rs.getInt("company_id"),
                            rs.getString("company_name"),
                            rs.getInt("hire_num"),
                            rs.getString("hire_name"),
                            rs.getInt("hire_year"),
                            rs.getInt("hire_degree"),
                            rs.getString("hire_desc"),
                            sdf.parse(rs.getString("hire_date"))
                    );
                    list.add(job);
                } catch (ParseException e) {
                    throw new RuntimeException(e);
                }
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
        db.close();
        return list;
    }

2.调用私有的方法实现操作

    @Override
    public Job findById(Integer jobId) {
        db.connect();
        String sqlPro = "SELECT * FROM company_hire_tab WHERE hire_id =?";
        db.prepareStatement(sqlPro,jobId);
        ResultSet rs = db.executeQuery();
        return getJob(rs);
    }


    @Override
    public List<Job> findJobByLessYear(Integer year) {
        db.connect();
        String sql ="SELECT * FROM company_hire_tab WHERE hire_year <= ?;";
        return getJobs(sql, year);
    }

3.service — 组织代码的业务【进化到servlet调用service】

（1）配合界面进行代码的编写，要捋清楚业务的逻辑，把dao里实现的方法进行进一步的封装；

（2）固定的格式：属性私有化，构造方法中new 对象；

4.util —需要用到的工具【进化到durid和JdbcTemplate】

（1）JDBC的封装工具：创建单例；

（2）一些需要用到的常量

5.测试 —单元测试Junit4

（1）dao的增删改查需要进行测试，主要测试SQL语句编写是否正确；

（2）service的业务相关进行测试，主要看业务的流程逻辑设计是否合理，有没有需要改进的地方；

【核心业务】应聘记录模块+评分模块

（1）简历投递表是该项目的【重点和难点】该表涉及到应聘者和招聘者的操作，两者之间交互等，我认为是本项目中最核心的部分。
（2）公司评分：首先不是所有人都能对公司进行评分，在本控制台项目中设定只有获得企业面试邀请并且参加面试后，无论结果通过与否都可以进行公司的评价；

0.业务流程分析

建立企业和应聘者之间的关系

记录id,记录时间（是指申请的日期），申请人id（应聘者表的主键），企业id（企业表的主键），申请职位（职位名称），状态（无，申请中，预约面试，已面试： 这个状态是在应聘者申请时为改为“申请中”，企业同意面试后改为“预约面试”），面试时间。

1）公司操作查询操作：

查询自己发布职位的投递情况，

（1）根据职位名称查询； 通过id找到定位公司，然后在其中找到职位；

（2）根据发布日期查询；

（3）根据申请人学历查询；

（4）根据申请人工作年限查询；

未通过初筛0，申请中1，预约面试2，已面试3，通过4，不通过5

2）应聘者进行相关操作

无0，申请中1，预约面试2，已面试3

（1）创建一条应聘信息表，状态为申请中，编号为1；

（2）查看自己的申请记录

初始化，没有面试日期

业务	操作	下一步
1.应聘者创建应聘信息	新增一条数据，状态为申请中1，面试日期为无	企业查看应聘信息
2.企业进行面试预约	根据记录表的id，设置状态为预约面试2，填写面试日期	应聘者按照日期要求进行面试
3.企业面试	根据记录表的id，修改状态为已面试3，	应聘者等待面试结果
4.面试者查看自己的信息	根据应聘者的id返回所有的记录信息，查看申请中。。。	应聘者进行企业评分
5.已经面试，通过面试，不通过面试的应聘者进行评分

3）公司进行面试相关操作：

未通过初筛0，申请中1，预约面试2，已面试3，通过4，未通过5

failedInitial() 未通过初筛；

applying() 申请中；

sendInterview() 发送面试邀请，预约面试；

finishInterview() 完成面试；

passInterview() 通过面试；

failedInterview() 未通过面试；

（3）进行面试的预约，设置面试的时间；

根据面试记录表的id 修改 为预约面试 ，并且要设置面试的时间

（3）拒绝该申请人，设置 状态为未通过初筛，0

（4）修改面试状态为 已面试

（5）修改状态为通过面试，或者不通过面试

状态（无，申请中，预约面试，已面试： 这个状态是在应聘者申请时为改为“申请中”，企业同意面试后改为“预约面试”）

修改选中记录的状态，中文和数字两个，并且设置面试时间

1.实体类

面试申请记录表	表列名
记录id,	record_id
记录时间（是指申请的日期），	record_date
申请人id（应聘者表的主键），	apply_id
申请人姓名	apply_name
企业id（企业表的主键），	company_id
企业名称	company_name
职位id（职位表的主键）	job_id
申请职位（职位名称），	job_name
状态（无，申请中，预约面试，已面试： 这个状态是在应聘者申请时为改为“申请中”，企业同意面试后改为“预约面试”），	record_status 未通过初筛0，申请中1，预约面试2，已面试3，通过4，不通过5
状态数字	record_status_num，未通过初筛0，申请中1，预约面试2，已面试3，通过4，不通过5
面试时间。	interview_date

Record.java实体类代码

package com.qianbaidu.recruit.entity;

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

import java.text.SimpleDateFormat;
import java.util.Date;


/**
 * 应聘记录表实体类
 */
@AllArgsConstructor
@NoArgsConstructor
@Getter @Setter
public class Record {
    private Integer id;
    private Date recordDate;
    private Integer applyId;
    private String applyName;
    private Integer companyId;
    private String companyName;
    private Integer jobId;
    private String jobName;
    private String recordStatus; // 无 0，申请中 1，预约面试 2，已面试 3
    private Integer reStatusNum; // 状态的数字表示，可以和上面用文字表示的方法对比
    private Date interviewDate;

    @Override
    public String toString() {
        return "\nRecord{" +
                "id=" + id +
                ", recordDate 申请日期 =" + showRecordDate()+
                ", applyId=" + applyId +
                ", applyName='" + applyName + '\'' +
                ", companyId=" + companyId +
                ", companyName='" + companyName + '\'' +
                ", jobId=" + jobId +
                ", jobName='" + jobName + '\'' +
                ", recordStatus='" + recordStatus + '\'' +
                ", reStatusNum=" + reStatusNum +
                ", interviewDate 面试时间 =" + showInterviewDate() +
                '}';
    }



    public String showRecordDate(){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        if (this.recordDate!=null){
            return sdf.format(this.recordDate);
        }
        return null;
    }

    public String showInterviewDate(){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        if (this.interviewDate!=null){
            return sdf.format(this.interviewDate);
        }
        return null;
    }
}

2.dao层–和数据库交互

接口部分代码IRecordDao.java

package com.qianbaidu.recruit.dao;

import com.qianbaidu.recruit.entity.Record;
import com.qianbaidu.recruit.util.DbUtil;

import java.util.List;

public interface IRecordDao {
    /**
     * 进行简历投递，求职者投递一条简历
     * @param record 新增的职位
     */
    void saveRecord(Record record);

    /**
     * 根据唯一的id查找投递记录
     * @param id 唯一id
     * @return 找到的投递信息
     */
    Record findById(Integer id);

    /**
     * failedInitial()  未通过初筛；
     * @param recordId 修改的记录表的 id
     */
    void failedInitial(Integer recordId);

    /**
     * 发送面试邀请
     * @param recordId 修改的 id
     * @param interviewDate string类型面试时间 2022-05-06
     */
    void sendInterview(Integer recordId,String interviewDate);

    /**
     * 完成面试
     * @param recordId 修改的id
     * @param interviewDate string类型的完成面试的时间，后续可以是当前操作时间
     */
    void finishInterview(Integer recordId,String interviewDate);

    /**
     * 面试通过，发送offer
     * @param recordId 修改的id
     */
    void passInterview(Integer recordId);

    /**
     * 面试未通过，
     * @param recordId 修改的id
     */
    void failedInterview(Integer recordId);

    /**
     * 面试者查看自己申请的信息
     * @param applyId 求职者的id
     * @return 自己申请的所有职位
     */
    List<Record> findRecordByApplyId(Integer applyId);


    /**
     * 查找阿里巴巴 的 java开发 职位的 投递者，或者全部投递人
     * 根据职位的 id 和 公司的 id 查找职位信息表，即公司查自己的职位信息
     * @param jobIdList 职位的 id 列表
     * @param companyId 公司的id
     * @return 查询到的职位信息表
     */
    List<Record> findRecordByJobIDAndCompanyID(Integer[] jobIdList,Integer companyId);

    /**
     * 学历大于本科的阿里巴巴投递信息
     * @param applyIdList 学历大于本科的求职者id的 list
     * @param companyId 公司的id
     * @return 查询到的结果
     */
    List<Record> findRecordByInApplyIdListAndCompanyId(Integer[] applyIdList,Integer companyId);

    /**
     * 学历大于 本科 的所有求职者的 id， 投递职位 的 职位id list，公司 的 id
     * @param applyIdList 学历大于 本科 的所有求职者的 id
     * @param companyId 公司 的 id
     * @param jobIdList 投递职位 的 职位id list
     * @return 查询到的结果
     */
    List<Record> findRecordByInApplyIdListAndCompanyIdAndInJobId(List<Integer> applyIdList,Integer companyId,List<Integer> jobIdList);

    /**
     * 投递阿里巴巴 的测试开发 或者测试+其他职位 的投递者中， 工作年限大于2年的人
     * @param applyIdList 工作年限大于3年的人的id list
     * @param companyId 公司的id
     * @param jobIdList 职位的id 的list
     * @return 满足条件的人
     */
    List<Record> findRecordByInApplyIdListAndJobIdAndCompanyId(Integer[] applyIdList,Integer companyId,Integer[] jobIdList);

}

接口部分的实现：RecordDaoImpl.java

package com.qianbaidu.recruit.dao.impl;

import com.qianbaidu.recruit.dao.IRecordDao;
import com.qianbaidu.recruit.entity.Job;
import com.qianbaidu.recruit.entity.Record;
import com.qianbaidu.recruit.util.DbUtil;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;

public class RecordDaoImpl implements IRecordDao {

    private DbUtil db;

    public RecordDaoImpl() {
        db = DbUtil.INSTANCE;
    }
    @Override
    public void saveRecord(Record record) {
        db.connect();
        String sql = "INSERT INTO apply_record_tab" +
                "(record_id,record_date,apply_id,apply_name,company_id,company_name,job_id,job_name,record_status,record_status_num,interview_date) " +
                "VALUES (?,?,?,?,?,?,?,?,?,?,?)\n";
        db.prepareStatement(sql, 
                record.getId(),
                record.getRecordDate(),record.getApplyId(),record.getApplyName(),
                record.getCompanyId(),record.getCompanyName(),record.getJobId(),
                record.getJobName(),record.getRecordStatus(),record.getReStatusNum(),
                record.getInterviewDate()
        );
        db.executeUpdate();
        db.close();
    }

    @Override
    public Record findById(Integer id) {
        db.connect();
        String sql = "SELECT * FROM apply_record_tab WHERE record_id = ?";
        db.prepareStatement(sql,id);
        ResultSet rs = db.executeQuery();
        Record record = null;
        try {
            if (rs.next()){
                record = new Record(
                        rs.getInt("record_id"),
                        rs.getDate("record_date"),
                        rs.getInt("apply_id"),
                        rs.getString("apply_name"),
                        rs.getInt("company_id"),
                        rs.getString("company_name"),
                        rs.getInt("job_id"),
                        rs.getString("job_name"),
                        rs.getString("record_status"),
                        rs.getInt("record_status_num"),
                        rs.getDate("interview_date")
                );

            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
        db.close();
        return record;
    }

    @Override
    public void failedInitial(Integer recordId) {
        db.connect();
        String sql = "UPDATE apply_record_tab SET record_status='未通过初筛',record_status_num='0',interview_date=null WHERE record_id = ?";
        db.prepareStatement(sql,recordId);
        db.executeUpdate();
        db.close();
    }

    @Override
    public void sendInterview(Integer recordId,String interviewDate) {
        db.connect();
        String sql = "UPDATE apply_record_tab SET record_status='预约面试',record_status_num='2',interview_date=? WHERE record_id = ?";
        db.prepareStatement(sql,interviewDate,recordId);
        db.executeUpdate();
        db.close();
    }

    @Override
    public void finishInterview(Integer recordId, String interviewDate) {
        db.connect();
        String sql = "UPDATE apply_record_tab SET record_status='已面试',record_status_num='3',interview_date=? WHERE record_id = ?";
        db.prepareStatement(sql,interviewDate,recordId);
        db.executeUpdate();
        db.close();
    }

    @Override
    public void passInterview(Integer recordId) {
        db.connect();
        String sql = "UPDATE apply_record_tab SET record_status='通过',record_status_num='4' WHERE record_id = ?";
        db.prepareStatement(sql,recordId);
        db.executeUpdate();
        db.close();
    }

    @Override
    public void failedInterview(Integer recordId) {
        db.connect();
        String sql = "UPDATE apply_record_tab SET record_status='未通过',record_status_num='5' WHERE record_id = ?";
        db.prepareStatement(sql,recordId);
        db.executeUpdate();
        db.close();
    }

    @Override
    public List<Record> findRecordByApplyId(Integer applyId) {
        List<Record> list = new ArrayList<>(10);
        db.connect();
        String sql = "SELECT * FROM apply_record_tab WHERE apply_id = ?";
        return getRecords(applyId, list, sql);
    }

    @Override
    public List<Record> findRecordByJobIDAndCompanyID(Integer[] jobIdList, Integer companyId) {
        List<Record> list = new ArrayList<>(10);
        db.connect();
        String sqlPro = "SELECT * FROM apply_record_tab WHERE job_id IN (";
        for (Integer i:jobIdList){
            sqlPro = sqlPro + i + ",";
        }
        // 把最后一个,号删除
        String sql = sqlPro.replaceAll(",\\s*$", "") + ") AND company_id=?";
        return getRecords(companyId, list, sql);
    }

    @Override
    public List<Record> findRecordByInApplyIdListAndCompanyId(Integer[] applyIdList, Integer companyId) {
        List<Record> list = new ArrayList<>(10);
        db.connect();
        String sqlPro = "SELECT * FROM apply_record_tab WHERE apply_id IN (";
        for (Integer i:applyIdList){
            sqlPro = sqlPro + i + ",";
        }
        // 把最后一个,号删除
        String sql = sqlPro.replaceAll(",\\s*$", "") + ") AND company_id=?";
        System.out.println(sql);
        return getRecords(companyId, list, sql);
    }

    @Override
    public List<Record> findRecordByInApplyIdListAndCompanyIdAndInJobId(List<Integer> applyIdList, Integer companyId, List<Integer> jobIdList) {
        List<Record> list = new ArrayList<>(10);
        db.connect();
        String sqlPro = "SELECT * FROM apply_record_tab WHERE apply_id IN (";
        for (Integer i:applyIdList){
            sqlPro = sqlPro + i + ",";
        }
        // 把最后一个,号删除
        String sqlP = sqlPro.replaceAll(",\\s*$", "") + ") AND company_id=" + companyId +" AND job_id IN (";
        for (Integer j:jobIdList){
            sqlP = sqlP + j + ",";
        }
        String sql = sqlP.replaceAll(",\\s*$", "") + ")";
        System.out.println(sql);
        db.prepareStatement(sql);
        return getRecords(list);
    }

    @Override
    public List<Record> findRecordByInApplyIdListAndJobIdAndCompanyId(Integer[] applyIdList, Integer companyId, Integer[] jobIdList) {
        List<Record> list = new ArrayList<>(10);
        db.connect();
        String sqlPro = "SELECT * FROM apply_record_tab WHERE apply_id IN (";
        for (Integer i:applyIdList){
            sqlPro = sqlPro + i + ",";
        }
        // 把最后一个,号删除
        String sqlP = sqlPro.replaceAll(",\\s*$", "") + ") AND company_id=? AND job_id IN (";
        for (Integer j:jobIdList){
            sqlP = sqlP + j +",";
        }

        String sql = sqlP.replaceAll(",\\s*$", "") + ")";
        return getRecords(companyId, list, sql);
    }

    private List<Record> getRecords(Integer companyId, List<Record> list, String sql) {
        db.prepareStatement(sql,companyId);
        return getRecords(list);
    }

    private List<Record> getRecords(List<Record> list) {
        ResultSet rs = db.executeQuery();
        try {
            while (rs.next()){
                Record record = new Record(
                        rs.getInt("record_id"),
                        rs.getDate("record_date"),
                        rs.getInt("apply_id"),
                        rs.getString("apply_name"),
                        rs.getInt("company_id"),
                        rs.getString("company_name"),
                        rs.getInt("job_id"),
                        rs.getString("job_name"),
                        rs.getString("record_status"),
                        rs.getInt("record_status_num"),
                        rs.getDate("interview_date")
                );
                list.add(record);

            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
        db.close();
        return list;
    }
}

3.Service层的调用
具体的调用在下面企业操作模块和求职者操作模块中；

登陆的业务逻辑解析

1.业务分析和解决方案

业务分析：
1.分两种角色类型，应聘者和招聘者，不同的角色对应不同的业务需求；
2.本质是权限的控制，公司只能操作自己公司的信息，查看和处理自己公司投递的简历；
2.用户只能查和看操作自己的信息，查看自己的投递情况，以及新建一个自己的简历投递；

解决方案：
1.由于在设计的时候，应聘者和招聘者分成两张信息表，包括用户名、密码，两张表有各自唯一的自增id，然后用这个id进行 个人/公司 的信息匹配，查看和修改 个人/公司 自己的信息等；

2.这样的设计下，应聘者用户 和 招聘者用户的 id 是会重复的，因此在登陆的时候需要保留好 登陆的身份信息，比如这里用0老板，1应聘者，从而确定 根据这个id 查询 个人信息表，还是公司信息表；

2.流程拆解–实现和业务

从实现的角度，用户输入用户名、密码、选择（应聘者、企业）进行登录。

从业务的角度：

3.service层的代码

接口部分：只暴露了3个接口，登陆，注册，以及登陆注册的入口函数

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();


}

实现部分的代码：这里老板的登陆方式采用把所有老板的信息查出来，存到Java的list中，然后用boss实体类的equals(对象) 的方法，进行登陆的验证

service的实现类：

package com.qianbaidu.recruit.service.impl;

import com.qianbaidu.recruit.dao.ILoginDao;
import com.qianbaidu.recruit.dao.impl.LoginDaoImpl;
import com.qianbaidu.recruit.entity.Boss;
import com.qianbaidu.recruit.entity.Emp;
import com.qianbaidu.recruit.exception.InputIllegalException;
import com.qianbaidu.recruit.exception.LoginIllegalException;
import com.qianbaidu.recruit.exception.LoginNameNotFoundException;
import com.qianbaidu.recruit.exception.RegisterException;
import com.qianbaidu.recruit.service.ILoginService;
import com.qianbaidu.recruit.ui.LoginMenu;
import org.apache.log4j.Logger;

import java.util.Iterator;
import java.util.List;
import java.util.Objects;

public class LoginServiceImpl implements ILoginService {
    private ILoginDao dao;


    public LoginServiceImpl() {
        dao = new LoginDaoImpl();
    }

    private Integer applyId;
    private Integer companyId;
    private String loginBossName;
    private Emp applyUser;
    private Boss companyUser;

    @Override
    public boolean login(String role) {
        if (role.equals("0")){ // 老板登陆
            try {
                companyUser = loginBoss();
                companyId = companyUser.getId();
                return true;
            } catch (LoginNameNotFoundException e) {
                System.out.println(e.getMessage());
            } catch (LoginIllegalException i){
                Logger.getLogger(this.getClass()).error("招聘者用户 "+ loginBossName+" 密码输入错误");
            }
        }else if(role.equals("1")){ // 应聘者登陆
            try {
                applyUser = loginEmp();
                applyId = applyUser.getId();
                return true;
            } catch (LoginNameNotFoundException e) {
                System.out.println(e.getMessage());
            }catch (LoginIllegalException i){
                String[] errorSplit = i.getMessage().split("\\+");
                Logger.getLogger(this.getClass()).error("应聘者用户 "+ errorSplit[1]+" 密码输入错误");
            }
        }
        return false;
    }

    // 用户登陆的逻辑验证

    /**
     * 应聘者用户登陆逻验证
     */
    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;
    }

    private Boss loginBoss(){
        Integer[] checks = loginBossCheck();
        if (checks[0]!=1){
            throw new LoginNameNotFoundException("404异常，用户名不存在，请注册");
        }
        if (checks[1]!=1){
            throw new LoginIllegalException("405异常，用户名|密码错误，请重新输入+");
        }
        Boss loginBoss = dao.findBoss().get(checks[2]-1);
        Logger.getLogger(this.getClass()).info("招聘者用户 "+loginBoss.getUsername()+" 登陆");
        return loginBoss;
    }

    /**
     * 进行老板的登陆信息验证，返回布尔数组，[用户名是否存在，密码是否正确]
     * @return 返回布尔数组，[用户名是否存在，密码是否正确]
     */
    private Integer[] loginBossCheck(){
        String[] loginInput = LoginMenu.loginUI("0");//（企业0，求职者1）
        // 获得可比较的boss对象
        Boss inBoss = new Boss();
        inBoss.setLoginName(loginInput[0]);
        inBoss.setPassword(loginInput[1]);

        Integer[] checks = new Integer[]{0,0,0}; // 比较的结果
        List<Boss> list = dao.findBoss();
        Iterator<Boss> it = list.iterator();
        while (it.hasNext()){
            Boss b = it.next();
            // 用户名进行比较
            boolean loginNameCheck = b.equals(inBoss);
            boolean loginNameAndPasswordCheck = b.equalsLoginNameAndPassword(inBoss);
            if (loginNameCheck){
                checks[0] = 1;
                loginBossName = b.getUsername();
            }
            if (loginNameAndPasswordCheck){
                checks[1] = 1;
                checks[2] = b.getId();
            }
        }
        return checks;
    }



    // 用户注册的逻辑验证
    /**
     * 用户注册的逻辑
     * @param role 角色选择，0老板，1应聘者
     * @return true注册成功，false注册失败
     */
    @Override
    public boolean sign(String role) {
        if (role.equals("0")){ // 老板注册
            return bossSign(); // 到这一步，说明注册成功
        }else if (role.equals("1")){ // 应聘者注册
            return empSign();
        }
        return false;
    }


    @Override
    public String[] execute() {
        String[] loginMes = new String[2];
        // 1.欢迎界面，进行选择
        String[] wleInput = LoginMenu.welcomeUI().split("-");
        // 2.进行注册，注册成功后，进行登陆
        if (wleInput[1].equals("0")){
            int inputTimes = 0;
            Boolean isContinue = true;
            while (isContinue){
                isContinue = !sign(wleInput[0]); // 0老板，1应聘者
                inputTimes +=1;
                if (inputTimes>=3){
                    LoginMenu.inputManyTime();
                    break;
                }
            }
        }
        // 2.进行登陆，登陆成功后，进行相应操作
        // 连续输错3次，可返回
        int inputTimes = 0;
        Boolean isContinue1 = true;
        while (isContinue1){
            isContinue1 = !login(wleInput[0]); // 0老板，1应聘者
            loginMes[0] = wleInput[0]; // 标识登陆的身份信息，0老板，1应聘者
            inputTimes +=1;
            if (inputTimes>=3){
                LoginMenu.inputManyTime();
                break;
            }
        }
        if (wleInput[0].equals("0")){ // 老板
            loginMes[1] = companyId+"";
            // 在这里加入职位相关的操作


        }else if (wleInput[0].equals("1")){ // 员工
            loginMes[1] = applyId+"";
        }

    return loginMes;

    }


    /**
     * 进行企业用户的注册，采用把数据库的公司用户的用户名等信息存在内存的list中，
     * 减少和数据库的交互，但需要使用循环
     * 利用循环做equals对象方法判断是否存在该用户
     */
    private boolean bossSign(){
        System.out.println("进行企业的注册");
        Boss boss = LoginMenu.addBossUI();
        if (boss!=null){
            try {
                bossRegisterCheck(boss);
                dao.saveBoss(boss);
                Logger.getLogger(this.getClass()).info("新增企业用户："+boss);
                System.out.println("恭喜伯乐 "+boss.getUsername()+" 注册成功，即将返回登陆页面");
                return true;
            } catch (RegisterException e) {
                System.out.println(e.getMessage());
                Logger.getLogger(this.getClass()).error("招聘者 "+boss.getUsername()+" 重复注册");
            }
        }
        return false;
    }

    /**
     * 检查企业用户是否存在，用对象的equals方法进行检查
     * @param boss 在注册界面生成的boss实体
     */
    private void bossRegisterCheck(Boss boss){
        // 企业用户是否已经存在
        List<Boss> list = dao.findBoss();
        Iterator<Boss> it = list.iterator();
        while (it.hasNext()){
            Boss b = it.next();
            if (b.equals(boss)) throw new RegisterException("402异常，招聘者用户名已存在异常");
        }
    }

    /**
     * 应聘者注册页面，用sql语句进行用户名的查询，
     * 需要和数据库交互，但不需要循环
     */
    private boolean empSign(){
        System.out.println("应聘者注册");
        Emp emp = LoginMenu.addEmpUI();
        if (emp!=null){
            // 应聘者登陆名是否存在
            try {
                empRegisterCheck(emp);
                dao.saveEmp(emp);
                Logger.getLogger(this.getClass()).info("新增应聘者用户"+emp);
                System.out.println("恭喜千里马 "+emp.getUsername()+" 注册成功，即将返回登陆页面");
                return true;
            }catch (RegisterException r){
                System.out.println(r.getMessage());
                Logger.getLogger(this.getClass()).error("招聘者 "+emp.getUsername()+" 重复注册");
            }
        }
        return false;
    }

    private void empRegisterCheck(Emp emp){
        // 应聘者用户是否已经存在
        Emp e = dao.findEmpByLoginName(emp.getLoginName());
        if (e!=null) throw new RegisterException("402异常，应聘者用户名已存在异常");
    }

}

Boss的实体类：

package com.qianbaidu.recruit.entity;

import java.util.Objects;

/**
 * 公司登陆的实体类
 */
public class Boss {
    private Integer id;
    private String loginName;
    private String password;
    private String username;
    private Integer login;

    public Boss() {
    }

    public Boss(String loginName, String password, String username) {
        this.loginName = loginName;
        this.password = password;
        this.username = username;
    }

    public Boss(Integer id, String loginName, String password, String username, Integer login) {
        this.id = id;
        this.loginName = loginName;
        this.password = password;
        this.username = username;
        this.login = login;
    }

    @Override
    public String toString() {
        return "boss{" +
                "id=" + id +
                ", loginName='" + loginName + '\'' +
                ", password='" + password + '\'' +
                ", username='" + username + '\'' +
                ", login=" + login +
                '}';
    }

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

    public boolean equalsLoginNameAndPassword(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Boss boss = (Boss) o;
        return Objects.equals(loginName, boss.loginName) && Objects.equals(password, boss.getPassword());
    }

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

企业操作模块

1.业务分析和解决方案

业务分析：
（1）对于应聘者，核心的业务是发布职位，查看简历投递情况，对投递的简历进行筛选和面试相关操作；
（2）权限相关：企业只能查看自己公司的投递情况，对投递自己公司的建立进行操作；
（3）查询相关：企业可以查询某个职位的投递信息，查询某个职位学历高于某个要求的投递信息，查询某个职位工作年限大于某个年数的投递信息；
（4）操作相关：批量拒绝不符合要求的简历投递，对申请人进行面试邀约，面试结束后设置通过或者不通过；
（5）查询的进一步思考：如果某个公司要筛选投递某个职位的人学历大于某个要求的简历投递信息，那么此时公司的关注的是投递人的学历，对于这个业务，我设计了如下展示步骤：

1）根据关键字查询到公司自己发布的职位；
2）根据该职位的投递信息查询到所有投递者中符合学历要求的人的简历详细信息；
3）【公司定位学历】说明关注的是投递者的学历，然后查询到这些符合要求的人投递的我公司的全部投递信息；以此就知道该高学历人才自己认为他能够胜任哪些工作；
4）最终展示根据1.查询到的职位，和2.符合学历要求的人；展示符合简历要求的人投递查询到的职位，的投递信息；

解决方案：
（1）权限的问题----本质是sql的问题，即所有的操作都需要一个老板boss的唯一id；
（2）查询的问题----本质是dao层支持各种查询，然后在service层中灵活调用这些dao；
（3）操作相关的问题----简历投递表是该项目的【重点和难点】该表涉及到应聘者和招聘者的操作，两者之间交互等，本文会用单独的一节来描述该问题；

2.业务的流程解析图

3.公司相关的代码

service的接口部分

package com.qianbaidu.recruit.service;

import com.qianbaidu.recruit.entity.Applicant;
import com.qianbaidu.recruit.entity.Job;
import com.qianbaidu.recruit.entity.Record;

import java.util.List;

public interface ICompanyService {
    /**
     * 企业登陆后进行信息的完善
     * @param id 根据登陆确定的企业的唯一id
     */
    void saveCompanyInformation(Integer id);

    /**
     * 进行职位信息的发布
     * @param id 发布职位的公司的id
     */
    void publishJob(Integer id);

    /**
     * 根据出现在 职位名称 和 简介 中出现的关键字 找出发布的职位信息
     * @param companyId 公司的id
     * @return 找到的自己发布的职位
     */
    List<Job> companyFindJobByKeyWord(Integer companyId);

    /**
     * 根据 出现在 职位名称 和 简介 中出现的关键字 找到 职位， 然后找到 投递简历的人的信息
     * @param companyId 公司的id
     * @return 找到投简历的人的信息
     */
    List<Applicant> companyFindApplicantsByKeyWord(Integer companyId);

    /**
     * 根据 出现在 职位名称 和 简介 中出现的关键字 找到 职位 这些职位的投递信息
     * @param companyId 公司的id
     * @return 找到的应聘等登记表
     */
    List<Record> companyFindRecordByKeyWord(Integer companyId);

    /**
     * 学历大于本科的阿里巴巴 的 某个职位 的投递信息
     * 1-测试：本科以上学历的 测试 职位的申请记录
     * @param companyId 公司id
     * @return 查询结果
     */
    List<Record> companyFindRecordByMoreDegreeAndJobName(Integer companyId);

    /**
     * 工作年限大于 几年 以上的 某个求职 的投递信息
     * 例如：输入 1-测试 表示1年以上经历的 测试 职位的申请记录
     * @param companyId 公司id
     * @return 查询结果
     */
    List<Record> companyFindRecordByMoreWorkYearAndJobName(Integer companyId);

    // 批量拒绝简历
    void cSetFailedInitial(List<Record> rejectRecordList);

    // 进行面试的预约
    void cSendInterview(List<Record> rejectRecordList);

    // 更新面试状态为已完成面试
    void cFinishInterview(List<Record> rejectRecordList);

    // 通过面试
    void cPassInterview(List<Record> recordList);

    // 未通过面试
    void cFailedInterview(List<Record> recordList);


    Boolean execute(Integer companyId);

    Boolean positionMain(Integer companyId);

    Boolean queryJobMain(Integer companyId);

    Boolean interviewMain(Integer companyId);

    Boolean updateInterviewMain(List<Record> rejectRecordList,Integer companyId);

}

service层的实现类：

package com.qianbaidu.recruit.service.impl;

import com.qianbaidu.recruit.dao.IApplicantDao;
import com.qianbaidu.recruit.dao.ICompanyDao;
import com.qianbaidu.recruit.dao.IJobDao;
import com.qianbaidu.recruit.dao.IRecordDao;
import com.qianbaidu.recruit.dao.impl.ApplicantDaoImpl;
import com.qianbaidu.recruit.dao.impl.CompanyDaoImpl;
import com.qianbaidu.recruit.dao.impl.JobDaoImpl;
import com.qianbaidu.recruit.dao.impl.RecordDaoImpl;
import com.qianbaidu.recruit.entity.Applicant;
import com.qianbaidu.recruit.entity.Company;
import com.qianbaidu.recruit.entity.Job;
import com.qianbaidu.recruit.entity.Record;
import com.qianbaidu.recruit.exception.InputIllegalException;
import com.qianbaidu.recruit.service.ICompanyService;
import com.qianbaidu.recruit.service.ILoginService;
import com.qianbaidu.recruit.ui.CompanyMesUI;
import com.qianbaidu.recruit.util.Constance;
import org.apache.log4j.Logger;
import org.omg.CORBA.PRIVATE_MEMBER;

import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

public class CompanyServiceImpl implements ICompanyService {
    private ICompanyDao dao;
    private CompanyMesUI ui;
    private ILoginService lo;
    private IJobDao jobDao;
    private SimpleDateFormat sdf;
    private IRecordDao recordDao;
    private IApplicantDao applicantDao;

    public CompanyServiceImpl() {
        dao = new CompanyDaoImpl();
        ui = CompanyMesUI.getInstance();
        jobDao = new JobDaoImpl();
        sdf = new SimpleDateFormat("yyyy-MM-dd");
        recordDao = new RecordDaoImpl();
        applicantDao = new ApplicantDaoImpl();
    }

    @Override
    public void saveCompanyInformation(Integer id) {
        String[] addInput = ui.addCompanyUI();
        String[] base = addInput[0].split("-");
        String desc = addInput[1];
        String web = addInput[2];
        // 公司的网站，如果没有为null
        if (web.equals("")){
            web = null;
        }
        Company company = new Company(id,
                base[0], // 公司名字
                Integer.parseInt(base[1]), // 公司规模
                base[2], // 位置
                base[3], // 类型
                web, // 官网
                base[4], // 电话
                base[5], // 联系人
                desc, // 简介
                5.0, // 初始分数 5.0
                "5" // 初始rates 5
                );
        dao.save(company);
    }

    @Override
    public void publishJob(Integer id) {
        // 根据id找到 公司的 实体类 ---- 获得名字;
        Company co = dao.findById(id);
        // 调用界面，进行职位的发布
        String[] in = ui.publishJobUI();
        Integer companyId = co.getId();
        String companyName = co.getName();
        String[] baseMesSplit = in[0].split("\\+");
        Integer num = Integer.parseInt(baseMesSplit[0]);
        String jobName = baseMesSplit[1];
        Integer year = Integer.parseInt(baseMesSplit[2]);
        Integer degree = Integer.parseInt(baseMesSplit[3]);
        if (degree>3 || degree<0 ){
            throw new InputIllegalException("输入错误，应该是（大专0，本科1，硕士2，博士3）");
        }
        String dateStr = baseMesSplit[4];
        String desc = in[1];
        Job newJob = null;
        try {
            Date date = sdf.parse(dateStr);
            newJob = new Job(null,companyId,companyName,
                    num,jobName,year,degree,desc,date);
            // 保存日志信息
            Logger.getLogger(this.getClass()).info("ID为 " + companyId +" 的 " + companyName +" 新增职位信息 "+newJob);
            // 职位信息存入数据库
            jobDao.save(newJob);
        } catch (ParseException e) {
            System.out.println("405异常，职位保存出错");
            throw new RuntimeException(e);
        }
    }

    @Override
    public List<Job> companyFindJobByKeyWord(Integer companyId) {
        // 先展示界面
        String in = ui.companyFindJobNameUI();
        System.out.println("---------------输入为 "+ in+" 查询到您发布的职位信息如下-----------------------");
        List<Job> find= jobDao.findJobByKeyWordAndCompanyId(in,companyId);
        System.out.println(find);
        return find;
    }

    @Override
    public List<Applicant> companyFindApplicantsByKeyWord(Integer companyId) {
        // 先根据 关键字 找到 自己发布的职位;
        String in = ui.companyFindApplicantsByJobKeyWordUI();
        List<Job> find = jobDao.findJobByKeyWordAndCompanyId(in,companyId);
        System.out.println("找到发布的职位信息如下");
        System.out.println(find);
        // 然后找到职位的id
        List<Integer> jobListI = new ArrayList<>(10);
        for (Job job:find){
            jobListI.add(job.getJobId());
        }
        Integer[] jobList = new Integer[jobListI.size()];
        jobListI.toArray(jobList);
        List<Record> findRecords = recordDao.findRecordByJobIDAndCompanyID(jobList,companyId);
        System.out.println("找到该职位的投递信息如下：");
        System.out.println(findRecords);
        // 找到投递这些职位的人的信息
        System.out.println("找到投递者些职位的人的信息如下");
        List<Integer> arrayList = new ArrayList<>(10);
        for (Record record:findRecords){
            arrayList.add(record.getJobId());
        }
        List<Applicant> findApplicant = applicantDao.findByIdList(arrayList);
        System.out.println(findApplicant);
        return findApplicant;
    }

    @Override
    public List<Record> companyFindRecordByKeyWord(Integer companyId) {
        // 先根据 关键字 找到 自己发布的职位;
        String in = ui.companyFindApplicantsByJobKeyWordUI();
        List<Job> find = jobDao.findJobByKeyWordAndCompanyId(in,companyId);
        System.out.println("找到发布的职位信息如下");
        System.out.println(find);
        // 然后找到职位的id
        List<Integer> jobListI = new ArrayList<>(10);
        for (Job job:find){
            jobListI.add(job.getJobId());
        }
        Integer[] jobList = new Integer[jobListI.size()];
        jobListI.toArray(jobList);
        List<Record> findRecords = recordDao.findRecordByJobIDAndCompanyID(jobList,companyId);
        System.out.println("找到该职位的投递信息如下：");
        System.out.println(findRecords);
        return findRecords;
    }


    @Override
    public List<Record> companyFindRecordByMoreDegreeAndJobName(Integer companyId) {
        String in = ui.companyFindRecordByJobNameAndMoreDegree();
        String[] inSplit = in.split("-");
        Integer degree = Integer.parseInt(inSplit[0]);
        if (degree>3){
            throw new InputIllegalException("输入错误，应该是（大专0，本科1，硕士2，博士3）");
        }
        String jobName = inSplit[1];
        // 先找到该职位的信息
        List<Job> findJob = jobDao.findJobByLikeName(jobName, companyId);
        System.out.println("--------------------------------------------------------------------------------------");
        System.out.println("根据职位名称 【"+ jobName + "】 模糊查询 找到职位信息如下");
        System.out.println(findJob);

        // 根据职位信息 查询 投递的记录表
        List<Integer> jobListI = new ArrayList<>(10);
        List<String> jobNameList = new ArrayList<>(10);
        for (Job job:findJob){
            jobListI.add(job.getJobId());
            jobNameList.add(job.getName());
        }
        Integer[] jobList = new Integer[jobListI.size()];
        jobListI.toArray(jobList);
        List<Record> findRecord = recordDao.findRecordByJobIDAndCompanyID(jobList,companyId);
        System.out.println("--------------------------------------------------------------------------------------");
        System.out.println("找到 职位 【"+jobNameList+"】 投递信息 如下");
        System.out.println(findRecord);
        // 拿到投递这些职位的人的 id
        List<Integer> applyListI = new ArrayList<>(10);
        for (Record record:findRecord){
            applyListI.add(record.getApplyId());
        }
        Integer[] applyList = new Integer[applyListI.size()];
        applyListI.toArray(applyList);
        List<Applicant> findApplicants = applicantDao.findByMoreDegreeAndApplyIdInList(applyList, degree);
        System.out.println("--------------------------------------------------------------------------------------");
        System.out.println("投递职位的人中满足学历要求 【"+ Constance.showDegree(degree) + " 以上】 的人为");

        System.out.println(findApplicants);
        if (findApplicants.isEmpty()){
            System.out.println("未找到符合要求的简历投递人");
            return new ArrayList<>();
        }
        // 拿到满足学历要求的人的 id
        List<Integer> appList = new ArrayList<>(10);
        List<String> applyNameList = new ArrayList<>(10);
        for (Applicant applicant:findApplicants){
            appList.add(applicant.getId());
            applyNameList.add(applicant.getName());
        }
        Integer[] applyList1 = new Integer[appList.size()];
        appList.toArray(applyList1);

        // 满足学历要求的人的id 数组
        System.out.println();

        List<Record> find = recordDao.findRecordByInApplyIdListAndCompanyId(applyList1,companyId);
        System.out.println("--------------------------------------------------------------------------------------");
        System.out.println("求职者 【"+ applyNameList + "】 投递我公司 的所有职位信息如下");
        System.out.println(find);

        // 根据 公司id， 职位job id， 申请人id 查找投递信息
        List<Record> result = recordDao.findRecordByInApplyIdListAndCompanyIdAndInJobId(Arrays.asList(applyList1), companyId, Arrays.asList(jobList));

        System.out.println("--------------------------------------------------------------------------------------");
        System.out.println("根据职位名称 【"+jobName+"】 模糊查询 投递我公司 【"+jobNameList+"】 职位的 申请人中 学历要求 在 【"+ Constance.showDegree(degree) +"】 学历以上的 投递记录如下");
        System.out.println(result);

        return result;
    }

    @Override
    public List<Record> companyFindRecordByMoreWorkYearAndJobName(Integer companyId) {
        String in = ui.companyFindRecordByJobNameAndMoreWorkYear();
        String[] inSplit = in.split("-");
        Integer workYear = Integer.parseInt(inSplit[0]);
        if (workYear<0){
            throw new InputIllegalException("输入错误，工作年限要大于1");
        }
        String jobName = inSplit[1];
        // 先找到该职位的信息
        List<Job> findJob = jobDao.findJobByLikeName(jobName, companyId);
        System.out.println("--------------------------------------------------------------------------------------");
        System.out.println("根据关键字【"+jobName+"】找到职位信息如下");
        System.out.println(findJob);

        // 根据职位信息 查询 投递的记录表
        List<Integer> jobListI = new ArrayList<>(10);
        List<String> jobNameList= new ArrayList<>(10);
        for (Job job:findJob){
            jobListI.add(job.getJobId());
            jobNameList.add(job.getName());
        }
        Integer[] jobList = new Integer[jobListI.size()];
        jobListI.toArray(jobList);
        List<Record> findRecord = recordDao.findRecordByJobIDAndCompanyID(jobList,companyId);
        System.out.println("--------------------------------------------------------------------------------------");
        System.out.println("找职位【"+jobNameList+"】的投递记录表如下");
        System.out.println(findRecord);

        // 拿到投递这些职位的 id 满足条件的职位 id 的List
        List<Integer> matchApply = new ArrayList<>(10);
        List<Integer> matchJobList = new ArrayList<>(10);
        for (Record record:findRecord){
            matchJobList.add(record.getJobId());
            matchApply.add(record.getApplyId());
        }
        Integer[] mJobList = new Integer[matchJobList.size()];
        matchJobList.toArray(mJobList);
        Integer[] mApplyList = new Integer[matchApply.size()];
        matchApply.toArray(mApplyList);
        List<Applicant> findApplicants = applicantDao.findByMoreWorkYearAndApplyIdInList(mApplyList, workYear);
        System.out.println("--------------------------------------------------------------------------------------");
        System.out.println("投递 职位 【"+jobNameList+"】的人中满足 工作年限要求 【"+workYear+"以上】 的求职者如下");
        System.out.println(findApplicants);
        // 拿到满足工作年限要求的 人的 id
        List<Integer> mApply = new ArrayList<>(10);
        for (Applicant app:findApplicants){
            mApply.add(app.getId());
        }
        Integer[] mAList = new Integer[matchApply.size()];
        mApply.toArray(mAList);
        List<Record> find = recordDao.findRecordByInApplyIdListAndJobIdAndCompanyId(mAList,companyId,mJobList);
        System.out.println("--------------------------------------------------------------------------------------");
        System.out.println("根据职位名称 【"+jobName+"】 模糊查询 投递我公司 【"+jobNameList+"】 职位的 申请人中 工作年限 在 【"+ workYear +"】 年以上的 投递记录如下");
        System.out.println(find);
        return find;
    }

    @Override
    public void cSetFailedInitial(List<Record> rejectRecordList) {
        // 根据上一步查找到的简历信息如下
        String in = ui.companyRejectApplicantByRecordId();
        String[] inList = in.split("-");
        List<Integer> integerList = new ArrayList<>(5);
        for (String i:inList){
            integerList.add(Integer.parseInt(i));
        }
        // 获得所有要拒绝的所有 记录 id
        System.out.println("您要 设置 id为 "+integerList+ " 的投递记录状态 为 未通过简历初筛");
        for (Record i:rejectRecordList){
            if (integerList.contains(i.getId())){
                recordDao.failedInitial(i.getId());
                System.out.println("设置未通过 的 投递记录 如下");
                System.out.println("更新前为");
                System.out.println(i);
                System.out.println("更新后为");
                System.out.println(recordDao.findById(i.getId()));
            }
        }
    }

    @Override
    public void cSendInterview(List<Record> rejectRecordList) {
        // 根据上一步查找到的简历信息如下
        String in = ui.companySendInterviewUI();
        String[] inList = in.split("\\+");
        Integer id = Integer.parseInt(inList[0]);
        String strDate = inList[1];
        // 输入 10+2023-05-17 表示 给 记录为id 的 发送面试邀请
        System.out.println("您要 设置 id为 【"+id+ "】 的投递记录状态 为 发送面试邀请,面试时间为 【"+strDate+"】");
        for (Record i:rejectRecordList){
            if (id.equals(i.getId())){
                recordDao.sendInterview(id, strDate);
                System.out.println("发送面试邀请 的 投递记录 如下");
                System.out.println("更新前为");
                System.out.println(i);
                System.out.println("更新后为");
                System.out.println(recordDao.findById(i.getId()));
            }
        }
    }

    @Override
    public void cFinishInterview(List<Record> rejectRecordList) {
        // 根据上一步查找到的简历信息如下
        String in = ui.companyFinishInterviewUI();
        String[] inList = in.split("\\+");
        Integer id = Integer.parseInt(inList[0]);
        String strDate = inList[1];
        // 输入 10+2023-05-17 表示 给 记录为id 的 设置完成面试，时间为2023-05-17
        System.out.println("您要 设置 id为 【"+id+ "】 的投递记录状态 为 完成面试,完成面试的时间为 【"+strDate+"】");
        for (Record i:rejectRecordList){
            if (id.equals(i.getId())){
                recordDao.finishInterview(id, strDate);
                System.out.println("完成面试的 的 投递记录 如下");
                System.out.println("更新前为");
                System.out.println(i);
                System.out.println("更新后为");
                System.out.println(recordDao.findById(i.getId()));
            }
        }
    }

    @Override
    public void cPassInterview(List<Record> recordList) {
        // 根据上一步查找到的简历信息如下
        String in = ui.companyPassInterviewUI();
        String[] inList = in.split("-");
        List<Integer> integerList = new ArrayList<>(5);
        for (String i:inList){
            integerList.add(Integer.parseInt(i));
        }
        // 获得所有要拒绝的所有 记录 id
        System.out.println("您要 设置 id为 "+integerList+ " 的投递记录状态 为 通过面试，即将发送offer");
        for (Record i:recordList){
            if (integerList.contains(i.getId())){
                recordDao.passInterview(i.getId());
                System.out.println("即将 设置 通过面试 的 投递记录 如下");
                System.out.println("更新前为");
                System.out.println(i);
                System.out.println("更新后为");
                System.out.println(recordDao.findById(i.getId()));
            }
        }
    }

    @Override
    public void cFailedInterview(List<Record> recordList) {
        // 根据上一步查找到的简历信息如下
        String in = ui.companyNotPassInterviewUI();
        String[] inList = in.split("-");
        List<Integer> integerList = new ArrayList<>(5);
        for (String i:inList){
            integerList.add(Integer.parseInt(i));
        }
        // 获得所有要拒绝的所有 记录 id
        System.out.println("您要 设置 id为 "+integerList+ " 的投递记录状态 为 未通过面试，即将发送offer");
        for (Record i:recordList){
            if (integerList.contains(i.getId())){
                recordDao.failedInterview(i.getId());
                System.out.println("即将 设置 未通过面试 的 投递记录 如下");
                System.out.println("更新前为");
                System.out.println(i);
                System.out.println("更新后为");
                System.out.println(recordDao.findById(i.getId()));
            }
        }
    }


    @Override
    public Boolean execute(Integer companyId) {
        // 先出界面
        String in = ui.choiceUI();
        if (in.equals("1")){
            Boolean isContinue = true;
            while (isContinue){
                isContinue = positionMain(companyId);
            }
        }else if (in.equals("2")){
            Boolean isContinue = true;
            while (isContinue){
                isContinue = interviewMain(companyId);
            }
        }else if (in.equals("0")){
            System.out.println("返回上一级界面");
            return false;
        }else {
            System.out.println("输入错误，重新输入");
        }
        return true;
    }

    @Override
    public Boolean positionMain(Integer companyId) {
        // 出界面
        String in =ui.positionUI();
        if (in.equals("1")){
            publishJob(companyId);
        }else if (in.equals("2")){
            System.out.println(jobDao.findAllJobs());
        }else if (in.equals("3")){
            // 进入分类查询子界面
            System.out.println("进入分类查询子界面");
            Boolean isContinue = true;
            while (isContinue){
                isContinue = queryJobMain(companyId);
            }
        }else if (in.equals("0")){
            System.out.println("返回上一级界面");
            return false;
        }else {
            System.out.println("输入错误，重新输入");
        }
        return true;
    }

    @Override
    public Boolean queryJobMain(Integer companyId) {
        // 分类子查询界面
        String in = ui.positionQueryUI();
        if (in.equals("1")){
            companyFindJobByKeyWord(companyId);
        }else if (in.equals("2")){
            companyFindApplicantsByKeyWord(companyId);
        }else if (in.equals("0")){
            System.out.println("返回上一级界面");
            return false;
        }else {
            System.out.println("输入错误，重新输入");
        }
        return true;
    }

    @Override
    public Boolean interviewMain(Integer companyId) {
        // 面试相关的操作的界面
        String in = ui.interviewUI();
        if (in.equals("1")){
            List<Record> find = companyFindRecordByKeyWord(companyId);
            if (find.isEmpty()){
                System.out.println("未找到符合要求的投递者，请返回上一级目录");
            }
            // 查找到职位信息，进行修改
            Boolean isCon = true;
            while (isCon){
                isCon = updateInterviewMain(find, companyId);
            }
        }else if (in.equals("2")){
            List<Record> find = companyFindRecordByMoreDegreeAndJobName(companyId);
            if (find.isEmpty()){
                System.out.println("未找到符合要求的投递者，请返回上一级目录");
            }
            // 查找到职位信息，进行修改
            Boolean isCon = true;
            while (isCon){
                isCon = updateInterviewMain(find, companyId);
            }
        }else if (in.equals("3")){
            List<Record> find = companyFindRecordByMoreWorkYearAndJobName(companyId);
            if (find.isEmpty()){
                System.out.println("未找到符合要求的投递者，请返回上一级目录");
            }
            // 查找到职位信息，进行修改
            Boolean isCon = true;
            while (isCon){
                isCon = updateInterviewMain(find, companyId);
            }
        } else if (in.equals("0")){
            System.out.println("返回上一级界面");
            return false;
        }else {
            System.out.println("输入错误，重新输入");
        }
        return true;
    }

    @Override
    public Boolean updateInterviewMain(List<Record> recordList,Integer companyId) {
        //  进行**未通过初筛0，申请中1，预约面试2，已面试3，通过4，不通过5** 操作
        String in = ui.updateInterviewStatusUI();
        if (in.equals("1")){
            cSetFailedInitial(recordList);
        }else if (in.equals("2")){
            cSendInterview(recordList);
        } else if (in.equals("3")){
            cFinishInterview(recordList);
        } else if (in.equals("4")){
            cPassInterview(recordList);
        } else if (in.equals("5")){
            cFailedInterview(recordList);
        }else if (in.equals("0")){
            return false;
        }else {
            System.out.println("输入错误，重新输入");
        }
        return true;
    }
}

求职者操作模块

1.业务分析和解决方案

业务分析：
（1）核心业务：进行简历的投递 和 对公司进行评分；

（2）职位查询：对于应聘者来讲，对公司的查询以及对职位的查询都是为了进行简历的投递，在本控制台项目中，求职者先进行职位查询，支持通过关键字，工作年限要求，公司名字进行职位查询，其中关键字指的是出现在职位名称和职位简介中的关键字；工作年限的要求是小于等于某个年限要求的职位信息；公司名字查询为求职者看重某个公司的平台，因此想要通过公司名看该公司所有的招聘信息；

（3）简历投递：根据上一步查询到的职位信息，应聘者会对心仪的职位进行简历投递，参考常见的求职app，本控制台项目支持应聘者批量简历投递；同时在简历投递之前，会展示该求职者目前所有简历投递状况，列出还未投递过的建立

（4）公司评分：首先不是所有人都能对公司进行评分，在本控制台项目中设定只有获得企业面试邀请并且参加面试后，无论结果通过与否都可以进行公司的评价；

2.业务流程拆解

简历投递的步骤：

3.求职者操作相关代码

service接口部分代码：

package com.qianbaidu.recruit.service;

import com.qianbaidu.recruit.entity.Company;
import com.qianbaidu.recruit.entity.Job;
import com.qianbaidu.recruit.entity.Record;

import java.util.List;

public interface IApplicantService {

    /**
     * 新增 求职者 信息
     * @param applyId 求职者的id
     */
    void addApplicantMess(Integer applyId);

    /**
     * 修改 简历 信息 ，修改地址，自我介绍，工作年限
     * @param applyId 修改的id
     */
    void updateAppAddressDescWorkYear(Integer applyId);

    /**
     * 根据查找到的结果进行职位的申请
     * @param findJobs 查找到的职位
     * @param applyId 申请人的id
     */
    void addApplyRecord(List<Job> findJobs,Integer applyId);

    // 根据名字找公司
    List<Company> appFindCompanyByName(Integer applyId);

    // 根据类型找公司
    List<Company> appFindCompanyByType(Integer applyId);

    // 根据规模找公司
    List<Company> appFindCompanyMoreSize(Integer applyId);

    // 根据公司评分找公司
    List<Company> appFindCompanyMoreRate(Integer applyId);

    // 根据关键字找职位
    List<Job> appFindJobByKeyWord(Integer applyId);

    // 根据工作年限 找职位
    List<Job> appFindJobMoreYear(Integer applyId);

    // 求职者查看职位 申请
    List<Record> appViewJobRecord(Integer applyId);

    // 根据公司名字找职位
    List<Job> appFindJobByCompanyName(Integer applyId);

    // 申请人对公司进行评分
    List<Job> appRateCompany(Integer applyId);

    // 找公司的主业务入口程序，输入为操作的用户的编号
    Boolean queryCompanyMain(Integer applyId);

    // 查找工作相关业务的入口程序，
    Boolean queryJobMain(Integer applyId);

    Boolean addJobApplyMain(List<Job> findJobs,Integer applyId);

    // 主要入口函数
    Boolean execute(Integer applyId);
}

service实现部分代码：

package com.qianbaidu.recruit.service.impl;

import com.qianbaidu.recruit.dao.IApplicantDao;
import com.qianbaidu.recruit.dao.ICompanyDao;
import com.qianbaidu.recruit.dao.IJobDao;
import com.qianbaidu.recruit.dao.IRecordDao;
import com.qianbaidu.recruit.dao.impl.ApplicantDaoImpl;
import com.qianbaidu.recruit.dao.impl.CompanyDaoImpl;
import com.qianbaidu.recruit.dao.impl.JobDaoImpl;
import com.qianbaidu.recruit.dao.impl.RecordDaoImpl;
import com.qianbaidu.recruit.entity.Applicant;
import com.qianbaidu.recruit.entity.Company;
import com.qianbaidu.recruit.entity.Job;
import com.qianbaidu.recruit.entity.Record;
import com.qianbaidu.recruit.exception.InputIllegalException;
import com.qianbaidu.recruit.service.IApplicantService;
import com.qianbaidu.recruit.ui.ApplicantMenuUI;
import com.qianbaidu.recruit.util.Constance;

import java.rmi.server.UID;
import java.sql.SQLOutput;
import java.text.SimpleDateFormat;
import java.util.*;

public class ApplicantServiceImpl implements IApplicantService {
    private ApplicantMenuUI ui;
    private IApplicantDao appDao;
    private ICompanyDao compDao;
    private IJobDao jobDao;
    private IRecordDao recDao;

    public ApplicantServiceImpl(){
        ui = ApplicantMenuUI.APPLY_UI;
        appDao = new ApplicantDaoImpl();
        compDao = new CompanyDaoImpl();
        jobDao = new JobDaoImpl();
        recDao = new RecordDaoImpl();
    }

    @Override
    public void addApplicantMess(Integer applyId) {
        // 先出界面
        String[] in = ui.addApplicantMessUI();
        String[] base = in[0].split("-");
        String name = base[0];
        Integer age = Integer.parseInt(base[1]);
        String gender = base[2];
        String phone = base[3];
        String wechat = base[4];
        String address =null;
        if (!in[1].equals("")){
            address = in[1];
        }
        String qq = base[5];
        String email = base[6];
        Integer degree = Integer.parseInt(base[7]);
        if (degree>3 || degree<0 ){
            throw new InputIllegalException("输入错误，应该是（大专0，本科1，硕士2，博士3）");
        }
        String university = base[8];
        Integer workYear = Integer.parseInt(base[9]);
        String desc = null;
        if (!in[2].equals("")){
            desc = in[2];
        }
        String experience =null;
        if (!in[3].equals("")){
            experience = in[3];
        }

        Applicant app =new Applicant(applyId,name,age,gender,phone,wechat,address,qq,email,degree,workYear,university,desc,experience);
        System.out.println("新增 应聘者信息 如下");
        System.out.println(app);
        appDao.save(app);
        // 添加信息到数据库
    }

    @Override
    public void updateAppAddressDescWorkYear(Integer applyId) {
        // 先出界面
        String[] in = ui.updateApplicantMessUI();
        String[] in1 = in[0].split("-");
        String newAddress = in1[0];
        String newWokeYear = in1[1];
        String newDesc = in[1];
        System.out.println("更新简历前的个人信息");
        Applicant beforeApp = appDao.findById(applyId);
        System.out.println(beforeApp);
        appDao.updateAddressDescYear(new String[]{newAddress,newDesc,newWokeYear}, applyId);
        System.out.println("更新简历后的个人信息");
        System.out.println(appDao.findById(applyId));
    }

    @Override
    public void addApplyRecord(List<Job> findJobs, Integer applyId) {
        // 找到 求职者已经投递过的职位，列出可以投递的 未投递过的 职位
        // 先根据id 在职位申请记录表 中 找出自己投递过的 所有 职位的 id
        List<Record> findRecords = recDao.findRecordByApplyId(applyId);
        System.out.println("您已经投递过的 职位申请记录表 如下");
        System.out.println(findRecords);
        List<Integer> findJobId = new ArrayList<>();
        for (Record r:findRecords){
            findJobId.add(r.getJobId());
        }
        Set<Integer> setJobId = new HashSet<>(findJobId);
        System.out.println("其中职位的 iD 为" + setJobId);
        // 根据上面找到的id 在 职位表 表 中 已经投递过， 未投递过的职位 信息；
        List<Job> appliedJobs = new ArrayList<>(5);
        List<Job> notAppliedJobs = new ArrayList<>(5);
        List<Job> allJobs = jobDao.findAllJobs();
        System.out.println("所有职位信息如下：");
        System.out.println(allJobs);
        List<Integer> canApplyJobIds = new ArrayList<>(4);
        for (Job j:allJobs){
            if (setJobId.contains(j.getJobId())){ // 包含，说明投递过
                appliedJobs.add(j);
            }else {
                notAppliedJobs.add(j);
                canApplyJobIds.add(j.getJobId());
            }
        }
        System.out.println("投递过的职位如下");
        System.out.println(appliedJobs);
        System.out.println("还未投递的职位如下：");
        System.out.println(notAppliedJobs);
        // 获得所有可以继续投递的 简历职位的id

        // 输入 职位的id 进行职位的申请
        String[] in = ui.applyJobByIdUI(canApplyJobIds).split("-");
        List<Integer> applyJobIds = new ArrayList<>(5);
        for (String i:in){
            applyJobIds.add(Integer.parseInt(i));
        }
//        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
//        Date nowDate = new Date();

        for (Integer i:applyJobIds){
            // 申请人的实体类，公司的实体类，职位的信息
            Applicant app = appDao.findById(applyId);
            Job job = jobDao.findById(i);
            Company company = compDao.findById(job.getCompanyId());
            Date recordDate = new Date();
            String applyName = app.getName();
            Integer companyId = company.getId();
            String companyName = company.getName();
            Integer jobId = job.getJobId();
            String JobName = job.getName();
            String recordStatus = "申请中";
            Integer reStatusNum = 1;
            Date interviewDate =null;
            Record record = new Record(null, recordDate, applyId,applyName,companyId, companyName,jobId,JobName,recordStatus, reStatusNum,interviewDate);
            System.out.println("新建职位申请");
            System.out.println(record);
            recDao.saveRecord(record);
        }
        // 根据 职位 信息表 找到公司
    }



    @Override
    public List<Company> appFindCompanyByName(Integer applyId) {
        // 1.界面
        String companyName = ui.findCompanyByName();
        // 2.接口
        List<Company> find = compDao.findCompanyByLikeName(companyName);
        System.out.println("根据关键字【"+ companyName + "】找到的公司如下：");
        System.out.println(find);
        return find;
    }

    @Override
    public List<Company> appFindCompanyByType(Integer applyId) {
        // 1.界面
        String compType = ui.findCompanyByType();
        // 2.接口
        List<Company> find = compDao.findCompanyByLikeType(compType);
        System.out.println("根据企业类型【"+ compType + "】找到的公司如下：");
        System.out.println(find);
        return find;
    }

    @Override
    public List<Company> appFindCompanyMoreSize(Integer applyId) {
        // 1.界面
        Integer compSize = Integer.parseInt(ui.findCompanyBySize());
        // 2.接口
        List<Company> find = compDao.findCompanyByMoreSize(compSize);
        System.out.println("根据企业规模大于等于【"+ Constance.showCompanySize(compSize) + "】找到的公司如下：");
        System.out.println(find);
        return find;
    }

    @Override
    public List<Company> appFindCompanyMoreRate(Integer applyId) {
        // 1.界面
        String compRate = ui.findCompanyByRate();
        // 2.接口
        List<Company> find = compDao.findCompanyByMoreRate(compRate);
        System.out.println("根据企业 好评 大于等于【"+ compRate + "】找到的公司如下：");
        System.out.println(find);
        return find;
    }

    @Override
    public List<Job> appFindJobByKeyWord(Integer applyId) {
        // 找到 招聘的职位 信息
        String jobKeyWord = ui.findJobByName();
        List<Job> findJob = jobDao.findJobByKeyWord(jobKeyWord);
        System.out.println("根据关键字 【"+ jobKeyWord + "】找到 的 招聘信息 如下：");
        System.out.println(findJob);
        // 显示这些职位 的 公司信息
        List<Integer> compIds = new ArrayList<>(10);
        for(Job j:findJob){
            compIds.add(j.getCompanyId());
        }
        System.out.println("发布 这些职位的公司信息如下 ");
        Set<Integer> compSet = new HashSet<>(compIds);
        for (Integer i:compSet){
            Company comp = compDao.findById(i);
            System.out.println(comp);
        }
        return findJob;
    }

    @Override
    public List<Job> appFindJobMoreYear(Integer applyId) {
        // 先找到职位信息
        String[] in = ui.findJobByWorkYear().split("-");
        Integer flag = Integer.parseInt(in[0]);
        Integer workYear = Integer.parseInt(in[1]);
        List<Job> findJobs = new ArrayList<>(10);
        if (flag==0){
            System.out.println("小于工作年限要求"+in[1]+" 年的 职位信息如下");
            findJobs = jobDao.findJobByLessYear(workYear);
        }else if (flag==1){
            System.out.println("大于工作年限要求"+in[1]+" 年的 职位信息如下");
            findJobs = jobDao.findJobByMoreYear(workYear);
        }
        System.out.println(findJobs);
        // 再找到发布这些职位的公司信息
        // 显示这些职位 的 公司信息
        List<Integer> compIds = new ArrayList<>(10);
        for(Job j:findJobs){
            compIds.add(j.getCompanyId());
        }
        System.out.println("发布 这些职位的公司信息如下 ");
        Set<Integer> compSet = new HashSet<>(compIds);
        for (Integer i:compSet){
            Company comp = compDao.findById(i);
            System.out.println(comp);
        }
        return findJobs;
    }

    @Override
    public List<Record> appViewJobRecord(Integer applyId) {
        System.out.println("查找到的 应聘记录表 如下");
        List<Record> find = recDao.findRecordByApplyId(applyId);
        System.out.println(find);

        List<Record> failedInitial = new ArrayList<>(5);
        List<Record> applying = new ArrayList<>(5);
        List<Record> getInterview = new ArrayList<>(5);
        List<Record> finishInterview = new ArrayList<>(5);
        List<Record> passInterview = new ArrayList<>(5);
        List<Record> failedInterview = new ArrayList<>(5);
        for (Record i:find){
            Integer c = i.getReStatusNum();
            switch (c){
                case 0:
                    failedInitial.add(i);
                    break;
                case 1:
                    applying.add(i);
                    break;
                case 2:
                    getInterview.add(i);
                    break;
                case 3:
                    finishInterview.add(i);
                    break;
                case 4:
                    passInterview.add(i);
                    break;
                case 5:
                    failedInterview.add(i);
                    break;
            }
        }
        System.out.println("---------------------------------------------");
        System.out.println("申请中的投递信息");
        System.out.println(applying);
        System.out.println("---------------------------------------------");
        System.out.println("未通过简历初筛的投递信息");
        System.out.println(failedInitial);
        System.out.println("---------------------------------------------");
        System.out.println("收到面试邀请的投递信息");
        System.out.println(getInterview);
        System.out.println("---------------------------------------------");
        System.out.println("已经面试的投递信息");
        System.out.println(finishInterview);
        System.out.println("---------------------------------------------");
        System.out.println("通过面试 的投递信息");
        System.out.println(passInterview);
        System.out.println("---------------------------------------------");
        System.out.println("未通过面试 的投递信息");
        System.out.println(failedInterview);

        return find;
    }

    @Override
    public List<Job> appFindJobByCompanyName(Integer applyId) {
        // 先根据 职位关键字 找公司
        String in = ui.findCompByJobKeyWordThenShowJob();
        // 1.找到职位
        List<Job> findJobs = jobDao.findJobByKeyWord(in);
        System.out.println(findJobs);
        // 2.找到公司
        List<Integer> compIds = new ArrayList<>(10);
        for(Job j:findJobs){
            compIds.add(j.getCompanyId());
        }
        System.out.println(" 发布这些职位的公司如下 ");
        Set<Integer> compSet = new HashSet<>(compIds);
        for (Integer i:compSet){
            Company comp = compDao.findById(i);
            System.out.println(comp);
            // 3.根据公司分类显示职位信息
            // 根据公司 id 找职位
            System.out.println("该 公司 发布的 职位 如下");
            System.out.println("------------------------------------------------------");
            System.out.println(comp.getId());
            System.out.println(jobDao.findByCompanyId(comp.getId()));
        }

        // 然后 查询到这些公司 的招聘信息
        return findJobs;
    }

    @Override
    public List<Job> appRateCompany(Integer applyId) {
        // 先找到 该求职 者 投递过的职位信息 中通过 面试，或者 未通过 面试的 求职记录信息
        List<Record> find = recDao.findRecordByApplyId(applyId);
        System.out.println("您投递过的信息如下");
        System.out.println(find);

        List<Record> canRate = new ArrayList<>(5);
        for (Record i:find){
            if (i.getReStatusNum()==4 || i.getReStatusNum()==5){
                canRate.add(i);
            }
        }
        System.out.println("已经出结果的投递信息");
        System.out.println(canRate);
        // 找到可以进行评分的公司id
        List<Integer> compIds = new ArrayList<>(10);
        for(Record j:canRate){
            compIds.add(j.getCompanyId());
        }
        System.out.println("出面试 结果 的职位的 公司信息如下 ");
        Set<Integer> compSet = new HashSet<>(compIds);
        for (Integer i:compSet){
            Company comp = compDao.findById(i);
            System.out.println(comp);
        }
        // 出界面
        String[] in = ui.applyRateCompUI(compSet).split("-");
        Integer companyId = Integer.parseInt(in[0]);
        Integer rate = Integer.parseInt(in[1]);
        if (rate>10 || rate<0){
            System.out.println("评分错误，（1~10）打分");
            return null;
        }
        if (!compSet.contains(companyId)){
            System.out.println("公司输入错误，请输入您可以评价的公司编号"+compSet);
            return null;
        }
        System.out.println("评分前公司的信息如下");
        System.out.println(compDao.findById(companyId));
        compDao.updateCompanyRate(in[1],companyId);
        System.out.println("评分后公司的信息如下");
        System.out.println(compDao.findById(companyId));
        return null;
    }

    @Override
    public Boolean queryCompanyMain(Integer applyId) {
        // 出公司查询界面
        String in = ui.appQueryComp();
        if (in.equals("1")){
            appFindCompanyByName(applyId);
        }else if (in.equals("2")){
            appFindCompanyByType(applyId);
        } else if (in.equals("3")){
            appFindCompanyMoreSize(applyId);
        } else if (in.equals("4")){
            appFindCompanyMoreRate(applyId);
        } else if (in.equals("0")){
            return false;
        }else {
            System.out.println("输入错误，重新输入");
        }
        return true;

    }

    @Override
    public Boolean queryJobMain(Integer applyId) {
        // 出职位查询界面
        String in = ui.appQueryJob();
        if (in.equals("1")){
            List<Job> find = appFindJobByKeyWord(applyId);
            if (find.isEmpty()){
                System.out.println("未找到合适的职位，请返回上一级界面");
            }
            // 查找到职位信息，进行修改
            Boolean isCon = true;
            while (isCon){
                isCon = addJobApplyMain(find,applyId);
            }

        }else if (in.equals("2")){
            List<Job> find = appFindJobMoreYear(applyId);
            if (find.isEmpty()){
                System.out.println("未找到合适的职位，请返回上一级界面");
            }
            // 查找到职位信息，进行修改
            Boolean isCon = true;
            while (isCon){
                isCon = addJobApplyMain(find,applyId);
            }

        } else if (in.equals("3")){
            List<Job> find = appFindJobByCompanyName(applyId);
            if (find.isEmpty()){
                System.out.println("未找到合适的职位，请返回上一级界面");
            }
            // 查找到职位信息，进行修改
            Boolean isCon = true;
            while (isCon){
                isCon = addJobApplyMain(find,applyId);
            }

        } else if (in.equals("0")){
            return false;
        }else {
            System.out.println("输入错误，重新输入");
        }
        return true;
    }

    @Override
    public Boolean addJobApplyMain(List<Job> findJobs,Integer applyId) {
        // 进行职位的申请
        String in = ui.appApplyJobUI();
        if (in.equals("1")){
            System.out.println("进行职位申请的操作");
            addApplyRecord(findJobs,applyId);
        } else if (in.equals("0")){
            return false;
        }else {
            System.out.println("输入错误，重新输入");
        }
        return true;
    }

    @Override
    public Boolean execute(Integer applyId) {
        // 主界面
        String in = ui.appExecuteUI();
        if (in.equals("1")){
            updateAppAddressDescWorkYear(applyId);
        }else if (in.equals("2")){
            queryCompanyMain(applyId);
        } else if (in.equals("3")){
            queryJobMain(applyId);
        } else if (in.equals("4")){
            appViewJobRecord(applyId);
        } else if (in.equals("5")){
            appRateCompany(applyId);
        }else if (in.equals("0")){
            return false;
        }else {
            System.out.println("输入错误，重新输入");
        }
        return true;
    }
}

---

总结

1.项目设计分层，实体类，dao，service，util。。。。
2.【思考】从JDBC进化到框架，Spring的JdbcTemplate和Druid；
3.【思考】有了前端后从service到servlet连接前后端的交互，jsp等；
4.【权限】在控制台的项目的id号到 cookie–session，过滤器filter；
5.【思考】软件开发业务的重要性，需要搞清需求，弄清业务；