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

最新推荐文章于 2024-06-12 18:56:57 发布

2301_82243493

最新推荐文章于 2024-06-12 18:56:57 发布

阅读量745

点赞数 29

文章标签：单元测试功能测试学习

本文链接：https://blog.csdn.net/2301_82243493/article/details/138928802

版权

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

/\*\*

* 投递阿里巴巴的测试开发或者测试+其他职位的投递者中，工作年限大于2年的人
* @param applyIdList 工作年限大于3年的人的id list
* @param companyId 公司的id
* @param jobIdList 职位的id 的list
* @return 满足条件的人
*/
List 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.流程拆解–实现和业务


从实现的角度，用户输入用户名、密码、选择（应聘者、企业）进行登录。  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/56ca09ee938f4565a4ddea071eb2e3bc.png)  
 从业务的角度：


![在这里插入图片描述](https://img-blog.csdnimg.cn/127ed7abe2b44168b03c9c97bf1e0d8f.png)


### 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 list = dao.findBoss();
Iterator 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.业务的流程解析图


![在这里插入图片描述](https://img-blog.csdnimg.cn/b29e741962364b52a88715e8971423ed.png)


![在这里插入图片描述](https://img-blog.csdnimg.cn/8b66ad31baa948beaa7d000016c11dfa.png)


### 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 companyFindJobByKeyWord(Integer companyId);

/\*\*

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

/\*\*

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

/\*\*

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

/\*\*

* 工作年限大于几年以上的某个求职的投递信息
* 例如：输入 1-测试表示1年以上经历的测试职位的申请记录
* @param companyId 公司id
* @return 查询结果
*/
List 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.业务流程拆解


![在这里插入图片描述](https://img-blog.csdnimg.cn/2cc10cf4854c4826ba043e700f19dbea.png)  
 简历投递的步骤：  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/44368ef52488430c9e35528da0339317.png)


### 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 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(“未通过面试的投递信息”);
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("您投递过的信息如下");

[外链图片转存中…(img-2BrSbJP9-1715789947814)]
[外链图片转存中…(img-Dpu1QUVX-1715789947815)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以戳这里获取

2301_82243493

关注

29
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
Java基础（项目2）——项目案例：控制台的一个云就业平台项目【应聘

Logger.getLogger(this.getClass()).info(“应聘者用户 “+loginEmp.getUsername()+” 登陆”);Logger.getLogger(this.getClass()).error(“招聘者 “+boss.getUsername()+” 重复注册”);Logger.getLogger(this.getClass()).error(“招聘者 “+emp.getUsername()+” 重复注册”);//（企业0，求职者1）//（企业0，求职者1）
复制链接

扫一扫