来，你们想要的打卡功能-51CTO.COM

前言

你的世界多数情况下充满了混沌和单调，你的身体虽然不胖但并不会让你感觉到那么有力量;你的过往乏善可陈，充斥着很多伤心与自我否定，你过往的未来也没有惊喜在场。你想要一场新生，想要一次脱胎换骨，没有行动，一切都是空想，依旧忍受痛苦与弱小。一点一滴的积累，才能感受飞轮转起来时的酣畅淋漓，才会有气势如虹的力量，一点一滴的积累就是需要一个打卡的功能。

[[346092]]

打卡在生活中还是应用挺多的，比如上班打卡，健身打卡，学习打卡...等等，实际上打卡功能开发是挺容易的，让我们来一起实现它吧，让我们自己用着自己开发的功能吧！

为什么写一篇打卡的功能性文章呐?

公司一个系统需要实现的一个小小功能，也是为了方便日后进行回顾以及优化，特此记录下来，话不多说我们来实现它吧。

数据库设计

1. 为什么要设计数据库

节省数据的存储空间
保证数据的完整性
方便根据数据库进行系统的开发

2. 根据需求设计数据库

打卡功能
日志表(打卡用户，打卡项目编号，打卡时间) 这个表中的打卡项目这个字段是非必须的，添加这个字段只是为了方便日后的扩展，其他两个字段都是必须的
项目表(项目编号，项目名称，创建时间) 这个表是非必须的，只是为了方便日后的扩展，可加可不加
统计表(项目编号，总打卡数，连续打卡数，打卡用户，打卡时间) 这个表中的字段除了项目编号这个字段不是必须的，其他都是必须要的基本字段，
我这样设计三张表只是为了方便以后的扩展使用，除了项目表，其他两张表都是最基础的必须要的
首先创建一个数据库 clockin CHARACTER SET:指定数据库采用的字符集,utf8不能写成utf-8 COLLATE:指定数据库字符集的排序规则,utf8的默认排序规则为

utf8_general_ci（通过show character set查看） drop database if EXISTS clockin ; create database clockin CHARACTER SET utf8 COLLATE utf8_general_ci; 
1.

sql 语句如下

DROP TABLE IF EXISTS `clockin_count`; 
CREATE TABLE `clockin_count` ( 
  `id` int(11) NOT NULL AUTO_INCREMENT, 
  `pid` int(11) DEFAULT NULL COMMENT '打卡项目', 
  `sum` int(11) DEFAULT NULL COMMENT '打卡总次数', 
  `cloop` int(11) DEFAULT NULL COMMENT '打卡连续次数', 
  `name` varchar(25) COLLATE utf8_bin DEFAULT NULL COMMENT '打卡人', 
  `dtime` datetime DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP, 
  PRIMARY KEY (`id`) 
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin; 
 
DROP TABLE IF EXISTS `clockin_log`; 
CREATE TABLE `clockin_log` ( 
  `id` int(11) NOT NULL AUTO_INCREMENT, 
  `name` varchar(25) COLLATE utf8_bin DEFAULT NULL COMMENT '打卡人', 
  `pid` int(11) DEFAULT NULL COMMENT '打卡项目', 
  `dtime` datetime DEFAULT NULL COMMENT '打卡时间', 
  PRIMARY KEY (`id`) 
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin; 
 
DROP TABLE IF EXISTS `clockin_project`; 
CREATE TABLE `clockin_project` ( 
  `id` int(11) NOT NULL AUTO_INCREMENT, 
  `pid` int(11) NOT NULL, 
  `project` varchar(25) COLLATE utf8_bin NOT NULL, 
  `dtime` datetime DEFAULT NULL, 
  PRIMARY KEY (`id`) 
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin; 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.

3. 理解清楚数据表之间的映射关系

clockin_log : 日志表，存储用户的每天打卡日志信息，表的数据更新率比较高，特此提出来，作为单独的表使用
clockin_project：项目表，在什么项目上的打卡，不是非必要的，只是为了方便日后的扩展使用，而添加的
clockin_count：统计表，统计日志表中用户的打卡信息，数据相对比较少，提取出来更加直观，查询数据用的比较频繁

实现思路

首先进行判断项目是否存在，存在才能进行打卡，接着判断今天是否已打卡，如果今天没打卡则插入数据，然后判断昨天是否打卡，

昨天如果打卡了则连续天数，总天数都加一，若昨天没打卡，则连续天数设为一，总天数加一，思维导图如下：

这里主要就是sql语句的编写，我这里主要用到了sql中的 LEFT语法，对应了oracle中的substr()，主要是用来判断今天昨天是否打卡

语法： ==LEFT (ARG,LENGTH)== ARG源数据，LENGTH个字符串，ARG可以是CHAR或BINARY STRING

例如：left('12345',2) --> 12

<!-- 查询今天是否打卡--> 
    <select id="selectClockinIsexit" resultType="ClockinLog"> 
        SELECT * FROM clockin_log where name = #{name} and pid = #{pid} 
                   and LEFT(dtime,10) = LEFT(NOW(),10) 
    </select> 
 
<!-- 查询昨天是否打卡--> 
    <select id="selectClockinYesterdayIsexit" resultType="ClockinLog"> 
          SELECT * FROM clockin_log where name = #{name} and pid = #{pid} 
           and LEFT(dtime,10)=LEFT(#{dtime},10) 
    </select> 
 
既由 2020-10-10T10:30:51  得到  2020-10-10 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

主要代码

这里我用到了 MybatisPlus，具体使用可以参照

这里的Result是我定义了一个结果集包含 code —— 状态码，msg —— 返回消息，data —— 数据信息

// name 用户名 pid 项目编号    
public Result clock(String name,String pid){ 
 
        // 返回的数据类型 
        Result<Object> result = new Result<>(); 
 
        // 得到昨天的日期 
        Calendar cal= Calendar.getInstance(); 
        cal.add(Calendar.DATE,-1); 
        Date yesterday=cal.getTime(); 
 
        // 判断今天是否打卡 
        Boolean isexit = clockinLogService. 
                selectClockinIsexit(name, Integer.parseInt(pid)); 
 
        LambdaQueryWrapper<ClockinCount> wrapper = new LambdaQueryWrapper<>(); 
        wrapper.eq(ClockinCount::getName,name).eq(ClockinCount::getPid,Integer.parseInt(pid)); 
        ClockinCount one = clockinCountService.getOne(wrapper); 
 
        LambdaQueryWrapper<ClockinProject> wrapper1 = new LambdaQueryWrapper<>(); 
        wrapper1.eq(ClockinProject::getPid,Integer.parseInt(pid)); 
        ClockinProject project = clockinProjectService.getOne(wrapper1); 
 
        //打卡项目是否存在 
        if (!StringUtils.isEmpty(project)){ 
            if (isexit){// 判断今天是否打卡 
                result.setRetCode(Result.ERROR); 
                result.setRetMsg("今日已打卡"); 
                result.setRowData(one); 
                return result; 
            }else { 
                // 记录打卡信息 
                ClockinLog clockinLog = new ClockinLog(); 
                clockinLog.setName(name).setPid(Integer.parseInt(pid)).setDtime(LocalDateTime.now()); 
                boolean save = clockinLogService.save(clockinLog); 
                if(save){//是否插入数据成功 
                    Boolean yesterdayIsexit = clockinLogService. 
                            selectClockinYesterdayIsexit(name, Integer.parseInt(pid), yesterday); 
                    System.err.println("yesterdayIsexit->"+yesterdayIsexit); 
                    if (yesterdayIsexit){  //判断昨天有没有打卡 
                        System.err.println("昨天打卡了"); 
                        // 更新打卡次数 
                        ClockinCount cc = new ClockinCount(); 
                        LambdaUpdateWrapper<ClockinCount> updateWrapper = new LambdaUpdateWrapper<>(); 
                        updateWrapper.eq(ClockinCount::getPid,Integer.parseInt(pid)).eq(ClockinCount::getName, name); 
                        cc.setSum(one.getSum()+1).setCloop(one.getCloop()+1); 
                        clockinCountService.update(cc,updateWrapper); 
                    }else { 
                        if (!StringUtils.isEmpty(one)){  // 统计表中用户存在否 
                            // 更新打卡次数 
                            ClockinCount cc = new ClockinCount(); 
                            LambdaUpdateWrapper<ClockinCount> updateWrapper = new LambdaUpdateWrapper<>(); 
                            updateWrapper.eq(ClockinCount::getPid,Integer.parseInt(pid)).eq(ClockinCount::getName, name); 
                            cc.setSum(one.getSum()+1).setCloop(1); 
                            clockinCountService.update(cc,updateWrapper); 
                        }else { 
                            // 插入数据信息 
                            ClockinCount cc = new ClockinCount(); 
                            cc.setCloop(1).setName(name).setPid(Integer.parseInt(pid)).setSum(1).setDtime(LocalDateTime.now()); 
                            clockinCountService.save(cc); 
                        } 
                    } 
                    one = clockinCountService.getOne(wrapper); 
                    result.setRetCode(Result.SUCCESS); 
                    result.setRetMsg("成功"); 
                    result.setRowData(one); 
                    return result; 
                } 
            } 
        }else { 
            result.setRetCode(Result.ERROR); 
            result.setRetMsg("失败"); 
            result.setRowData("打卡项目不存在"); 
        } 
        return null; 
    } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.

总结

本文主要介绍了用Java写一个打卡功能的主要过程，打卡主要是记录了一个人阶段性的努力，如果自己的自我规划学习能力不高，自我督促能力不强，那么这个打卡功能就可以完美的解决督促自己进行学习以及其他事情。以上就是本篇文章的主要代码以及思路。

本文授权转载自公众号「良许Linux」。良许，世界500强外企Linux开发工程师，公众号里分享大量Linux干货，欢迎关注!